Agent 记忆像账房

小白先读

先别管那些论文名词。

把 Agent 当成一个替你办事的人。

今天，你叫它帮你改代码。它看了文件，跑了测试，记下哪里错了。

明天，你又叫它接着干。麻烦来了。

它若什么都不记，就像新来的伙计，昨日的账一笔不认。

它若什么都往脑子里塞，又像桌上堆满旧纸，真要用那张，反倒翻不出来。

Agent 记忆要办的事，就夹在这两头中间：

该记的记下，旧账理清，临场只递有用那几张。

所以记忆系统不是仓库。它更像账房、库吏、军师合在一处。它要收账，要理账，还要临阵递账。

换成论文话，才是下面这几句。

Agent 记忆的头一桩，不是向量库，也不是知识图谱。

头一桩是：历史在外头越长越杂，模型眼前只容一小撮。

总矛盾就一句：

过去不断生长，当下只能择要。

往下拆，有六个关口：

1.来源：什么该进来，什么该丢在门外。

2.抽取：原文、摘要、结构化事实，哪样更经用。

3.管理：新记忆怎么进，旧证据怎么留。

4.形态：文本、向量、图、参数，哪种担哪份差。

5.检索：相似不等于有用，找得近还要找得准。

6.注入：给少了不够，给多了添乱。

再横着看，场景也分主次。个性化要记人，编程要记工程现场，网页 Agent 要记状态变化，多 Agent 要记谁说了什么、谁该担责。

最后还得落到实践。换模型，换 prompt，换任务，主次都会动。跑得住，才算真有记忆。

目录

1.小白先读：先把账本这个比方看懂。

2.术语小抄：先把黑话翻成人话。

3.先抓总矛盾：历史在外头长，推理在眼前收。

4.六个关口：来源、抽取、管理、形态、检索、注入。

5.三种功能：事实、经验、工作。

6.方法地图：各篇论文到底抓住哪一头。

7.设计办法：先问场景，再定架构。

8.最后一句：分类帮人看路，实践替人验货。

读法也简单。

赶时间，读"小白先读"，再看"论文为什么各有做法"。

做系统，读"来源"到"注入"那几节。

写方案，读"怎么按主次设计"和"场景是总裁判"。

术语小抄

论文话	先这么理解
Agent	会调用工具办事的小助理
prompt / context	临上场前塞到它手里的纸
token	纸上能写下的字数
向量库	按相似味道找旧纸的抽屉
知识图谱	把人、事、物、关系画成一张网
检索	从旧账里翻几条出来
注入	把翻出来的旧账递给模型
长期记忆	下次还要认的旧账
工作记忆	眼下这件事的桌面

看完这张小抄，再往下读，就不必怕名词。凡是遇见新词，都往这张桌上放。

正文

近来读 Agent 记忆论文，越读越觉得，许多争论一开头就跑偏了。

有人问：该用向量库，还是知识图谱？

有人问：记忆该放 prompt 里，还是放外部库里？

有人问：该做短期记忆，还是长期记忆？

这些都要问。

只是不能先问。

先问这些，像一进门就争锅碗瓢盆，倒忘了今日要做什么饭。

Agent 记忆系统的头一桩，不是"存在哪里"。也不是"取回几条"。

头一桩是：过去不断长出来，眼下只能用一小撮。

Agent 一路行动，一路留下东西：用户说过的话，工具回来的结果，网页当前状态，代码改动，测试失败，计划草稿，自我反省，成功经验，失败路数。越干越多，越多越杂，越杂越旧。

可模型临场推理时，只能吃下一段上下文。哪怕上下文窗口变长，也不是万事大吉。长了，噪声也长。旧账、新账、闲话、证据一齐涌来，模型反倒眼花。

这就是总矛盾：

历史在外头生长，推理在当下收束。

Agent 记忆系统的总矛盾

一头要全，一头要省。

一头要保真，一头要好用。

一头要随时更新，一头又不能把旧证据抹掉。

抓住这根绳，后面才好说。

《Memory in the LLM Era》把记忆系统拆成四环：抽取、管理、存储、检索。又把十种代表方法放到 LOCOMO 和 LONGMEMEVAL 上同场比较。结论很有意思：没有一种方法通吃。高分方法常常更费 token，省 token 方法又常丢准头。上下文从 50% 拉到 200%，多数方法一路掉分。问题不再只是"找不找得到"，而是"能不能在一堆旧账闲话里压住噪声"。

《Memory in the Age of AI Agents》换了个角度，把记忆分成三轴：形式、功能、动态。

形式问：记忆靠什么承载？是明文 token，是参数，是隐状态？

功能问：记忆拿来干什么？是记事实，是学经验，还是维持眼下工作区？

动态问：记忆怎么生、怎么变、怎么取？

两篇放在一起看，就清楚了。

前一篇像流水线。后一篇像地图。

流水线告诉你一条记忆从哪里进来，怎样加工，怎样取出去。地图告诉你这条记忆究竟是什么东西，为谁服务，能活多久。

真正写系统，要把两张图叠起来看。

一、总矛盾下面，还有一串小矛盾

总矛盾不是一句空话。

它往下落，就落成六个关口：

Agent 记忆系统的六个关口

从哪里来  ↓抽成什么样  ↓怎么演化和管理  ↓放成什么形态  ↓怎么检索  ↓怎么注入

每个关口里头，都有自己的主要矛盾。

这也是为什么论文会分出许多路数。

不是大家乱写。

是每个人抓住了不同关口里的不同领头矛盾。

看长对话的人，盯的是用户事实、偏好、承诺、改口。

看软件工程的人，盯的是补丁原因、测试失败、工具轨迹、仓库约束。

看网页和 GUI Agent 的人，盯的是页面状态、观察摘要、动作后果。

看多模态的人，盯的是图像、视频、传感器和时间片。

看自我进化的人，盯的是失败经验怎样化成策略，策略怎样化成技能。

问题不同，主矛盾就不同。

主矛盾不同，方法自然不同。

先把几条路摆在桌上。

方法	抓住哪一处	具体做法
MemoryBank	用户事实怎样积累、衰减	留历史，炼用户画像，用遗忘曲线调权重
MemoChat	长对话怎样少花 token	训练模型写 memo，再取 memo 回答
MemGPT	上下文满了怎么办	把主上下文当内存，把外部库当磁盘，让模型自己调页
Mem0 / Mem0g	对话事实怎样变成可取条目	Mem0 抽摘要和事实；Mem0g 抽实体、关系、时间
A-MEM	零散记忆怎样连起来	写成卡片，带关键词、标签、向量，再反向更新旧卡
Zep	新旧事实怎样带时间	Graphiti 建时间知识图谱，边上带版本和有效期
MemTree	平铺记忆怎样分层	新记忆按语义插进树里，叶子存细节，父节点存摘要
MemoryOS	短中长期怎样迁移	短期 FIFO，中期分页，长期靠热度晋升
MemOS	明文、激活、参数怎样统一	用 MemCube 包住内容、来源、版本，再调度、迁移、融合
Memory-R1	写入规则能不能学出来	训练 ADD、UPDATE、DELETE、NOOP 四个动作
MemAgent	长流怎样压进小窗口	一段段读文档，每步重写固定长度记忆
ReasoningBank	经验怎样长成本事	从成败轨迹里炼策略和避坑条目，再取回来用

这么看，论文不是散的。

它们各自抓住一处绳结。

有的抓来源，有的抓形态，有的抓更新，有的抓检索，有的抓注入。

二、记忆从哪里来：主矛盾是"未来效用"

第一关，记忆从哪里来。

来源太多。

用户聊天是一处。系统消息是一处。工具结果是一处。网页 DOM、GUI 截图、代码 diff、测试日志、终端输出、文件目录、PR 评论，也都是一处。多 Agent 系统里，别的 Agent 说过什么、做过什么，也能进来。视频、语音、传感器流，又是一路。

这一关的主要矛盾，不是"能不能全收"。

全收最容易。

难的是：哪一类东西真会改变往后行动？

不会改行动的，收了只是添乱。

会改行动的，漏了就要出错。

个人助手里，用户事实管全局。姓名、偏好、禁忌、日程、地点、长期目标，少一条，答话就变味。

企业助手里，环境事实管全局。文档版本、权限边界、客户状态、业务规则，少一条，动作就越界。

代码 Agent 里，经验轨迹管全局。为什么改这个文件，哪条测试红了，哪次修法失败，哪条约束不能碰，少一条，就会绕回旧坑。

长任务里，工作记忆管全局。当前计划、未完成子任务、已验证证据、待查假设，少一条，任务就断线。

多模态场景里，观察事实管全局。视频里某个物体何时出现，GUI 上按钮现在在哪儿，导航中哪条路走过，少一条，Agent 就像闭眼摸路。

所以来源这一关，要先问：

哪类信息不进记忆，后面的行动就办不成？

答出来，来源主次就分出来了。

这也解释了论文版图。MemoryBank、Mem0 这一路多从对话里抽用户事实。AMA-Bench 这类盯 agentic trajectory，因为 Agent 真干活时，轨迹里藏着因果。软件工程 memory 关心 repo、测试、diff、issue，因为这些才会改变下一次修复。多模态记忆关心帧、对象、空间状态，因为文字摘要常不够。

MemoryCode 这类编码评测说得更直白。模型单看一条指令能做，塞进一百轮办公闲聊和改口里，准头就大跌。这里要记的不是"聊天内容"，而是未来要执行的 pivot instruction。谁改了需求，谁废了旧约束，谁埋下一条日后才用的编码要求，这些才是主。

MEMTRACK 又换一副场面。Slack、Linear、Git 事件交叉来，时间线里有噪声，也有冲突。它发现 Zep、Mem0 这类后端并不自动救场。为什么？来源主次没分好，取回一堆相似片段，还不等于知道哪个事件管现在这件事。

AMA-Bench 再往 agentic trajectory 上推一步。Agent 自己观察、调用工具、失败、回滚、再试。这里的主矛盾不是"用户说了什么"，而是"哪一步造成了后果"。所以 AMA-Agent 用因果图和工具辅助检索，不只靠相似句子。

同叫记忆，入口不一样。

入口一错，后面全是错账。

三、抽成什么样：主矛盾是"保真"和"可操作"

第二关，记忆获取成什么样。

同一段历史，可以化成许多样子。

可以原封不动留一段 raw log。

可以压成摘要。

可以抽成关键词、标签、用户画像。

可以拆成实体、关系、三元组。

可以写成一条事件链。

可以存成一个 case：当时目标是什么，走了哪几步，哪里成了，哪里败了。

可以炼成一条策略：遇到这种问题，先查哪儿，再试哪儿。

可以进一步化成技能：代码片段、函数、脚本、API 调用、MCP 工具。

还可以不显出来，压进 latent token、embedding、KV cache、LoRA 片段、参数模块。

这一关的主要矛盾，是保真和可操作。

原文最真，却难用。

摘要好用，却会漏。

三元组清楚，却容易把语气、条件、时序削平。

事件链能保因果，却抽取麻烦。

策略轻巧，能迁移；抽错了，便成错方子。

技能最好用，能直接执行；可一旦封装过度，就看不见来龙去脉。

latent 记忆密度高，成本低，还不露明文；坏处也明白：人看不懂，错了难查。

所以不能笼统说"抽取"。

要先问：这段东西往后拿来干什么？

若为了个性化，抽用户画像、偏好、长期约束。

若为了事实问答，抽可核验事实，保留原文证据。

若为了多跳推理，抽实体关系，最好带时间。

若为了代码修复，抽失败原因、触发条件、验证命令、修改位置。

若为了自我进化，抽成 case、principle、workflow、skill。

若为了当前任务不掉线，抽成工作区状态、待办、已证实、未证实。

《Memory in the LLM Era》说抽取大体有三路：直接归档、摘要式抽取、图式抽取。直接归档保真，摘要节省，图式保关系。三者没有谁天然高一等。看的是场面。

直接归档这一路，MemGPT、MemoryBank、MemTree 都用。先把原始消息留下，往后再调页、合并、建树。它的准头在保真。坏处也在这里：原文多了，取错、塞多、位置偏，全会拖累模型。

摘要式抽取这一路，MemoChat、Mem0、A-MEM 都有影子。MemoChat 训练模型按"记下备忘、取回备忘、据此回答"走。Mem0 把对话里的事实和摘要写成可检索条目。A-MEM 更像记卡片：一张卡带上下文描述、关键词、标签、向量，再同旧卡片牵线。

图式抽取这一路，Mem0g、Zep 走得更远。它们要实体、关系、时间。用户搬家，不只是两句自然语言；要变成"用户-居住于-杭州"，并标明新旧状态。业务里客户、合同、权限、工单互相牵扯，图就有用。

经验抽取又是另一套。ExpeL 存成功轨迹和 insight。ReasoningBank 从成功和失败里炼出 strategy item 和 trap warning。Memory-R1 不先写死规则，而是让模型学会 ADD、UPDATE、DELETE、NOOP。它们都在抓一个事：过去的行动怎样变成将来能用的手艺。

闲谈偏好，用摘要和用户事实就够。

代码因果，只靠摘要就薄。

长期人物关系，图式会占便宜。

当前任务状态，结构化 scratchpad 更合手。

这就是抽取这一环里的主次。

四、记忆怎么演化：主矛盾是"更新"和"不毁证据"

第三关，记忆怎么变。

记忆不是写进去就完。

它会重复，会冲突，会过期，会升格，也会腐烂。

《Memory in the LLM Era》把管理拆成五件事：连接、整合、层级迁移、更新、过滤。

连接，是把相关经历牵上线。

整合，是把碎片揉成段、揉成主题、揉成画像。

迁移，是把短期推到中期，再把常用、重要、反复出现的推到长期。

更新，是处理新旧冲突。

过滤，是把没用、重复、过期的压下去。

这一关的主要矛盾，是更新和不毁证据。

用户昨天说"我住上海"，今天说"我搬杭州了"。若直接覆盖，上海这条旧事实没了。若两条一并放出，模型答话就乱。

正确做法不是乱删。

要标时间，标状态，标适用范围。杭州是现址，上海是旧址。旧址不能拿来推荐本地餐馆，却能解释过去订单。

代码里也一样。

某次 patch 失败，不该删。它眼下没用，往后也许能提醒 Agent 别再走那条路。某个测试曾经红，后来绿了。红的证据不该盖掉，应该标成"已解决"。某条架构约束，若后来变了，也要留版本。

记忆系统最怕两种极端。

一种是死账本。什么都留，什么都不改。越用越乱。

一种是活橡皮。新话一来就抹旧话。越用越薄。

好系统要像账房。

旧账归档，新账生效；凭证还在，状态分明。

这也是不同方法分路的地方。

规则更新稳。MemoryOS 这一路靠分层、FIFO、热度、规则迁移，模型肩上的活少些。

LLM 更新灵。MemTree、Zep 这类让模型合并、总结、消解冲突，表达能力强些，也多一分不稳。

Agent 自主管理更自由。MemGPT、MemOS 这类让 Agent 调工具管理记忆，能应付复杂场面，候选一多，也容易工具调用失败、索引打架。

再细看，管理也有五种手法。

连接，是 A-MEM 的要害。新卡片来了，不孤零零放着，要同旧卡片按语义相似连边。往后取一张，可以牵出一串。

整合，是 MemoryBank、MemoChat 的要害。日常闲谈不必条条原封不动进库，合成事件摘要、主题备忘、用户画像，才省地方。

迁移，是 MemGPT、MemoryOS 的要害。MemGPT 把主上下文和外部存储分开，让模型自己调页。MemoryOS 写得更死：短期队列满了，整段对话按 FIFO 推到中期；中期里访问多、近来常用的，再升到长期。

更新，是 Zep、Memory-R1 的要害。Zep 不只覆盖事实，而是给关系加时间版本。Memory-R1 把更新拆成四个动作：加、改、删、不动。它的野心，是把记忆管理从人工规则改成可训练策略。

过滤，是 Mem0、MemoryBank、MemoryOS 的要害。重复的、过期的、不常用的，都要压下去。只是过滤也有刀口。该删的是噪声，不该删的是证据。

所以管理这一环，不是越智能越好。

该写死的，写成制度。

该交给模型判断的，再交给模型。

五、记忆放成什么形态：主矛盾是"看得见"和"跑得动"

第四关，记忆用什么承载。

《Memory in the Age of AI Agents》把形式分成三大类：token-level、parametric、latent。

这三类不是名词游戏。它们各有脾气。

Token-level 记忆，就是明文、条目、文档、图谱、表、树、文件、代码这些看得见的东西。

好处是可查、可改、可审计。出了错，能翻出来看。要删除，能删。要加权限，能加。高风险场景、企业场景、个人偏好、代码仓库，多半离不开它。

坏处是占上下文，费检索，容易噪声堆积。

Token-level 里面还分三种。

平铺的一维记忆，像一串日志、一袋 chunks、一堆经验卡片。简单，便宜，久了会乱。

平面二维记忆，像图、树、表。关系立起来了，能做多跳和因果，维护成本也上来。

层级三维记忆，像短期、中期、长期，多层图，多层摘要。能管粒度，也容易在层层汇总里丢细节。

Parametric 记忆，藏在参数里。

它适合长期规则、风格、领域知识、通用技能。用起来不必每次检索，推理时顺手就带出来。

坏处是难改，难审计。今天用户改了偏好，你不能为他重训一遍模型。某条知识错了，改参数还可能牵动旁的知识。

所以参数记忆适合"常年不变、处处可用"的东西，不适合"某用户刚说、明天可能变"的东西。

Latent 记忆，藏在隐状态、embedding、KV cache、soft token 里。

它密，快，省，有时还更护隐私。长视频、长文档、多模态流、在线推理，都喜欢它。

坏处是看不清。压缩错了，人难查。反复读写，还可能漂。

所以形态这一关的主矛盾，是看得见和跑得动。

要审计、要回滚、要解释，token-level 主。

要泛化、要风格、要稳定行为，parametric 主。

要高密度、低延迟、多模态，latent 主。

真正系统多半混用。

明文记事实，参数记本事，隐状态记眼前。

MemOS 就是把这三样摆到一张桌上。它把明文记忆、激活记忆、参数记忆都包成 MemCube。每个 MemCube 带内容，也带来源、版本、访问记录。能组合，能迁移，能融合。说白了，它不想再让"向量库、KV cache、微调权重"各唱各的，而是想用一套调度制度管起来。

MemAgent 走另一边。它不建外部库，也不求可审计。长文档一段一段进来，模型每看一段，就把固定长度记忆重写一遍。内存不涨，成本按线性走。这个法子适合长流阅读，主矛盾是压缩和吞吐；不适合要查证据、要回滚的企业记忆。

Memanto 又是一条反路。它不追图谱复杂度，而是用十几类 typed semantic memory 先把写入卡住，再用低延迟语义检索取回。它抓住的是生产系统里的主矛盾：不一定要图最漂亮，要快、稳、可控。

各司其职，别拿一把刀切所有菜。

六、记忆怎么检索：主矛盾是"相似"和"有用"

第五关，怎么检索。

这是最容易误会的一关。

许多系统把检索当成向量 top-k。

可相似不等于有用。

用户问："我上次订的是哪家酒店？"相似检索多半够。

用户问："为什么上次修这个 bug 没修成？"只找相似句子就不够。要看时间，要看动作前后，要看工具返回，要看测试怎么红，要看哪一步把事情带歪。

检索这一环的主要矛盾，是相似和有用。

《Memory in the LLM Era》把检索分四路。

字面检索，靠 BM25、关键词、Jaccard。找名字、路径、错误码、函数名，很好用。

向量检索，靠语义相似。找近义表达、偏好、主题、摘要，方便。

结构检索，靠图遍历、树搜索、层级展开。找因果、关系、多跳、时间线，更合适。

LLM 辅助检索，让模型改写查询、抽实体、拆问题、选检索路。复杂问题里有用，但也更费。

固定一路检索，迟早会脆。

名字要字面。

偏好要语义。

因果要结构。

多步任务要路由。

过期事实要看状态。

多模态要看视觉对象、时间段、空间位置。

所以未来更要紧的，不是再争 BM25 和 embedding 谁赢。

而是检索路由：这一次问题，到底该走哪一路？

论文里新三层方案也是这个意思。短期记忆整体取，保证眼前不断；中期记忆用向量找高层语义，又用树搜索摸到底层原文；长期记忆再走向量。不同层级，不同取法。

RMM 把这事往后又推一步。它先建多粒度记忆，按 utterance、turn、session 分层；再用 retrospective reflection 做在线检索修正。取错了，就看引用归因，反过来调检索。它抓的主矛盾不是"写得够不够"，而是"取出来的证据准不准"。

ACON 抓的是注入前那一步压缩。它不满足于手写摘要规则，而是拿"全上下文能成、压缩后失败"的轨迹来复盘，让强模型改压缩指南，再蒸馏给小模型。这里的主矛盾是：删什么不坏事，留什么才救命。

Memanto 把检索做得更像生产工程。它用 typed schema 限制写入，再用 information-theoretic search 做一次低延迟取回。它不追多轮图遍历，追的是一次查询能不能把要紧事实捞上来。

《Memory in the LLM Era》的教训也在这里。Zep 在 LONGMEMEVAL 上跑不完两天，被排除出部分实验。图结构强，不代表工程上一定合算。检索的主矛盾，常常是准头、延迟、成本三者一起算。

这才像系统。

不是一只筷子夹遍全席。

七、记忆怎么注入：主矛盾是"给够"和"别扰乱"

检索出来，还没完。

还要注入。

这一步常被轻看。其实很要命。

取回十条记忆，怎么放进 prompt？放在系统消息，还是用户消息前？按时间排，按轻重排，还是按冲突状态排？摘要在前，原文在后，还是原文只作证据？旧事实和新事实并存时，要不要标谁生效？

这一环的主要矛盾，是给够和别扰乱。

给少了，模型断线。

给多了，模型眼花。

给错顺序，近事压旧事。

给错格式，模型不知哪条该信。

给错粒度，模型还要自己拼图。

注入也有许多变体。

最粗的是直接拼接：把相关片段塞进上下文。快，简单，也最容易噪声大。

稳一点的是结构化注入：用户事实一栏，任务约束一栏，相关证据一栏，过期事实一栏，待验证假设一栏。模型一眼看出层次。

再细一点，是分层注入：短期上下文给全，中期摘要给主题，长期偏好给稳定约束，原始证据只在需要时展开。

再往里走，是隐式注入：soft prompt、memory token、KV cache、adapter、LoRA 片段。它不占明文上下文，效率好，可解释性差。

工具型 Agent 还有一种注入：不是把记忆写成话，而是把记忆变成可调用技能。比如把一次成功流程沉淀成脚本，把工具经验沉淀成 API 说明，把领域套路沉淀成 MCP 工具。此时注入的不是"一段文字"，而是"一项能力"。

ReasoningBank 就偏这一面。它不把旧轨迹整段塞回来，而是炼成可迁移的推理策略和避坑提醒。新任务来，先取几条策略，再让 Agent 动手。对 web 和 SWE 这类任务，"上次哪里绕弯了"比"上次完整聊天记录"更有用。

ExpeL 是早一辈做法。它存成功轨迹，也抽 insight。新任务来，把相近轨迹当 few-shot，再把 insight 放进上下文。好处是简单，坏处是失败教训用得不够，经验池大了也会乱。

Memory-R1 的注入更像一套小账簿。它先让 Memory Manager 整理外部库，再让 Answer Agent 选 top-k 记忆回答。它把"写"和"用"拆开训练，说明注入不是最后一铲土，而是前面写库时就该想到的事。

注入还有时间节奏。

有的任务只在开头取一次，像带一张地图出门。

有的任务中途按需取，像走到岔路再问路。

有的任务每一步都更新工作区，像行军时不断报号。

没有哪种永远最好。

任务短，开头注入够了。

任务长，得间歇检索。

环境变化快，得连续刷新。

一旦注入失手，前面做得再好也白费。

金子取出来，塞进模型眼前时弄成一团泥，照样没用。

八、三种功能，三套主矛盾

到这里，还要再横着看一遍。

记忆不是为"记住"而记住。

《Memory in the Age of AI Agents》把功能分成三类：事实记忆、经验记忆、工作记忆。

这三类各有主矛盾。

事实记忆问：Agent 知道什么？

它管用户偏好、环境状态、历史承诺、文档事实。主矛盾是稳定和变化。稳定了，才有一致性；能变，才不说旧话。用户事实要能更新，环境事实要能对齐，旧事实要能退场。

经验记忆问：Agent 怎样变强？

它管成功案例、失败轨迹、反省、策略、技能。主矛盾是具体和抽象。具体案例有证据，迁移差；抽象原则能迁移，容易空。好的经验记忆，要从 case 到 strategy，再到 skill。先有原始轨迹，再有反省，再有可复用套路，最后才有可执行工具。

工作记忆问：Agent 眼下想着什么？

它管当前目标、计划、约束、中间结果、未完成项。主矛盾是聚焦和连续。太聚焦，丢历史；太连续，噪声淹没当前。长任务里，工作记忆要不断折叠：把旧观察压成状态，把中间结论写成报告，把计划改成清单，把无关分支剪掉。

这三类不能混。

把事实记忆当经验记忆，Agent 只会背资料，不会长本事。

把经验记忆当事实记忆，Agent 会把一次偶然成功当铁律。

把工作记忆当长期记忆，库里全是临时草稿。

把长期事实塞满工作区，模型眼前全是老黄历。

所以做系统时，先分功能，再选形式，再定流水线。

问清楚：“这条记忆是事实、经验，还是工作状态？”

这比问"用不用图"更靠前。

九、论文为什么各有做法

Agent 记忆论文的方法地图

现在再看各路方法，就不乱了。

MemoryBank 像一本用户账。它留历史，也炼用户画像，还用遗忘曲线调记忆强度。它抓的是事实记忆里的矛盾：用户画像要稳，又不能老。今天还爱吃辣，明天胃不好了，系统就得改口。

MemoChat 像按主题写备忘。它训练模型走三步：先写 memo，再取 memo，最后据 memo 回答。它抓的是长对话里的轻量问题：不求把所有细节重建出来，只求少花 token 还能保持一致。

Mem0 是生产长期记忆层。它把对话里有用事实抽出来，存成可检索条目，背后多用向量检索、摘要、更新和过滤。它抓的是"事实能不能被下一次快速捞出来"。Mem0g 往图上走，把实体关系也抽出来，试图补上多跳关系和时间更新。

A-MEM 把记忆写成卡片。新卡片带上下文、关键词、标签、向量，还同旧卡按相似度连线。新卡也能反过来改旧卡。它抓的是"孤立条目怎么长成网络"。这很像做笔记：一张纸不值钱，纸和纸之间的线才值钱。

Zep 用 Graphiti 做时间知识图谱。实体是点，关系是边，边上带时间和版本。它抓的是"什么在什么时候为真"。企业系统里，这个很要紧。合同状态、客户归属、权限边界，不带时间就会出错。

MemGPT 借操作系统的比方。主上下文是快内存，外部存储是慢磁盘；模型通过函数调用自己查、自己写、自己把东西挪进挪出。它抓的是"谁来管上下文"。让模型自己管，灵活；模型一犹豫，记忆函数就漏调。

MemoryOS 也借 OS，但更像写了制度。短期是 FIFO 队列，中期是对话链和分页，长期靠访问频率和近因热度晋升。它抓的是"迁移规则"。少让模型自由发挥，多用明规矩托底。

MemTree 把长记忆长成树。叶子细，父节点粗；新记忆按语义插进去，祖先摘要跟着更新。它抓的是"粒度"。只取叶子，太碎；只取根，太粗。树就是想在粗细之间搭梯子。

MemOS 走得更大。它把明文、KV cache、参数都纳入一套记忆 OS，用 MemCube 包住内容和元数据，再调度、迁移、融合。它抓的是"多种记忆形态怎么统一"。这个方向雄心大，工程代价也大。

Memory-R1 把记忆管理改成可训练动作。ADD、UPDATE、DELETE、NOOP 四个动词，看着朴素，正好打中更新矛盾。它不只问"该取什么"，还问"该写什么、改什么、删什么、不动什么"。

MemAgent 不管外部库，管窗口。长文档一段一段来，每段之后重写固定长度记忆。它抓的是"无限长输入怎么压进有限上下文"。这一路适合长文档流，不适合要审计、要引用原证据的场景。

RMM 抓检索后悔。先建多粒度记忆，再用回看机制修正检索。它关心的不是记忆有没有存，而是答案到底引用了哪条证据，错了怎么改检索。

ACON 抓压缩规矩。它拿失败轨迹来教压缩器：哪些观察不能删，哪些历史可以压，哪些格式会误导模型。它说明一件事：压缩不是越短越好，是删了还不坏事。

ReasoningBank 抓经验升级。它不满足于存成功样例，还把失败也拿来炼"避坑条"。新任务来，取回的是策略，不是整段旧轨迹。它抓的是经验记忆里的主矛盾：具体案例要升成可迁移方法。

《Memory in the LLM Era》最后提出的新三层混合方案，正是这套主次逻辑的一个缩影。它借 MemoryOS 的三层：短期 FIFO 接住新消息，中期承接语义段，长期收纳高热记忆。又借 MemTree 的树：中期记忆既有摘要节点，也能摸回底层原文。检索时，短期全取，中期向量加树搜索，长期向量取。它在 LOCOMO 和 LONGMEMEVAL 上打到最好，平均每轮 token 成本还压到 450 以下。

这说明一件事：强方法往往不是押中某个单点，而是抓住了多个关口的主要矛盾。

来源上不乱收。

形态上不只平铺。

管理上有层次。

检索上分路。

注入上控粒度。

这才打得动长任务。

十、怎么按主次设计

真要做一个 Agent 记忆系统，别先开库。

先问任务。

第一问：这 Agent 靠什么活？

若靠个性化活，用户事实是主。

若靠解决任务活，经验记忆是主。

若靠长程执行活，工作记忆是主。

若靠环境交互活，环境事实是主。

若靠多 Agent 协作活，共享状态和权限边界是主。

第二问：这条记忆从哪里来？

来自用户，还是来自工具？来自环境，还是来自模型自评？来自一次任务，还是跨任务积累？来自文字，还是图像、视频、GUI？

第三问：它该成什么样？

要原文，要摘要，要事实，要图谱，要事件链，要案例，要策略，要技能，要隐状态，还是要参数？

第四问：它会不会变？

会变，就要时间、版本、状态。

会冲突，就要冲突消解。

会过期，就要衰减或归档。

会复用，就要升格。

第五问：它怎样取，怎样给模型？

字面取、向量取、结构取、LLM 取，还是路由后再取？

取回后，是明文塞进去，结构化塞进去，分层塞进去，还是隐式注入？

这几问答清楚，系统轮廓就出来了。

反过来，若一上来就说"我们用图数据库"，多半还没想透。

图能解关系，不解所有问题。

向量能解相似，不解所有问题。

长上下文能多装，不会自动分轻重。

总结能省 token，也会偷走证据。

参数能记本事，不适合天天改用户偏好。

latent 能省，出了错难审。

每件工具都有用，也都有边界。

主次分不清，工具越多，系统越乱。

十一、场景是总裁判

说到底，记忆系统还是要服务场景。

离开场景谈记忆，越谈越玄。

个性化有个性化的记忆。

用户说不吃香菜，系统下回点菜要避开。用户喜欢短答，系统说话就别绕。用户换了城市，推荐、日程、提醒都要跟着换。这里的主矛盾，是偏好和事实怎样稳稳更新，怎样少打扰，怎样别把私事乱传。

MemoryBank、Mem0、Memory-R1 多在这块显身手。MemoryBank 靠用户画像和衰减，Mem0 靠事实条目和检索，Memory-R1 靠学习写、改、删。它们争的不是谁更像人脑，而是谁能把用户事实管得准。

编程有编程的记忆。

这回修 bug，Agent 要记住仓库结构、测试入口、失败日志、补丁思路、回滚原因。下回遇到相似问题，不是背一段聊天记录，而是拿出能用的经验：先跑哪条命令，别动哪个模块，哪个假设上次错了。这里的主矛盾，是经验怎样从轨迹里抽出来，怎样带证据，怎样能复用。

MemoryCode 把这个问题钉住了。单条编码指令，模型常能办；指令藏在多轮会话里，夹着闲话和改口，准头就掉。这里要记的是"将来要执行的约束"，不是整段对话。

MEMTRACK 又把场景往企业里推。Slack、Linear、Git 交错成一条长时间线，里面有状态变更，也有互相打架的信号。它的结论刺人：单接 Zep、Mem0 这类记忆后端，并不必然提升。原因也明白。编程场景主矛盾常在跨平台状态跟踪和冲突消解，不在"多召回几条相似记忆"。

网页操作有网页操作的记忆。

页面会变，按钮会换，登录会过期。这里的主矛盾，是当前状态怎样保住，动作后果怎样接上。

ExpeL、ReasoningBank 这一支更贴近网页和软件任务。ExpeL 把成功轨迹和 insight 留下来。ReasoningBank 再进一步，连失败也炼成避坑策略。WebArena、Mind2Web、SWE-Bench 这类场景里，Agent 常输在同一个坑反复踩。此时记忆要像师傅在旁边提一句：“这路上回走过，不通。”

多模态有多模态的记忆。

视频、图像、语音、位置，不能全化成一句摘要。这里的主矛盾，是怎么压缩而不丢关键观察。

《Memory in the Age of AI Agents》把 Ego-LLaVA、MA-LMM、VideoAgent、Video-RAG、KARMA、Mem2Ego 这类放到多模态记忆里看。它们都在回答同一个问题：图像、视频、物体、地标、路线，哪些要变成文字，哪些要留成视觉或空间状态。若场景是导航，"我刚走过哪条路"比一句风景摘要要紧。若场景是长视频问答，人物何时出现、物体何时移动，比整段剧情概括要紧。

多 Agent 协作又不同。

谁知道什么，谁改过什么，谁有权限，哪条记忆能共享，哪条只能私有。这里的主矛盾，是共享和隔离。

共享记忆不是把所有人的笔记倒进一口锅。多 Agent 里，记忆还要带身份、权限、来源、责任。一个 Agent 的猜测，不能冒充团队共识；一个私有工具结果，也不能随手广播。这里的主矛盾，是协作效率和污染风险。

所以没有一套记忆架构能包打天下。

同样是用户偏好，陪伴助手要记得细，客服系统未必能记太久。

同样是代码轨迹，研究型 Agent 可以保留长日志，生产系统要有权限、脱敏和审计。

同样是摘要，有的模型吃得准，有的模型一见摘要就丢边界；有的模型能按结构化字段办事，有的模型偏爱自然语言；有的模型对长 prompt 还能稳住，有的模型后半截就像没看见。

模型对 prompt 的感知不一样。

这句话很要紧。

同一份记忆，换个模型，效果会变。

同一个模型，换个格式，效果也会变。

写成表格、写成 JSON、写成项目符号、写成叙述段、放在 system 里、放在用户消息前、放在工具结果后，都会变。

所以分类只能帮人看路，不能替人走路。

最后还得实践检验。

跑任务，看结果。改格式，看结果。换检索，看结果。调粒度，看结果。看它是否少犯旧错，是否省 token，是否答得稳，是否能解释，是否越用越贴场景。

能经得住任务，才算好记忆。

经不住，名词再漂亮，也只是纸上热闹。

十二、最后收一句

Agent 记忆系统的主要矛盾，是不断生长、不断变化的历史，和当下有限、脆弱的推理上下文之间的矛盾。

这矛盾往下分，就成了六个关口：

从哪里来，抽成什么样，怎么演化，放成什么形态，怎么检索，怎么注入。

每个关口里，都有主矛盾。

来源关口，看未来效用。

抽取关口，看保真和可操作。

管理关口，看更新和不毁证据。

形态关口，看看得见和跑得动。

检索关口，看相似和有用。

注入关口，看给够和别扰乱。

再横着看，事实记忆、经验记忆、工作记忆，又各有主矛盾。

这几层扣起来，才是 Agent 记忆系统的全貌。

记忆不是仓库。

也不是向量库。

也不是图谱。

也不是一段长 prompt。

真正的记忆，是把过去的事实、经验、状态，按当下任务重新拣出、改写、排好、送到模型手边。该留的留，该合的合，该升的升，该标旧的标旧。该给原文时给原文，该给摘要时给摘要，该给图时给图，该给技能时给技能。

做到了，Agent 才不只是"这次会答"。

它会接着上次往前走。

但这话还要加半句：往哪儿走，要看场景。

个性化走个性化的路。

编程走编程的路。

长对话、网页、多模态、多 Agent，各走各的路。

主次不是写在论文标题里，而是露在任务里，露在失败里，露在一次次实验结果里。

具体事情，具体分析。

实践验得过，才是真的。

学AI大模型的正确顺序，千万不要搞错了

🤔2026年AI风口已来！各行各业的AI渗透肉眼可见，超多公司要么转型做AI相关产品，要么高薪挖AI技术人才，机遇直接摆在眼前！

有往AI方向发展，或者本身有后端编程基础的朋友，直接冲AI大模型应用开发转岗超合适！

就算暂时不打算转岗，了解大模型、RAG、Prompt、Agent这些热门概念，能上手做简单项目，也绝对是求职加分王🔋

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料，手把手帮你快速入门！👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型（GPT、文心一言等）特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架（LangChain等）实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块，看似清晰好上手，实则每个部分都有扎实的核心内容需要吃透！

我把大模型的学习全流程已经整理📚好了！抓住AI时代风口，轻松解锁职业新可能，希望大家都能把握机遇，实现薪资/职业跃迁～

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】