大模型的记忆管理：从记忆外挂到主动管理

2014年以来，模型能读的窗口从几百个token涨到了百万级别，可任务需要的长度也一直在涨，记忆管理始终绕不开。本文按时间顺序梳理大模型记忆管理技术的发展：每个阶段受什么约束，记忆存成什么样，“该不该记”由谁决定。

Q1：窗口越来越长，为什么记忆管理一直没有过时？

因为任务需要的长度，一直跑在窗口前面。2020年我们做CHIME ([1])时，一个问题配10条评论就是1280个token，是BERT最大输入长度512的2.5倍；2023年做MemoChat ([2])时，我们微调开源模型用的序列长度是2048；2026年做ContextPilot ([3])时，用的Qwen3-8B原生支持32K、用YaRN能外推到128K，可是在BrowseComp上跑15轮以上的轨迹里，不做上下文管理的WebExplorer-8B每轮输入照样涨到30K左右。

Q2：“该不该记”为什么这么难？

因为写错的代价，要很久之后才付。Memory-R1 ([4])里有个例子：用户在一次会话里说“我领养了一只狗，叫Buddy”，后来在另一次会话里又说“我又领养了一只，叫Scout”。一个没经过训练的记忆管理器把第二句当成对第一句的更正，执行DELETE+ADD，删掉了Buddy。这一步当时不会报错，对话照常进行，可记忆里已经只剩Scout一条；等到哪天用户问起“我养了几只狗”，错误才会暴露，而离犯错已经过去了好几轮。

Q3：这十几年，记忆管理技术是怎么发展的？

有两点需要说明：（1）这几条路线是先后出现的，但并没有互相取代：2024年底的Titans又回到了可微记忆，RAG式的预建索引今天也还在用；（2）贯穿这几段的是同一个问题：一条信息该不该记，由谁来决定。

Part1：2014-2016年，记忆网络

这一阶段，神经网络开始接上可以读写的外部存储。2014年，Memory Networks ([5])把事实存进一组外部槽位，按问题给槽位打分，挑出相关的几条再生成答案。同年的Neural Turing Machine ([6])把神经网络和一块外部记忆接在一起，通过attention读写，整个系统端到端可微，能从输入输出样例中学会复制、排序这样的简单算法。

Memory Networks有个前提：每道题都要标注好该看哪几条，也就是支撑事实的强监督。2015年的MemN2N ([7])把读取换成soft attention，端到端训练，不再需要逐题标注支撑事实，所需的监督大大减少。2016年的DNC ([8])延续了NTM的思路，让网络读写一块外部记忆矩阵，类比传统计算机里的内存。

这一阶段完成了一件事：“该读哪一条”从人工标注，交给了梯度。

Part2：2019-2022年，在预训练模型外面接记忆

BERT、XLNet等预训练模型成了问答任务的主力，但窗口很短，BERT最多只能读512个token。当时处理长输入大致有三种思路：在模型内部跨片段传递状态，或者在模型外面接一个可微的记忆模块，或者把资料预先存好、用的时候再检索。

第一种的代表是2019年的Transformer-XL ([9])。它提出片段级的循环机制，把前一段的隐状态带到下一段，学到的依赖长度比原始Transformer长450%。XLNet沿用了这套分段机制。

我们在2020年提出的CHIME ([1])属于第二种，关注的任务是Review QA，比如有人问：“这个计时器能设成30秒，用完自动回到30秒吗？”。这里每个问题配了10条评论，有人说能，有人说不能，有人说第一次碰掉就失效了，模型要基于互相矛盾的意见给出一个答案。如果一次读入，问题加10条评论就是 $40+124\times 10=128040+124\backslash times10=1280$ 个token，是BERT最大输入长度512的2.5倍。理论上，XLNet借助Transformer-XL的分段机制可以处理任意长度的文本，但同时读入多条长评论，计算开销很快就承受不了。当时模型的窗口很短，10条全塞进去做不到。我们选择逐条读评论：一是窗口放不下，二是逐条读可以保证外挂的记忆模块对每一条评论都保持同样的全注意力，这比先写个摘要再理解要合适。每读一条，更新一次两块固定大小的记忆：context memory收集跨评论的证据，answer memory持续修正答案。

读第 $kk$ 条评论时，计算过程如下：

• $H^k=\mathrm{X}\mathrm{L}\mathrm{N}\mathrm{e}\mathrm{t}([\mathrm{C}\mathrm{L}\mathrm{S}]q[\mathrm{S}\mathrm{E}\mathrm{P}]r_k[\mathrm{S}\mathrm{E}\mathrm{P}]a[\mathrm{S}\mathrm{E}\mathrm{P}])H^k=\backslash mathrm\{XLNet\}([\backslash mathrm\{CLS\}]~q~[\backslash mathrm\{SEP\}]~r\_k~[\backslash mathrm\{SEP\}]~a~[\backslash mathrm\{SEP\}])$ ，前166个位置记为 $H_c^k\in {\mathbb{R}}^{166\times 768}H\_c^k\backslash in\backslash mathbb\{R\}^\{166\backslash times768\}$ ，后84个位置记为 $H_a^k\in {\mathbb{R}}^{84\times 768}H\_a^k\backslash in\backslash mathbb\{R\}^\{84\backslash times768\}$
• $M_c^1=H_c^{1}M\_c^1=H\_c^1$ ， $M_a^1=H_a^{1}M\_a^1=H\_a^1$ ，读第1条评论时直接初始化两块记忆
• $Z_c^k=\mathrm{T}\mathrm{r}\mathrm{a}\mathrm{n}\mathrm{s}\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{e}\mathrm{r}\mathrm{E}\mathrm{n}\mathrm{c}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{r}(M_c^{k-1},H_c^k)Z\_c^k=\backslash mathrm\{TransformerEncoder\}(M\_c^\{k-1\},H\_c^k)$
• $G_c^k=\sigma (W_{mc}{M}_c^{k-1}+W_{zc}{Z}_c^k+b_c)G\_c^k=\backslash sigma(W\_\{mc\}M\_c^\{k-1\}+W\_\{zc\}Z\_c^k+b\_c)$ ，门控逐位置、逐维度取值在 $[0,1][0,1]$
• $M_c^k=G_c^k\odot M_c^{k-1}+(1-G_c^k)\odot H_c^{k}M\_c^k=G\_c^k\backslash odot\; M\_c^\{k-1\}+(1-G\_c^k)\backslash odot\; H\_c^k$ ， $G_c^{k}G\_c^k$ 越接近1越保留旧证据，越接近0越换成当前评论
• $Z_a^k=\mathrm{T}\mathrm{r}\mathrm{a}\mathrm{n}\mathrm{s}\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{e}\mathrm{r}\mathrm{E}\mathrm{n}\mathrm{c}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{r}(H_a^k,M_c^k)Z\_a^k=\backslash mathrm\{TransformerEncoder\}(H\_a^k,M\_c^k)$ ，注意这里用的是刚更新完的 $M_c^{k}M\_c^k$
• $G_a^k=\sigma (W_{ha}{H}_a^k+W_{za}{Z}_a^k+b_a)G\_a^k=\backslash sigma(W\_\{ha\}H\_a^k+W\_\{za\}Z\_a^k+b\_a)$
• $M_a^k=G_a^k\odot H_a^k+(1-G_a^k)\odot M_a^{k-1}M\_a^k=G\_a^k\backslash odot\; H\_a^k+(1-G\_a^k)\backslash odot\; M\_a^\{k-1\}$
• $L=\mathrm{C}\mathrm{E}(\mathrm{S}\mathrm{o}\mathrm{f}\mathrm{t}\mathrm{m}\mathrm{a}\mathrm{x}(W_{ma}{M}_a^{10}+b_{ma}),y)L=\backslash mathrm\{CE\}(\backslash mathrm\{Softmax\}(W\_\{ma\}M\_a^\{10\}+b\_\{ma\}),y)$ ，读完第10条评论后解码，计算损失

以上梯度回传到每一次写入。虽然损失只在读完第10条评论后算一次，但 $M_a^{10}M\_a^\{10\}$ 依赖 $M_a^{9}M\_a^9$ 和 $M_c^{10}M\_c^\{10\}$ ， $M_c^{10}M\_c^\{10\}$ 又依赖 $M_c^{9}M\_c^9$ 和第10条评论，一路递推回去，所以 $k=2,\dots ,10k=2,\backslash dots,10$ 的每一个门控 $G_c^{k}G\_c^k$ 都能收到最终损失的梯度。读第3条评论时“旧证据留多少、新证据进多少”，会被最终答案的好坏直接修正。

第三种做法干脆不在运行中做写入决策。2020年的RAG ([10])，非参数记忆是预先建好的Wikipedia向量索引，写入在建索引时一次做完，模型只学怎么检索和使用。2022年的Memorizing Transformers ([11])把近期输入的(key, value)全部缓存下来，读的时候用近似kNN检索，外部记忆不回传梯度。这两种做法都绕开了“这次该不该记”的问题，代价是压力转到了检索上。同年的Recurrent Memory Transformer ([12])则走第一种路线，在相邻片段之间传递一组memory token，怎么读写由训练学出来。

小结一下这一阶段：记忆要么是一块人读不懂的向量，写什么交给梯度；要么是一份全存的缓存或索引，写入时不做筛选。

Part3：2023年，让模型自己写备忘录

ChatGPT出来以后，模型已经能写出连贯的长文本，一个自然的想法是：把要记的东西直接写成文字，存在窗口外，需要时再取回来。好处是人能读、能改，还能在模型之间迁移，但代价是梯度没了。模型写下的是离散的token，任务损失传不回“当时为什么写这一句”，于是写入决策需要别的信号来学。这一年的几个代表工作，各用了一种：

• Reflexion ([13])（2023年3月）：用推理时的任务反馈。任务失败后，让模型自己写一段反思存下来，下次尝试时翻出来看，相当于一本错题本，不需要训练。
• Generative Agents ([14])（2023年4月）：在一个仿照《模拟人生》搭的小镇里放了25个智能体。每个智能体用自然语言记下自己的全部经历，随着时间推移把记忆归纳成更高层的反思，规划时再动态检索。写入是全记，筛选发生在归纳和检索的时候。
• MemoryBank ([15])（2023年5月）：用规则。借鉴艾宾浩斯遗忘曲线，按经过的时间和记忆的重要性决定遗忘和强化，像人一样，久不复习就淡忘。
• MemGPT ([16])（2023年10月）：用阈值规则加分层存储，思路借自操作系统的内存管理。主上下文由系统指令、working context和FIFO消息队列组成，外部上下文分为recall storage和archival storage。按论文给的示例配置，输入token超过窗口的70%时，queue manager插入一条memory pressure警告，提醒模型把重要信息写入working context或archival storage；超过100%时，驱逐相当于窗口50%的消息并更新递归摘要，被驱逐的原消息仍完整保存在recall storage中。也就是说，recall storage全存；往working context和archival storage里写什么，由模型根据警告、提示词和函数描述自己决定。

我们在同年8月提出的MemoChat用的是备忘录方法。流程是“记忆-检索-回复”的循环：模型先把对话切成几个topic，写出每个topic的摘要和轮次区间；新问题来了，从memo里挑出相关topic，再把挑中的memo和最近的对话一起交给模型回复。比如一段20轮的对话，前8轮在聊家人，后12轮在打车，模型要写出这样的memo：

MemoChat中Memo Writing的一个例子（20轮对话）

[{'topic': 'worry', 'summary': 'Sabrina is worried about her sister because she hasn't heard from her sister for 2 weeks. user comforts her.', 'start': 1, 'end': 8},
 {'topic': 'taxi conversation', 'summary': 'user takes bot's taxi to the railway station. As user is not rush, bot will drive slowly and carefully.', 'start': 9, 'end': 20}]

一开始我们直接让开源模型按指令写memo、做检索，结果发现当时模型的指令遵循能力不太行，几乎写不出符合格式的结果。所以我们决定针对写memo、检索、带memo对话三个阶段，分别构造指令数据做微调。之所以能用标注，是因为对话场景刚好有现成的“该记什么”：TopiOCQA提供topic切分，DialogSum提供人工摘要。我们从中重构了10,000条指令：写memo 3,046条，检索3,654条，带memo对话3,300条。Vicuna-33B在未微调和用这10,000条指令微调之后的对比：

• topic F1：1.63 → 57.07
• 摘要F1：5.51 → 68.32
• 检索F1：4.25 → 87.79
• 对话BertScore：45.94 → 58.68

可以看到，不经微调的开源模型几乎写不出合格的memo，微调之后就能学会。此外，对于闭源模型，在专家标注的MT-Bench+上，MemoChat-ChatGPT平均70.76，比最强基线MPC-ChatGPT高16.24分。

到这一年年底，“写什么”已经可以交给模型自己去写，但什么时候写、该不该写，靠的还是人定的流程、阈值和标注。

Part4：2024-2026年，窗口变长了，问题没有消失

这两年，窗口到了128K量级，记忆问题看上去可以靠堆窗口解决。可窗口越长越贵。以Qwen3-8B为例，它的模型配置是36层、8个KV头、head_dim为128，按bf16存储，KV Cache大小如下：

• 每个token： $2\times 36\times 8\times 128\times 2\text{B}=147456\text{B}=144\text{KiB}2\backslash times36\backslash times8\backslash times128\backslash times2\backslash text\{B\}=147456\backslash text\{B\}=144\backslash text\{KiB\}$ ，第一个2对应K和V，最后一个2是bf16的字节数
• 128K窗口： $144\text{KiB}\times 131072=18\text{GiB}144\backslash text\{KiB\}\backslash times131072=18\backslash text\{GiB\}$
• 32K窗口： $144\text{KiB}\times 32768=4.5\text{GiB}144\backslash text\{KiB\}\backslash times32768=4.5\backslash text\{GiB\}$

窗口每扩大4倍，KV Cache也扩大4倍，prefill中attention部分的计算量约为16倍。

同时，窗口放得下，不代表用得好。2024年10月的LongMemEval ([17])报告，商用聊天助手和长上下文LLM在持续交互中记忆信息时，准确率下降约30%。它把长期记忆拆成索引、检索、阅读三个阶段，并提出了session分解（调整value的粒度）、用事实扩展key、时间感知的query扩展等优化。

这一时期，大致有四个方向。

(1) 让长窗口算得起：SSA

稀疏注意力是降低长窗口计算量的主要办法：每个query只看一部分key。但它有两个问题：用full attention训好的模型直接换成稀疏推理，会因为训练和推理的分布不一致而掉点（attention gap）；只用稀疏注意力训练，没被选中的token拿不到梯度，效果又追不上full attention（capability gap）。2025年11月，我们提出了SSA ([18])：训练时每一步以相同概率随机选用sparse或full attention，同时算出另一种作为对照，双向对齐两者的输出。我们证明了，对同一个query，full和sparse attention的输出满足 $\parallel h^{\mathrm{f}\mathrm{u}\mathrm{l}\mathrm{l}}-h^{\mathrm{s}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{s}\mathrm{e}}\parallel \le \delta ({\max }_{j\in {\mathcal{S}}^c}\parallel v_j\parallel +\parallel h^{\mathrm{s}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{s}\mathrm{e}}\parallel )\backslash lVert\; h^\{\backslash mathrm\{full\}\}-h^\{\backslash mathrm\{sparse\}\}\backslash rVert\backslash le\backslash delta(\backslash max\_\{j\backslash in\backslash mathcal\{S\}^c\}\backslash lVert\; v\_j\backslash rVert+\backslash lVert\; h^\{\backslash mathrm\{sparse\}\}\backslash rVert)$ ，其中 ${\mathcal{S}}^c\backslash mathcal\{S\}^c$ 是被丢弃的token集合， $\delta \backslash delta$ 是这些token在full attention下的权重之和。也就是说，稀疏注意力造成的attention输出误差，有一个随 $\delta \backslash delta$ 线性增长的上界。

(2) 可微记忆回来了：Titans

2024年底的Titans ([19])设计灵感来自人的长期记忆：违背预期的事，更容易被记住。于是它用“意外程度”来决定写入：

• $k_t=x_t{W}_{K}k\_t=x\_tW\_K$ ， $v_t=x_t{W}_{V}v\_t=x\_tW\_V$ ，把当前输入投影成key和value
• $\mathrm{\ell }({\mathcal{M}}_{t-1};x_t)=\parallel {\mathcal{M}}_{t-1}(k_t)-v_t{\parallel }_2^2\backslash ell(\backslash mathcal\{M\}\_\{t-1\};x\_t)=\backslash lVert\backslash mathcal\{M\}\_\{t-1\}(k\_t)-v\_t\backslash rVert\_2^2$ ，关联记忆损失
• $S_t={\eta }_t{S}_{t-1}-{\theta }_t\mathrm{\nabla }\mathrm{\ell }({\mathcal{M}}_{t-1};x_t)S\_t=\backslash eta\_tS\_\{t-1\}-\backslash theta\_t\backslash nabla\backslash ell(\backslash mathcal\{M\}\_\{t-1\};x\_t)$ ，前一项是过去累积的surprise，后一项是当前的surprise
• ${\mathcal{M}}_t=(1-{\alpha }_t){\mathcal{M}}_{t-1}+S_t\backslash mathcal\{M\}\_t=(1-\backslash alpha\_t)\backslash mathcal\{M\}\_\{t-1\}+S\_t$ ， ${\alpha }_t\backslash alpha\_t$ 控制遗忘，相当于weight decay

这里有两层优化：

• 内层：记忆本身是一个网络，推理时用 $\mathrm{\nabla }\mathrm{\ell }\backslash nabla\backslash ell$ 更新它的参数。 $\mathrm{\nabla }\mathrm{\ell }\backslash nabla\backslash ell$ 衡量当前token有多“意外”， ${\theta }_t\backslash theta\_t$ 决定当前的意外有多少计入更新， ${\eta }_t\backslash eta\_t$ 决定之前累积的意外保留多少。这个信号当下就能算出来，不用等到任务结束。
• 外层： $W_{K}W\_K$ 、 $W_{V}W\_V$ 以及 ${\eta }_t\backslash eta\_t$ 、 ${\theta }_t\backslash theta\_t$ 、 ${\alpha }_t\backslash alpha\_t$ 怎么算，由语言模型损失端到端训练。

也就是说，Titans把“写多少”交给一个即时的自监督信号，再把“这个信号怎么算”交给训练，相当于把延迟反馈拆成了一个即时的问题。作者报告，在needle-in-a-haystack任务上，它能扩展到2M以上的上下文窗口，准确率高于基线。和2020年的CHIME相比，CHIME的门控参数训练完就固定了，记忆是一块状态；Titans的记忆本身是一个网络，推理时还在用梯度更新参数。

(3) 用任务奖励训练记忆操作：Memory-R1

回到开头Buddy和Scout的例子。2025年8月的Memory-R1把记忆操作限定为ADD、UPDATE、DELETE、NOOP四种，用最终答案对不对作为奖励，以PPO和GRPO训练。训练之后，Memory Manager不再先删后加，而是执行一次UPDATE，合并为“领养了两只狗，Buddy和Scout”。作者报告，只用152个训练QA对就超过了强基线。作者也指出，在这之前的系统大多让未经训练的模型按提示词选择记忆操作，没有和答案正确性挂钩的学习信号。

(4) 主动管理整个工作上下文

到了智能体阶段，要管的已经不只是对话历史。一个Agent要连续搜索、阅读、推理，每一轮的工具返回都在往上下文里堆。我们在BrowseComp上统计了至少15轮的轨迹：不做管理的WebExplorer-8B，每一轮都把之前的内容原样带着，输入长度几乎线性涨到约30K token；ContextPilot-8B则稳定在8K～10K。

围绕Agent不断变长的工作上下文，2025年下半年起出现了一批工作。我们把它们分成两类。第一类是被动管理，什么时候压缩、怎么压缩，由预先定好的规则决定：

• ReSum ([20])（2025年9月）：上下文达到token上限时，调用一个外部摘要工具把交互历史压成摘要，再从摘要继续探索。作者报告，不训练时比ReAct提高4.5%；再用ReSum-GRPO训练，把最终奖励广播到切开的每一段轨迹上，又提高8.2%。
• SUPO ([21])（2025年10月）：周期性地用模型生成的摘要压缩工具调用历史，并把摘要也纳入RL，端到端地同时优化工具调用和摘要策略。
• FoldAct ([22])（2025年12月）：指出摘要会改变Agent之后看到的内容，策略一更新，摘要的分布也跟着变，容易形成恶性循环、导致训练崩溃；为此把摘要token和动作token的损失分开计算，并加入完整上下文一致性损失。

第二类是主动管理，把管理动作做成工具，由模型自己决定什么时候用、怎么用。2023年的MemGPT ([16])已经通过工具调用管理记忆，这一时期的代表工作有：

• Sculptor ([23])（2025年8月）：提供三类工具：上下文分片；摘要、隐藏与恢复；精确搜索。不经专门训练就能提升长上下文任务的表现，再用RL进一步优化。
• MemAct ([24])（2025年10月）：把删除、插入这类原地编辑当作策略动作，用端到端RL训练。作者报告，MemAct-RL-14B的准确率与大16倍的模型相当，平均上下文长度减少51%。
• AgentFold ([25])（2025年10月）：每一步执行一次folding，既可以做细粒度压缩、保留关键细节，也可以把整段多步子任务抽象掉。只用SFT，AgentFold-30B-A3B在BrowseComp上达到36.2%，在BrowseComp-ZH上达到47.3%。
• AgeMem ([26])（2026年1月）：把长期记忆和短期记忆的管理统一做成工具，由模型决定何时存、取、更新、摘要或丢弃，用三阶段渐进式RL训练。
• StateLM ([27])（2026年2月）：给模型配上上下文剪枝、文档索引、记笔记等工具。作者报告，在BrowseComp-Plus上最高达到52%，对应的标准LLM只有5%左右。

我们认为这些工作还有三处不足：（1）Sculptor、AgentFold、StateLM这类工作的工具集主要是搜索、删除和摘要，缺少全局规划、长期记忆和自适应压缩；（2）RL探索时把所有管理动作一视同仁，可不同动作对最终结果的影响差别很大；（3）信用分配太粗，整条轨迹的最终奖励被分给每一个中间编辑动作。第三点很普遍，比如ReSum-GRPO把最终奖励广播到各段轨迹，AgeMem的step-wise GRPO也把组内归一化后的最终advantage原样分给同一条轨迹的每一步。

针对这三点，我们提出了ContextPilot，代码和模型都已开源。它管的不只是外部记忆库，而是整个working context。工具共17个，分为感知与规划（analyzeText、checkBudget、plan）、信息检索（buildIndex、searchContext、readChunk、readMultiChunks）、记忆管理（note、updateNote、readNote、memorize、updateMemory、readMemory）、上下文卸载（deleteContext、summarizeContext、compressContext、foldHistory）四类。长上下文QA实验的训练分两步：我们先以Qwen3.5-397B-A17B（thinking模式）为教师，在NovelQA的PublicDomain子集和NarrativeQA的训练集上生成轨迹，保留结果和管理质量都达标的轨迹，按编辑动作切成51,469个snapshot做SFT；再在488道LongBench-v2题上做RL。deep search实验以WebSailor-7B和WebExplorer-8B为底座，它们已经具备基本的搜索能力，所以我们跳过SFT，直接在从OpenSeeker中抽取的1,000道题上做RL。

RL要解决的，正是延迟反馈下的信用分配。我们人工抽样检查了StateLM-8B在BrowseComp+上的轨迹，发现答案对不对，和上下文管得好不好，经常对不上。下面是其中一对：

StateLM-8B在BrowseComp+上的两条轨迹

# 管理很弱，但答对了（gold: Robert D. McBain）
analyze -> index -> search×3 -> readChunk -> search×2 -> readChunk -> ... -> readChunk -> search×2 -> readChunk -> finish
----------------------------------------------------------------
# 管理很规范，但答错了（gold: Frank Leepa，回答: Ty Longley）
analyze -> index -> search -> readChunk -> note -> delete×2 -> search×2 -> readChunk -> updateNote -> delete×2 -> readNote -> finish

第一条一路搜索加阅读，几乎不做整理，最后答对了；第二条记笔记、删冗余、回读笔记，管理得井井有条，最后却答错了。如果把最终对错直接分给每一步，模型学到的会是“别整理，多搜几遍”，第二条里合理的note和delete反而要挨罚。我们的做法分两步。

第一步是Context-Aware Partial Rollout，找出值得多采样的编辑动作：

• $\mathrm{\Delta }{C}_t=\mid \frac{\mathrm{l}\mathrm{e}\mathrm{n}(c_{t+1})-\mathrm{l}\mathrm{e}\mathrm{n}(c_t)}{\mathrm{l}\mathrm{e}\mathrm{n}(c_t)}\mid \backslash Delta\; C\_t=\backslash left|\backslash frac\{\backslash mathrm\{len\}(c\_\{t+1\})-\backslash mathrm\{len\}(c\_t)\}\{\backslash mathrm\{len\}(c\_t)\}\backslash right|$ ，编辑前后上下文长度的相对变化
• $H_t=\frac{1}{k}{\sum }_{i=0}^{k-1}(-{\sum }_{j=1}^V{p}_{t+i,j}\log p_{t+i,j})H\_t=\backslash frac\{1\}\{k\}\backslash sum\_\{i=0\}^\{k-1\}\backslash left(-\backslash sum\_\{j=1\}^\{V\}p\_\{t+i,j\}\backslash log\; p\_\{t+i,j\}\backslash right)$ ，编辑后 $kk$ 个生成token的平均熵， $VV$ 是词表大小
• $\mathrm{\Delta }{H}_t=H_t-H_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{a}\mathrm{l}}\backslash Delta\; H\_t=H\_t-H\_\{\backslash mathrm\{initial\}\}$ ，相对轨迹开头的熵变化
• $\mathrm{s}\mathrm{c}\mathrm{o}\mathrm{r}\mathrm{e}(a_t)=\alpha \mathrm{\Delta }{C}_t+\beta \mathrm{\Delta }{H}_t\backslash mathrm\{score\}(a\_t)=\backslash alpha\backslash Delta\; C\_t+\backslash beta\backslash Delta\; H\_t$ ，编辑动作 $a_{t}a\_t$ 的分数

每个query的预算是 $N=128N=128$ 个snapshot：先做8条轨迹级rollout，每条最多切成8个snapshot（ $M\le 64M\backslash le64$ ），剩下的 $N-MN-M$ 个预算在score最高的动作处分叉，从该动作的父节点开始补采后续轨迹。

第二步是Fine-Grained Credit Assignment，按分支估计每个snapshot的回报：

• $R(S_M)=R_{\mathrm{o}\mathrm{u}\mathrm{t}}+R_{\mathrm{f}\mathrm{m}\mathrm{t}}+R_{\mathrm{p}\mathrm{e}\mathrm{n}}R(S\_M)=R\_\{\backslash mathrm\{out\}\}+R\_\{\backslash mathrm\{fmt\}\}+R\_\{\backslash mathrm\{pen\}\}$ ，终止snapshot的回报，三项分别是答案正确性、格式和非法调用/超长惩罚
• $R(S_i)=\frac{1}{\mathrm{\mid }\mathcal{T}(S_i)\mathrm{\mid }}{\sum }_{T\in \mathcal{T}(S_i)}R(T)R(S\_i)=\backslash frac\{1\}\{|\backslash mathcal\{T\}(S\_i)|\}\backslash sum\_\{T\backslash in\backslash mathcal\{T\}(S\_i)\}R(T)$ ，中间snapshot的回报， $\mathcal{T}(S_i)\backslash mathcal\{T\}(S\_i)$ 是以 $S_{i}S\_i$ 为前缀的所有终止轨迹
• ${\widehat{A}}_i=\frac{R(S_i)-\mathrm{m}\mathrm{e}\mathrm{a}\mathrm{n}(\{R(S)\mid S\in \mathcal{G}\})}{\mathrm{s}\mathrm{t}\mathrm{d}(\{R(S)\mid S\in \mathcal{G}\})}\backslash hat\{A\}\_i=\backslash frac\{R(S\_i)-\backslash mathrm\{mean\}(\backslash lbrace\; R(S)\backslash mid\; S\backslash in\backslash mathcal\{G\}\backslash rbrace)\}\{\backslash mathrm\{std\}(\backslash lbrace\; R(S)\backslash mid\; S\backslash in\backslash mathcal\{G\}\backslash rbrace)\}$ ， $\mathcal{G}\backslash mathcal\{G\}$ 是同一query下的所有snapshot，组内归一化后用GRPO优化

直观地说，一次删除好不好，不看这一条轨迹的结局，而是从删除那一步重新出发多走几次，看平均走得怎么样。

可以看到，同样的工具、同样的32K窗口，Qwen3-8B不经训练平均27.61分，经过SFT和RL之后的ContextPilot-8B-RL平均69.40分：工具给了，不等于会用。它也高于不用工具、直接开128K窗口的45.93分，不过两者的窗口和训练都不同，这组数只能说明窗口更大并没有换来更好的结果。工具设计的消融我们在Qwen3.5-397B-A17B上做，逐项加入planning、soft offloading和长期记忆工具，平均分从77.89依次到80.29、83.08、87.16，按这个顺序长期记忆一项最多（+4.08）。在deep search任务上（BrowseComp、BrowseComp-ZH、GAIA、xBench-DeepSearch），以WebExplorer-8B为底座，ContextPilot平均50.10，SUPO为49.09，ReSum为45.11，ReAct为42.90。

做完ContextPilot回头看CHIME，我们发现两者在回答同一个问题：某一次写入，对最终结果到底有多大影响？只是手段完全不同：

• CHIME：对给定的训练样本， $\mathrm{\partial }L\mathrm{/}\mathrm{\partial }{G}_c^k\backslash partial\; L/\backslash partial\; G\_c^k$ 由反向传播精确算出，这一步不需要采样
• ContextPilot： $R(S_i)R(S\_i)$ 是对 $S_{i}S\_i$ 之后期望回报的蒙特卡洛估计，再经组内归一化后作为GRPO的advantage。我们在附录A中证明，在同一个snapshot下，若各分支从同一分布条件独立采样且方差有限，单条轨迹估计的方差为 ${\sigma }^2\backslash sigma^2$ ， $nn$ 条分支平均为 ${\sigma }^2\mathrm{/}n\backslash sigma^2/n$

Part5：下一步，回头看参数化记忆

前面这些工作，处理的都是推理时送进来的信息。可模型即使什么都不检索，也会凭预训练写进参数的知识作答。对于长尾事实，不同来源的说法常常不一致，比如特蕾莎修女的生日：

ElephantBench中的一个例子

来源A（IMDb）：Mother Teresa was born on August 26, 1910 ...
来源B（Poem of Quotes）：Mother Teresa ... was born in Skopje, Macedonia on August 27th, 1910.
问题：What birth date was reported for Mother Teresa?
答案：① August 26, 1910  ② August 27, 1910

两个日期都有出处。一个只记得8月26日的模型，答案本身没错，但它就像盲人摸象，摸到了一条腿，就以为这是整头象。2026年，我们构建ElephantBench ([28])来测这种情况，它是一个闭卷知识探针，数据和排行榜都已公开。构建时，我们反过来用数据过滤：用DCLM的fastText质量分类器给RePro数据打分，专门保留低分部分作为低曝光语料，再从中挖出自然存在的分歧，最后得到1,094道题，每个答案都对回原始文档和权威公开来源核验，并经人工审核。评测时不给来源文档，不给检索，也不给工具。每个回答分为完整召回 $CC$ 、部分召回 $PP$ 和召回失败 $FF$ ， $C+P+F=1C+P+F=1$ ，另外报告条件完整度 $K=C\mathrm{/}(C+P)K=C/(C+P)$ ：

注意到表中这几个模型的 $FF$ 都很低， $PP$ 很高：它们几乎总能说出至少一种说法，问题出在说不全。哪一种说法被记住，和语料里谁曝光得多有关。我们对每组分歧统计了支持两种说法的文档数，联合回归显示：

• 多数说法的曝光增加一个标准差： $PP$ 上升14.18个百分点， $FF$ 下降10.17个百分点
• 少数说法的曝光增加一个标准差： $CC$ 上升15.13个百分点， $PP$ 下降15.41个百分点

也就是说，多数说法的曝光，主要和模型能不能想起这件事相关；少数说法的曝光，主要和能不能想全相关。请注意，这是相关性分析；闭卷结果也分不清，少数说法是根本没学到，还是学到了但没被问题唤起。

这对外部记忆的设计有一个推论：如果让模型自己决定什么时候检索，那么“只答出主导说法、答的又没错”的情况可能不会触发检索，最需要外部记忆补上的少数说法反而被漏掉。

参考文献

【1】CHIME：Lu, Junru, et al. "CHIME: Cross-passage Hierarchical Memory Network for Generative Review Question Answering." Proceedings of the 28th International Conference on Computational Linguistics (2020): 2547-2560.

【2】MemoChat：Lu, Junru, et al. "MemoChat: Tuning LLMs to use memos for consistent long-range open-domain conversation." arXiv preprint arXiv:2308.08239 (2023).

【3】ContextPilot：Pan, Zhuoshi, et al. "ContextPilot: Teaching Agents for Proactive Context Management via Fine-grained RL." To appear in Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing (2026). arXiv:2608.28476.

【4】Memory-R1：Yan, Sikuan, et al. "Memory-R1: Enhancing large language model agents to manage and utilize memories via reinforcement learning." arXiv preprint arXiv:2508.19828 (2025).

【5】Memory Networks：Weston, Jason, Sumit Chopra, and Antoine Bordes. "Memory networks." arXiv preprint arXiv:1410.3916 (2014).

【6】NTM：Graves, Alex, Greg Wayne, and Ivo Danihelka. "Neural turing machines." arXiv preprint arXiv:1410.5401 (2014).

【7】MemN2N：Sukhbaatar, Sainbayar, et al. "End-to-end memory networks." Advances in Neural Information Processing Systems 28 (2015).

【8】DNC：Graves, Alex, et al. "Hybrid computing using a neural network with dynamic external memory." Nature 538.7626 (2016): 471-476.

【9】Transformer-XL：Dai, Zihang, et al. "Transformer-XL: Attentive language models beyond a fixed-length context." Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics (2019): 2978-2988.

【10】RAG：Lewis, Patrick, et al. "Retrieval-augmented generation for knowledge-intensive NLP tasks." Advances in Neural Information Processing Systems 33 (2020).

【11】Memorizing Transformers：Wu, Yuhuai, et al. "Memorizing transformers." International Conference on Learning Representations (2022).

【12】RMT：Bulatov, Aydar, Yuri Kuratov, and Mikhail Burtsev. "Recurrent memory transformer." Advances in Neural Information Processing Systems 35 (2022).

【13】Reflexion：Shinn, Noah, et al. "Reflexion: Language agents with verbal reinforcement learning." Advances in Neural Information Processing Systems 36 (2023).

【14】Generative Agents：Park, Joon Sung, et al. "Generative agents: Interactive simulacra of human behavior." Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (2023).

【15】MemoryBank：Zhong, Wanjun, et al. "MemoryBank: Enhancing large language models with long-term memory." Proceedings of the AAAI Conference on Artificial Intelligence 38.17 (2024): 19724-19731.

【16】MemGPT：Packer, Charles, et al. "MemGPT: Towards LLMs as operating systems." arXiv preprint arXiv:2310.08560 (2023).

【17】LongMemEval：Wu, Di, et al. "LongMemEval: Benchmarking chat assistants on long-term interactive memory." International Conference on Learning Representations (2025).

【18】SSA：Shen, Zhenyi, et al. "SSA: Sparse Sparse Attention by Aligning Full and Sparse Attention Outputs in Feature Space." Proceedings of the 43rd International Conference on Machine Learning (2026).

【19】Titans：Behrouz, Ali, Peilin Zhong, and Vahab Mirrokni. "Titans: Learning to memorize at test time." arXiv preprint arXiv:2501.00663 (2024).

【20】ReSum：Wu, Xixi, et al. "ReSum: Unlocking long-horizon search intelligence via context summarization." arXiv preprint arXiv:2509.13313 (2025).

【21】SUPO：Lu, Miao, et al. "Scaling LLM multi-turn RL with end-to-end summarization-based context management." arXiv preprint arXiv:2510.06727 (2025).

【22】FoldAct：Shao, Jiaqi, et al. "FoldAct: Efficient and stable context folding for long-horizon search agents." arXiv preprint arXiv:2512.22733 (2025).

【23】Sculptor：Li, Mo, et al. "Sculptor: Empowering LLMs with cognitive agency via active context management." arXiv preprint arXiv:2508.04664 (2025).

【24】MemAct：Zhang, Yuxiang, et al. "Memory as action: Autonomous context curation for long-horizon agentic tasks." arXiv preprint arXiv:2510.12635 (2025).

【25】AgentFold：Ye, Rui, et al. "AgentFold: Long-horizon web agents with proactive context management." arXiv preprint arXiv:2510.24699 (2025).

【26】AgeMem：Yu, Yi, et al. "Agentic memory: Learning unified long-term and short-term memory management for large language model agents." Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (2026).

【27】StateLM：Liu, Xiaoyuan, et al. "The Pensieve paradigm: Stateful language models mastering their own context." International Conference on Learning Representations (2026).

【28】ElephantBench：Pan, Zhuoshi, et al. "Blind Men and the Elephant: Probing the Epistemic Myopia of LLMs under Long-Tail Divergent Knowledge." arXiv preprint arXiv:2608.28478 (2026).