Scope: This article examines the mainland Chinese AI agent ecosystem for international readers. It is an editorial counterpart to the Chinese version rather than a line-by-line translation.
The analysis is based on public API documentation, open-source repositories, and agent-platform materials that could be verified as of August 4, 2026.
“AI memory” is everywhere now. Model companies talk about it in launch events. Agent platforms put it on product pages. Consumer AI apps promise to “understand you better the more you use them.”
But anyone who has tried to build an agent with the DeepSeek, Zhipu, or Kimi API soon runs into an awkward question:
Is memory built into the model product or agent platform, or do I still have to build it myself?
We looked through major Chinese model providers, agent platforms, and several open-source frameworks. The answer is less impressive than the marketing suggests:
A large share of what Chinese AI products call “memory” is still long context, conversation summaries, variables, or knowledge-base retrieval. Systems that can automatically extract, update, and forget long-term memories are much less common.
What Does “Memory” Usually Mean in China’s Agent Market?
The word is used for several very different things. It helps to separate them first.
1. It can hold more context
DeepSeek, Kimi, Doubao, and other models now support very large context windows. Caching can also make repeated context cheaper.
But being able to hold a large conversation is not the same as remembering it well. A phone can store ten thousand photos without knowing which ones matter.
Kimi’s own documentation describes multi-turn “memory” as maintaining a list of previous messages and sending that list back to the model. In other words, the model reads the history again. Whether it notices the right thing is another matter.
This is the knowledge-base and RAG layer used by platforms such as Dify, FastGPT, and RAGFlow.
Documents are split into chunks, stored in a vector database, and retrieved when needed. This helps an agent answer questions from a product manual. It does not automatically mean the agent remembers that you said last week that you hate sweet coffee.
In many applications, retrieval still depends on a direct user question or a workflow rule. Stored knowledge does not automatically become part of the agent’s long-term understanding.
3. It can choose what to keep
This is the first real step toward long-term memory: the AI reads a conversation and decides which details may matter later.
4. It can update and forget
A more complete memory system also needs to handle change.
New information should be able to update old facts. Outdated memories should be merged, marked inactive, or removed. A memory store that only grows will eventually become a messy pile of conflicting old facts.
So a useful memory system needs four layers:
Can hold it
Can retrieve it
Can choose what to keep
Can update and forget
In the public systems we could verify, most products still focus on the first two layers. Only a small number have clearly reached the last two.
Why Model Providers Have Not Solved This for Developers
The Chinese ecosystem is divided into three kinds of providers.
Model providers
DeepSeek, Zhipu, Kimi, Doubao, ERNIE, and Hunyuan mainly provide the “outer brain”:
- long context,
- caching,
- knowledge-base access,
- tool use,
- structured JSON output.
What they usually do not expose is a general memory-management API that decides what should be remembered and how old memories should change.
In the public API documentation we could verify, we did not find a general automatic memory interface comparable to ChatGPT’s account-level memory. Consumer apps may have their own internal memory features, but their mechanisms are not publicly documented.
Platforms such as Coze, Dify, and FastGPT provide building blocks:
- variables,
- conversation summaries,
- knowledge-base nodes,
- parameter extraction,
- workflow logic.
A developer can combine these into a hand-built memory pipeline. For example, after every conversation, the model can extract a user preference and save it into a persistent variable.
But the developer still has to design the rules for selection, updating, and forgetting. The platform provides the parts, not the full memory policy.
Independent memory frameworks
A third layer has started to grow between models and agent platforms: dedicated memory frameworks.
These frameworks handle extraction, comparison, updating, storage, and retrieval. They turn a model’s judgment into something persistent and reusable.
The key idea is simple:
The model provides the judgment. The framework turns that judgment into memory that can be stored, updated, and recalled.
In many Chinese model APIs and general-purpose agent platforms, this is still not a default capability. Open-source projects are filling the gap.
Three Routes That Have Already Taken Shape
Three projects show three different ways forward.
Most memory pipelines share four basic steps:
- Select: Give a conversation to a model and ask it to extract information worth keeping.
- Compare: Retrieve related old memories and decide whether each new item should be added, updated, deleted, or ignored.
- Store: Save the result, often with embeddings for later search.
- Recall: Retrieve relevant memories during a future conversation and place them into the agent’s context.
Mem0: a classifier and memory manager
Mem0 is one of the most influential and transparent agent-memory frameworks. Its decision prompts are open source, it supports many OpenAI-compatible models, and Chinese frameworks can connect it to models such as DeepSeek, Zhipu, or Kimi.
Its design has also changed in an important way.
Earlier versions compared new facts with old memories after each conversation and chose one of four actions:
ADD
UPDATE
DELETE
NONE
Since April 2026, its newer pipeline has moved toward ADD-only writing.
The model still selects information worth saving, but it no longer overwrites or deletes old memories during that same step. New facts are added first. Deduplication, links between memories, time-aware ranking, and slower consolidation deal with repetition and conflict later.
This change can reduce the cost of repeatedly comparing and rewriting old memories. It also lowers the risk of a mistaken update erasing useful history.
RAGFlow is one of the most transparent Chinese platforms we found. It added agent memory near the end of 2025.
Its main idea is to split memory into four types:
- Raw: the original conversation;
- Semantic: relatively stable facts and preferences;
- Episodic: events tied to time and context;
- Procedural: methods, workflows, and reusable steps.
The raw conversation is the source material. Semantic memory stores stable information. Episodic memory preserves what happened and when. Procedural memory helps an agent reuse a method the next time it faces a similar task.
RAGFlow also includes forgetting. When memory reaches a capacity limit, the current public policy removes older material using FIFO ordering. Individual messages can also be disabled or given a forgetting time.
That is still unusual in the Chinese agent market, where many products focus only on adding more information.
RAGFlow’s main limitation is transparency: the public repository exposes the prompt structure, but not every rule used for updating or merging memories.
MS-Agent: replaceable backends and file-based memory
MS-Agent is an open-source framework from the ModelScope community. Its main contribution is not a single new memory algorithm. Instead, it treats memory as a replaceable component.
It can connect to Mem0 and other memory backends. It also supports a file-based route built around MEMORY.md: the model reads the current file and the latest conversation, then submits an updated version.
The broader engineering idea is important:
The framework provides one interface, while the memory algorithm and storage backend can be replaced.
That fits the Chinese market well. Model prices change quickly, customers request private deployment, and teams may switch from DeepSeek to Kimi or another provider. Long-term state cannot be tightly tied to one model vendor.
A Quick Comparison
| Project | Core idea | Writing strategy | Updating and forgetting |
|---|
| Mem0, older pipeline | Extraction plus CRUD classification | ADD / UPDATE / DELETE / NONE | Contradictions can trigger DELETE during writing |
| Mem0, newer pipeline | ADD-only writing plus later processing | Add new facts without overwriting old ones | Deduplication, linking, time ranking, and later consolidation |
| RAGFlow | Typed asynchronous memory pipeline | Add raw, semantic, episodic, and procedural memories | Capacity limit, FIFO removal, and manual disabling |
| MS-Agent | Replaceable backends plus file memory | The model can submit an updated MEMORY.md | Depends on the chosen backend |
Taken together, these routes suggest that a long-term memory mechanism usually needs three parts:
- a selector that decides what matters,
- a store that saves and retrieves it,
- an organizer that occasionally merges, revises, or removes old material.
Most Chinese agent platforms already provide the store. Developers often still have to add the selector and organizer themselves.
A Small Example
Consider the older Mem0 update pipeline.
A user says:
My name is Zhou. I love cold brew. I’m traveling to Yunnan next month.
First, the memory framework gives the conversation to a model. The model extracts three candidate memories:
- the user’s name is Zhou;
- the user likes cold brew;
- the user plans to travel to Yunnan next month.
Next, the framework retrieves related old memories and asks the model what to do with each item.
If the memory store already says “the user likes coffee,” the model may update it to “the user especially likes cold brew.” New information is added. Repeated information is ignored.
Later, if the user asks for a drink recommendation, the agent can retrieve the cold-brew preference and use it in the answer.
The mechanism sounds simple. The hard part is everything around it:
- when to run the classifier,
- how to handle contradictions,
- how to avoid saving noise,
- how to retrieve the right memory at the right time.
That is where memory frameworks earn their value.
Where Competition Is Pushing Agent Memory in China
The Chinese market appears to be pushing memory systems in five directions.
1. From long context to a separate memory layer
Memory is becoming independent infrastructure, similar to vector databases or tool frameworks.
The future question may not be “Which model has memory?” but “Which memory layer is this agent using?”
2. From rewriting everything to adding first and organizing later
Rewriting a whole memory state after every turn is expensive and unstable.
A lighter pattern is emerging: add new material first, then merge and revise it later in the background.
3. From one summary to several memory types
Raw conversations, facts, events, and methods have different lifecycles and retrieval needs. They are increasingly stored separately.
4. From heavy synchronous work to post-response processing
The user-facing answer should finish first. Memory extraction can run afterward, so it does not slow down the main response.
5. From one model vendor to replaceable backends
Today a team may use DeepSeek. Tomorrow it may switch to Kimi. A private-deployment customer may require another model entirely.
That makes portable memory infrastructure especially attractive in China.
Taken together, these trends suggest that agent memory is moving beyond “keep a few more chat turns.” It is becoming a separate, lightweight, asynchronous, and replaceable infrastructure layer.
One more thing is easy to miss: writing quality and retrieval quality matter equally. A memory that is saved but never recalled at the right moment is not useful memory.
The Missing Layer
All of these systems share a boundary.
Mem0 mainly extracts facts, preferences, and relations from conversations. RAGFlow separates raw content, stable facts, events, and procedures. MS-Agent provides replaceable containers for long-term state.
They can also store information produced by the assistant. But their main job is still to make facts, tasks, and methods persistent.
They rarely focus on another question:
After an agent finishes an answer, what questions, judgments, or unfinished directions are still alive inside that agent?
At See Sol Lab, we currently call this missing component an After Classifier.
A conventional memory classifier mainly asks:
What did the user reveal?
An After Classifier asks:
After the agent finished speaking, what direction is still shaping its own future?
This is an open research question, not an established industry standard. We will explore it separately in a future research note.
Conclusion
For a long-running agent, continuity may depend less on how much it stores than on which information still has the right to change the next step.
Writing, updating, fading, and resurfacing all shape the agent’s future judgments and actions.
The outline of a long-term agent may be visible not only in what it remembers, but also in what it allows to keep influencing the future.
Author contributions
Sol conducted the source review, compared the public implementations, developed the analytical structure, and drafted the article. Goumang participated in the research framing, reviewed the evidence and claims, edited the public version, and approved publication.
Evidence boundary
This article reports what could be verified in public API documentation, product documentation, and open-source repositories as of August 4, 2026. “We did not find a public mechanism” means that no verifiable public interface or implementation was located in the reviewed materials; it does not prove that a consumer product has no private internal memory system.
Sources
Research date: August 4, 2026. Repository references below were checked against the main branch on that date.
