Tencent introduces Hy Memory 2.0, persistent memory for AI agents and coding assistants

Tencent unveils Hunyuan Memory 2.0, an open-source system enabling AI agents to retain their knowledge, decisions, and modifications across multiple sessions.

A coding assistant that remembers why a previous change was made, an agent that retains user preferences, or multiple AI applications retrieving information from a shared work history. With Hy Memory 2.0, Tencent Hunyuan introduces a persistent memory infrastructure for AI agents. The release separates memory into three environments, conversations, professional work, and software development, each with its own storage and retrieval methods. It also introduces MemHub, a local-first application for bringing together histories from different assistants, and Hy-Memory-30B-A3B, a specialized model for deciding what information should be retained and updated over time. Memory Beyond the Conversation Window

AI agents can process long conversations and retrieve documents, but remembering information weeks after it first appeared presents a different challenge.

Preserving complete conversation histories is not always sufficient. A decision may have changed, a preference may no longer be relevant, and a technical solution may belong to an earlier code version.

Conventional retrieval systems can locate relevant passages, but they do not necessarily determine which information deserves long-term storage or how that information should evolve.

Hy Memory addresses this through a structured memory architecture.

Instead of storing everything in a single collection, it organizes information according to the kind of activity performed.

Version 2.0 introduces three primary environments: Chat, Working, and Coding.

The objective is to help agents retrieve not only what was said, but also what was done, which approaches worked, and how decisions changed over time. Three Types of Memory for Different Tasks

Chat handles conversations and personal information that may remain useful over extended periods.

It stores facts, preferences, summaries, and relationships between different pieces of information.

Working covers productivity tasks, including document creation, research, data analysis, content production, and application use.

It separates session-specific facts from reusable experiences that may help with similar tasks in the future.

For example, an agent may record that a report was produced using a particular method, while separately preserving the steps that solved a recurring problem.

Coding adapts this approach to software development.

It retains programming decisions, affected files, and the evolution of successive code modifications.

Each environment has specialized mechanisms, avoiding the assumption that conversational facts, reusable workflows, and source-code changes should all be stored identically. An Eight-Level Hierarchy for Conversational Memory

For conversational tasks, Hy Memory uses a hierarchy of eight levels, from L0 through L7.

The lower levels cover general information, raw conversations, atomic facts, and session summaries.

Higher levels are reserved for more abstract representations, including knowledge schemas and future intentions.

Atomic facts allow individual pieces of information to be stored separately instead of being buried inside a general summary.

The system can also account for changes between different versions of a fact, reducing the risk of treating outdated information as current.

Future intentions have an additional property: they can include an expiration date.

Once an intention is no longer prospective, it can be converted into an ordinary fact.

The architecture combines two processes. One supports extracting and retrieving information, while the other organizes broader relationships across accumulated knowledge.

Tencent describes the approach as a dual-process cognitive memory system, drawing on the distinction between fast processing and more deliberate reasoning.

Some hierarchy levels remain reserved in the current implementation, however, and should not be interpreted as eight fully implemented independent memory systems. Reusable Experiences for Productivity Agents

Working memory introduces a distinction between session facts and reusable experiences.

For each session containing tool interactions, Hy Memory can preserve a fact describing the task, the approach taken, and the outcome.

It can also extract multiple experiences describing solutions that may be useful in future work.

Unlike session facts, reusable experiences must meet additional value criteria before they are retained.

An experience may include the original task, retrieval keywords, the solution, environmental constraints, and confidence information.

The two layers are linked, allowing an agent to trace a reusable method back to the session that produced it.

Hy Memory also maintains progression information for facts that have been replaced or superseded.

This design gives productivity agents a memory of working methods rather than limiting retrieval to conversation summaries. Remembering How Code Changed

In software development, remembering that a file was modified is only part of the problem.

An agent may need to understand why a function changed, which alternative implementation was previously considered, or why an earlier version was reverted.

Hy Memory 2.0 introduces a version-evolution chain, also called a diff chain.

The system preserves actual code changes and associates them with files, functions, branches, and workspaces.

Changes can come from local Git differences or deterministic replacement operations found in tool traces.

This allows agents to recover modifications that no longer appear in the current project version.

For example, a coding assistant could examine why an earlier implementation was removed before suggesting a similar change.

Tencent emphasizes that the chain does not replace memory retrieval. Instead, it attaches relevant technical history to facts that have already been retrieved.

Information is also isolated by user, workspace, and branch to reduce unwanted mixing between separate development environments. MemHub Connects Memory Across AI Applications

Another part of the release is MemHub, a desktop and