【论文阅读】Agent 记忆机制（102）：UMA——用多个未来问题端到端训练一份共享记忆

文章目录

• 前言
• 零、论文基本信息
• 一、背景与问题：长上下文为什么仍然不会"记账"
• • [1. 长上下文解决的是"装得下"，不是"状态维护"](#1. 长上下文解决的是“装得下”，不是“状态维护”)
  • [2. RAG 擅长找片段，却不天然擅长维护隐状态](#2. RAG 擅长找片段，却不天然擅长维护隐状态)
  • [3. Query-conditioned Memory 与 Query-agnostic Memory](#3. Query-conditioned Memory 与 Query-agnostic Memory)
• [二、相关工作：UMA 改变的不是"有没有记忆"，而是"如何训练共享记忆"](#二、相关工作：UMA 改变的不是“有没有记忆”，而是“如何训练共享记忆”)
• • [1. 内部记忆与上下文压缩](#1. 内部记忆与上下文压缩)
  • [2. Prompt 驱动的外部记忆](#2. Prompt 驱动的外部记忆)
  • [3. 可训练的 Memory Agent](#3. 可训练的 Memory Agent)
• [三、问题建模：把记忆维护与问答放进同一个 MDP](#三、问题建模：把记忆维护与问答放进同一个 MDP)
• • [1. 输入被切成顺序信息流](#1. 输入被切成顺序信息流)
  • [2. 状态空间](#2. 状态空间)
  • [3. 统一动作空间](#3. 统一动作空间)
  • [4. 两层状态转移](#4. 两层状态转移)
• [四、UMA 方法总览：一次构建，多次复用](#四、UMA 方法总览：一次构建，多次复用)
• • [1. 统一策略输入](#1. 统一策略输入)
  • [2. Phase I：顺序记忆维护](#2. Phase I：顺序记忆维护)
  • [3. Phase II：混合检索增强问答](#3. Phase II：混合检索增强问答)
• [五、Task-Stratified GRPO：如何把多个问题的效用传给一份共享记忆](#五、Task-Stratified GRPO：如何把多个问题的效用传给一份共享记忆)
• • [1. 为什么普通 GRPO 分组不够](#1. 为什么普通 GRPO 分组不够)
  • [2. 嵌套轨迹采样](#2. 嵌套轨迹采样)
  • [3. QA Session 奖励](#3. QA Session 奖励)
  • [4. Memory Session 奖励：把多问题效用向上游聚合](#4. Memory Session 奖励：把多问题效用向上游聚合)
  • [5. Memory 组的优势归一化](#5. Memory 组的优势归一化)
  • [6. QA 组按问题分别归一化](#6. QA 组按问题分别归一化)
  • [7. 统一优化目标](#7. 统一优化目标)
• 六、Ledger-QA：专门诊断长期状态维护
• • [1. 为什么还需要新数据集](#1. 为什么还需要新数据集)
  • [2. 三阶段构造流程](#2. 三阶段构造流程)
  • [3. 它真正测量什么](#3. 它真正测量什么)
• 七、实验设置
• • [1. 三类能力轴](#1. 三类能力轴)
  • [2. 对比方法](#2. 对比方法)
  • [3. 训练配置](#3. 训练配置)
  • [4. 评价指标](#4. 评价指标)
• [八、主实验：UMA 的优势来自跨任务稳定性，而非每一列都第一](#八、主实验：UMA 的优势来自跨任务稳定性，而非每一列都第一)
• • [1. TTL 与 AR 总体结果](#1. TTL 与 AR 总体结果)
  • [2. Ledger-QA 平均结果](#2. Ledger-QA 平均结果)
  • [3. 长度增长后的退化曲线](#3. 长度增长后的退化曲线)
• 九、消融实验：真正起作用的是联合训练与正确分组
• • [1. Phase I 不是可有可无的预处理](#1. Phase I 不是可有可无的预处理)
  • [2. RL 带来的不是单纯答案风格变化](#2. RL 带来的不是单纯答案风格变化)
  • [3. 分层归一化确实必要](#3. 分层归一化确实必要)
  • [4. 两阶段训练不等价于端到端训练](#4. 两阶段训练不等价于端到端训练)
  • [5. 原始上下文仍然重要](#5. 原始上下文仍然重要)
• [十、Session Budget：更长窗口有收益，但很快递减](#十、Session Budget：更长窗口有收益，但很快递减)
• 十一、效率与资源扩展
• • [1. 528k Token ConvoMem 上的延迟](#1. 528k Token ConvoMem 上的延迟)
  • [2. Ledger-QA 扩展规律](#2. Ledger-QA 扩展规律)
• 十二、失败案例：错误究竟发生在哪一层
• • [1. Ledger-QA：主要瓶颈是写错，而不是找不到](#1. Ledger-QA：主要瓶颈是写错，而不是找不到)
  • [2. LoCoMo：写入、寻址和证据使用同样重要](#2. LoCoMo：写入、寻址和证据使用同样重要)
• [十三、与 Agent Memory 系列方法的横向比较](#十三、与 Agent Memory 系列方法的横向比较)
• [十四、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发](#十四、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发)
• • [1. Coding Agent：项目状态应在开发过程中维护](#1. Coding Agent：项目状态应在开发过程中维护)
  • [2. Tool Agent：奖励不应只看单次工具调用](#2. Tool Agent：奖励不应只看单次工具调用)
  • [3. Multi-Agent：共享黑板需要多消费者监督](#3. Multi-Agent：共享黑板需要多消费者监督)
  • [4. 状态型任务应优先验证写入，而非继续加大检索](#4. 状态型任务应优先验证写入，而非继续加大检索)
• 十五、局限性与证据边界
• • [1. 训练成本很高](#1. 训练成本很高)
  • [2. Ledger-QA 是合成且领域单一的受控诊断集](#2. Ledger-QA 是合成且领域单一的受控诊断集)
  • [3. 长程性能仍然绝对偏低](#3. 长程性能仍然绝对偏低)
  • [4. 上游信用分配仍然粗粒度](#4. 上游信用分配仍然粗粒度)
  • [5. 评价依赖 LLM Judge](#5. 评价依赖 LLM Judge)
  • [6. 对比协议并非完全同质](#6. 对比协议并非完全同质)
  • [7. 缺少真实在线纠错机制](#7. 缺少真实在线纠错机制)
• 十六、我的理解与启发
• • [1. UMA 真正训练的是"未来问题分布下的充分状态"](#1. UMA 真正训练的是“未来问题分布下的充分状态”)
  • [2. "一次构建，多次查询"改变了记忆系统的成本模型](#2. “一次构建，多次查询”改变了记忆系统的成本模型)
  • [3. 记忆质量至少有三个独立维度](#3. 记忆质量至少有三个独立维度)
  • [4. 更复杂的记忆结构不是永远的下一步](#4. 更复杂的记忆结构不是永远的下一步)
  • [5. 下一步应把确定性更新嵌入可学习策略](#5. 下一步应把确定性更新嵌入可学习策略)
• 十七、总结
• 参考资料

---

前言

假设一个个人财务 Agent 连续陪伴用户半年。

用户每天都可能说一句新信息：今天坐地铁花了 10 元、上周的机票退了 300 元、某笔购物其实应该归入办公用品。一个月后，用户才问："我这个月在交通上到底花了多少？"

这个问题看起来像检索，实际上不是。

如果系统只在提问时去原始聊天记录中搜索，它不仅要找到所有相关消费，还要识别退款、纠错、分类变化，并把分散在几十次会话中的金额重新聚合。答案并不存在于某一段文本中，而是一个随时间持续变化的隐状态。

此前的 Agent Memory 工作分别推进了记忆写入、结构化组织、检索与演化：A-MEM 强调可动态链接和演化的外部记忆；MAGMA 强调多图协同组织；CoM 将记忆压缩看作可学习过程；ReMemR1 让模型在读入时回看旧记忆；Mem²Evolve 进一步讨论经验如何自我演化。这些方法共同说明，Agent 不能只保存原文，而要主动维护可用状态。

但这里还缺少一个训练问题：如果记忆是在问题出现之前构建的，而且同一份记忆要服务未来多个未知问题，该怎样把下游问答效果反向传给上游的记忆写入行为？

这正是本文研究的 one-to-many 场景：一条长信息流只处理一次，产生一份可复用记忆；之后，多条彼此独立的问题共享这份记忆。它与"看到问题后，再围绕问题压缩上下文"的 one-to-one 范式有本质差别。

本文提出 Unified Memory Agent（UMA）。它把顺序记忆维护与问答放进同一策略，并用 Task-Stratified GRPO 将多个下游问题的平均效用分配给产生这份共享记忆的上游轨迹。

本文的唯一核心增量可以概括为：

UMA 将"问题揭示前构建一次、供多个未来问题复用"的外部记忆建模为端到端强化学习问题，并通过嵌套轨迹采样与分层优势归一化，把多问题的下游效用稳定地回传给上游记忆维护行为。

结构化 Memory Bank、混合检索和 Ledger-QA 都很重要，但它们分别是这条训练主线的执行载体、读取保障和诊断工具，而不是与核心增量并列的三个新点。

零、论文基本信息

• 论文名称： Learning to Remember: End-to-End Training of Memory Agents for Long-Context Reasoning
• 发表平台： EMNLP 2026 Main Conference；arXiv:2602.18493v2
• 代码仓库： https://github.com/ictnlp/unified-memory-agent
• 作者： Kehao Zhang、Shangtong Gui、Sheng Yang、Wei Chen、Yang Feng

一、背景与问题：长上下文为什么仍然不会"记账"

1. 长上下文解决的是"装得下"，不是"状态维护"

把所有历史直接放进上下文，优势是信息损失少，也不需要设计额外记忆结构。但这条路线存在三个问题：

1. 注意力计算与长输入成本持续增长；
2. 关键信息可能被埋在中间，出现 lost-in-the-middle 或 context rot；
3. 每次问题到来时，都要重新扫描和推理同一份历史。

更重要的是，当事实会更新时，原始历史中可能同时存在"旧值"和"新值"。长上下文保留了全部证据，却没有替 Agent 决定当前有效状态是什么。

2. RAG 擅长找片段，却不天然擅长维护隐状态

RAG 把历史切块，等问题到来后检索相关片段。它非常适合答案直接存在于某一段证据中的任务，但对累计、覆盖、撤销和冲突消解并不自然。

先看论文用来区分两种范式的例子：

Figure 1：RAG 与 Agentic Memory 的费用追踪对比。 RAG 在每次查询时重新检索历史，Agentic Memory 则随信息到达实时维护结构化状态。

"本月交通消费 80 元"通常不是某条日志中的原句，而是多笔消费与退款共同决定的聚合值。RAG 即使召回正确片段，也仍需要在问答时重做状态计算；一旦漏掉某个更新，结果就会错误。

Agentic Memory 的目标是把计算前移：新事件到来时立即更新类别金额、总额和剩余额度。之后的问题读取当前状态即可。

3. Query-conditioned Memory 与 Query-agnostic Memory

许多训练型记忆方法会先看到目标问题，再决定读什么、压缩什么。形式上，它们优化的是：

C , q ⟶ M q ⟶ a C,q \longrightarrow M_q \longrightarrow a C,q⟶Mq⟶a

其中 C C C 是长上下文， q q q 是已知问题， M q M_q Mq 是围绕问题构造的记忆。这种记忆可以只保留与当前问题有关的信息。

UMA 面对的是另一种协议：

C ⟶ M , ( M , q 1 ) → a 1 , ... , ( M , q M ) → a M C \longrightarrow M, \qquad (M,q_1)\to a_1,\ldots,(M,q_M)\to a_M C⟶M,(M,q1)→a1,...,(M,qM)→aM

构建 M M M 时，问题还不可见；同一个 M M M 需要回答多个未来问题。因此，记忆不能投机地只保存单一目标所需证据，而要保留具有广泛未来效用的信息。

这也带来信用分配难题：一次记忆写入到底好不好，不能由一条问题决定。某个压缩动作可能对问题 A 无害，却删除了问题 B 所需的事实。

二、相关工作：UMA 改变的不是"有没有记忆"，而是"如何训练共享记忆"

1. 内部记忆与上下文压缩

参数记忆、可学习 Memory Token、KV 压缩等方法把长期信息放进模型内部表示。它们可以减少显式文本长度，但通常需要访问或修改模型结构，难以作为黑盒模型外的通用记忆层。

UMA 选择外部记忆：状态以可读、可编辑的 Memory Bank 和 Core Memory 存在，模型通过工具操作它们。这样更容易审计某次错误到底发生在写入、检索还是最终推理阶段。

2. Prompt 驱动的外部记忆

MemGPT、Mem0、SCM 等系统依靠提示词执行记忆抽取、分层或图结构维护。它们部署灵活，却把复杂的写入决策交给 instruction following。小模型在长序列下可能不会稳定更新、删除或合并冲突信息。

UMA 并没有否定这些外部结构，而是进一步问：能否从下游结果中直接学习工具操作策略？

3. 可训练的 Memory Agent

MemAgent、ReMemR1 等方法已证明，RL 可以训练模型在长上下文中压缩、回看并回答问题。但它们更接近问题条件化的记忆轨迹：目标问题可以指导"什么值得记"。

Mem- α \alpha α 使用 RL 管理复合记忆系统；Mem-T 通过分阶段方式优化检索与构建策略。UMA 与它们最关键的差别不是工具更多，而是把共享记忆的构建轨迹分叉成多条 QA 轨迹，并用这些 QA 的总体效用联合监督同一份记忆。

三、问题建模：把记忆维护与问答放进同一个 MDP

1. 输入被切成顺序信息流

长上下文 C C C 被拆成 N N N 个块：

C = { c 1 , c 2 , ... , c N } C=\{c_1,c_2,\ldots,c_N\} C={c1,c2,...,cN}

模型不是一次看到全部内容，而是顺序接收每个 c k c_k ck。这更符合持续交互场景，也迫使系统在有限上下文中维护跨块状态。

2. 状态空间

论文将状态写为：

s t = ( M t , x t , h t ) s_t=(\mathcal{M}_t,x_t,h_t) st=(Mt,xt,ht)

其中：

• M t = ( m t c o r e , B t ) \mathcal{M}_t=(m_t^{core},B_t) Mt=(mtcore,Bt) 是双组件记忆；
• m t c o r e m_t^{core} mtcore 是不断演化的高层摘要；
• B t B_t Bt 是结构化键值 Memory Bank；
• x t x_t xt 是当前关注对象，在建记忆阶段为文本块 c k c_k ck，在问答阶段为查询 q q q；
• h t h_t ht 是近期工具调用和返回结果组成的交互历史。

这个状态设计把长期状态和短期工作区分开：Memory Bank 保存可定位事实，Core Memory 提供全局概览， h t h_t ht 只承担当前会话内的操作轨迹，避免工具日志无限膨胀。

3. 统一动作空间

记忆维护阶段提供：

• Add：添加新条目；
• Update：修改内容或重命名条目；
• Delete：删除失效条目；
• Retrieve、List：读取条目或浏览键；
• UpdateCore：提交当前 Core Memory，并进入下一个文本块。

问答阶段提供：

• BM25、Embedding：从原始文本块做稀疏或稠密检索；
• Retrieve、List：读取结构化 Memory Bank；
• Answer：输出最终答案并结束会话。

这里值得注意的是，UpdateCore 和 Answer 在实现中不是可执行 API。若模型没有输出结构化工具调用，而是输出普通文本，控制器会根据阶段分别把它解释为更新 Core Memory 或提交答案。

4. 两层状态转移

单个文本块内部，Agent 可以连续调用多个工具，更新 B t B_t Bt，同时把调用结果加入 h t h_t ht。当它提交 UpdateCore 时，当前内循环结束，系统切换到下一个块，并清空短期交互历史。

处理完 c N c_N cN 后，系统从维护阶段切到问答阶段， x t x_t xt 由文本块变为查询 q q q。

因此，策略既要学会当前块内的局部编辑，也要学会跨块整合：

局部 CRUD + 跨块 Core 更新 ⟶ M N \text{局部 CRUD} + \text{跨块 Core 更新} \longrightarrow \mathcal{M}_N 局部 CRUD+跨块 Core 更新⟶MN

四、UMA 方法总览：一次构建，多次复用

理解 UMA，最重要的是看清维护阶段与问答阶段怎样共享同一策略和同一记忆状态：

Figure 2：UMA 方法总览。 Phase I 顺序读取文本块，并通过 CRUD 维护 Memory Bank 与 Core Memory；Phase II 同时使用结构化记忆与原始上下文检索回答问题。

1. 统一策略输入

任意时刻，LLM 的输入由四部分拼接：

I n p u t t = I s y s , m t c o r e , x t , h t \mathrm{Input}_t=I_{sys},m_t\^{core},x_t,h_t Inputt=Isys,mtcore,xt,ht

I s y s I_{sys} Isys 定义当前阶段和可用工具； m t c o r e m_t^{core} mtcore 提供全局进度； x t x_t xt 提供当前文本块或问题； h t h_t ht 提供本轮工具交互。

统一策略写为：

a t ∼ π θ ( ⋅ ∣ I s y s , m t c o r e , x t , h t ) a_t\sim\pi_\theta(\cdot\mid I_{sys},m_t^{core},x_t,h_t) at∼πθ(⋅∣Isys,mtcore,xt,ht)

同一个参数集合 θ \theta θ 同时学习写记忆、读记忆、检索原文和生成答案。这样，下游 QA 不再只是独立模块，而能直接约束上游的记忆行为。

2. Phase I：顺序记忆维护

对每个文本块 c k c_k ck，模型重新初始化 h t = ∅ h_t=\varnothing ht=∅，再根据当前 Core Memory 与文本块选择操作：

a t ∼ π θ ( ⋅ ∣ I s y s , m t c o r e , c k , h t ) a_t\sim\pi_\theta(\cdot\mid I_{sys},m_t^{core},c_k,h_t) at∼πθ(⋅∣Isys,mtcore,ck,ht)

例如读到"本月又乘火车花费 10 元"时，Agent 可以先 Retrieve("transport")，读取已有交通金额，再 Update 为新值；若这是第一次出现交通类别，则 Add 新条目。

CRUD 的价值不只是结构化存储。Update 和 Delete 让记忆可以覆盖旧事实、修正错误和处理冲突，避免所有事件只追加不整理。

3. Phase II：混合检索增强问答

记忆构建完成后，问题到来。Agent 优先通过 List 或 Retrieve 访问 Memory Bank，也可以用 BM25 或 Embedding 回到原始上下文。

这是一个重要的保底设计：结构化记忆适合稳定状态与聚合值，原文检索适合长尾细节和未被写入的证据。UMA 没有假设压缩后的记忆可以无损替代全部原文。

五、Task-Stratified GRPO：如何把多个问题的效用传给一份共享记忆

这部分是论文真正的技术核心。

1. 为什么普通 GRPO 分组不够

一次训练样本里同时存在两类轨迹：

• 上游的 Memory Session，负责逐块维护共享记忆；
• 下游的 QA Session，负责用这份记忆回答具体问题。

不同问题的固有难度不同。若把所有 Session 放进同一个组归一化，简单问题的高分与困难问题的低分会互相污染；同时，Memory Session 的奖励是多个问题的聚合效用，与单条 QA 奖励也不是同一种统计对象。

因此，UMA 不只是"使用 GRPO"，而是按任务结构重新定义采样、奖励分配和归一化组。

Figure 3：Task-Stratified GRPO。 每条记忆轨迹产生一份最终记忆并分叉到共享问题集；Memory Session 与每个问题对应的 QA Session 分别组成归一化组。

2. 嵌套轨迹采样

对同一个上下文 C C C，训练分三步进行。

第一步，采样 G G G 条记忆轨迹：

{ τ 1 , τ 2 , ... , τ G } \{\tau^1,\tau^2,\ldots,\tau^G\} {τ1,τ2,...,τG}

每条轨迹 τ i \tau^i τi 包含 N N N 个 Memory Session，并产生最终记忆 M N i \mathcal{M}_N^i MNi。论文固定 G = 16 G=16 G=16。

第二步，对当前上下文只采样一次共享问题集：

Q C = { q 1 , q 2 , ... , q M } Q_C=\{q^1,q^2,\ldots,q^M\} QC={q1,q2,...,qM}

第三步，把每份最终记忆分别与每个问题组合，得到 G M GM GM 条 QA Session：

( M N i , q j ) ⟶ s q a i , j (\mathcal{M}N^i,q^j)\longrightarrow s{qa}^{i,j} (MNi,qj)⟶sqai,j

共享问题集非常关键。只有不同记忆轨迹回答相同问题，奖励差异才主要反映记忆质量，而不是问题难度差异。

3. QA Session 奖励

第 i i i 份记忆回答第 j j j 个问题时，奖励为：

R q a i , j = λ r t o o l q a , i , j + r o u t c o m e i , j R_{qa}^{i,j}=\lambda r_{tool}^{qa,i,j}+r_{outcome}^{i,j} Rqai,j=λrtoolqa,i,j+routcomei,j

r o u t c o m e i , j = r o u t c o m e ( a a n s i , j , y j ) r_{outcome}^{i,j}=r_{outcome}(a_{ans}^{i,j},y^j) routcomei,j=routcome(aansi,j,yj)

r t o o l r_{tool} rtool 衡量工具调用是否有效， r o u t c o m e r_{outcome} routcome 衡量最终答案与标准答案是否匹配。论文在所有任务中使用固定权重 λ = 0.5 \lambda=0.5 λ=0.5。

这避免了只奖励答案而放任无效工具调用，也避免了模型为了"调用正确"而忽略最终任务结果。

4. Memory Session 奖励：把多问题效用向上游聚合

同一份最终记忆 M N i \mathcal{M}_N^i MNi 服务 M M M 个问题。论文先计算这些问题的平均结果奖励：

r ˉ o u t c o m e i = 1 M ∑ j = 1 M r o u t c o m e i , j \bar r_{outcome}^{i}=\frac{1}{M}\sum_{j=1}^{M}r_{outcome}^{i,j} rˉoutcomei=M1j=1∑Mroutcomei,j

随后，属于记忆轨迹 τ i \tau^i τi 的每个 Memory Session 获得：

R m e m i , k = λ r t o o l m e m , i , k + r ˉ o u t c o m e i R_{mem}^{i,k}=\lambda r_{tool}^{mem,i,k}+\bar r_{outcome}^{i} Rmemi,k=λrtoolmem,i,k+rˉoutcomei

其中 r t o o l m e m , i , k r_{tool}^{mem,i,k} rtoolmem,i,k 可以由当前 Session 的有效工具调用比例计算。

直观上，一次写入不是因为"看起来像好摘要"而得分，而是因为它产生的最终记忆能否平均支持多个未来问题。这正是 query-agnostic 记忆需要的训练信号。

但它也有一个边界：同一轨迹中的所有 Memory Session 共享同一个平均下游结果，信用分配仍然较粗。模型知道"这条完整记忆轨迹整体好不好"，却不精确知道是哪一次早期写入造成后续错误。

5. Memory 组的优势归一化

所有记忆 Session 在当前更新中组成 Memory Group：

A m e m i , k = R m e m i , k − R ˉ m e m σ ( R m e m ⋅ , ⋅ ) + ϵ s t d A_{mem}^{i,k}=\frac{R_{mem}^{i,k}-\bar R_{mem}}{\sigma(R_{mem}^{\cdot,\cdot})+\epsilon_{std}} Amemi,k=σ(Rmem⋅,⋅)+ϵstdRmemi,k−Rˉmem

R ˉ m e m = 1 G N ∑ u = 1 G ∑ v = 1 N R m e m u , v \bar R_{mem}=\frac{1}{GN}\sum_{u=1}^{G}\sum_{v=1}^{N}R_{mem}^{u,v} Rˉmem=GN1u=1∑Gv=1∑NRmemu,v

论文设置 ϵ s t d = 10 − 6 \epsilon_{std}=10^{-6} ϵstd=10−6 防止方差为零。归一化后，同一 Memory Session 内的所有动作共享该优势值。

6. QA 组按问题分别归一化

对某个固定问题 q j q^j qj，只比较使用不同记忆状态回答该问题的 G G G 条 QA Session：

A q a i , j = R q a i , j − R ˉ q a , j σ ( R q a ⋅ , j ) + ϵ s t d A_{qa}^{i,j}=\frac{R_{qa}^{i,j}-\bar R_{qa,j}}{\sigma(R_{qa}^{\cdot,j})+\epsilon_{std}} Aqai,j=σ(Rqa⋅,j)+ϵstdRqai,j−Rˉqa,j

R ˉ q a , j = 1 G ∑ u = 1 G R q a u , j \bar R_{qa,j}=\frac{1}{G}\sum_{u=1}^{G}R_{qa}^{u,j} Rˉqa,j=G1u=1∑GRqau,j

这样，一个困难问题不会因为绝对分数低而让所有轨迹都受到惩罚；策略学习的是：对同一个问题，哪一种记忆构建与访问方式相对更好。

7. 统一优化目标

Memory Session 与 QA Session 最终进入同一个 PPO/GRPO 风格目标：

J ( θ ) = S m e m + S q a G N + G M J(\theta)=\frac{S_{mem}+S_{qa}}{GN+GM} J(θ)=GN+GMSmem+Sqa

单个动作的裁剪目标为：

ℓ ( ρ t , A ) = min ⁡ ( ρ t A , clip ⁡ ( ρ t , 1 − ϵ , 1 + ϵ ) A ) − β D K L , t \ell(\rho_t,A)=\min\left(\rho_tA,\operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)A\right)-\beta D_{KL,t} ℓ(ρt,A)=min(ρtA,clip(ρt,1−ϵ,1+ϵ)A)−βDKL,t

其中：

ρ t = π θ ( a t ∣ s t ) π θ o l d ( a t ∣ s t ) \rho_t=\frac{\pi_\theta(a_t\mid s_t)}{\pi_{\theta_{old}}(a_t\mid s_t)} ρt=πθold(at∣st)πθ(at∣st)

ρ t \rho_t ρt 控制新旧策略更新幅度，裁剪项避免单次更新过大， D K L , t D_{KL,t} DKL,t 约束策略不要偏离冻结参考模型太远。

所谓"统一端到端"，不是把两阶段数据简单混合，而是共享参数、共享最终任务效用，并在同一目标中联合更新。

六、Ledger-QA：专门诊断长期状态维护

1. 为什么还需要新数据集

传统长记忆基准常问"某人什么时候说过某句话"或"哪段文档包含答案"。这类任务主要考查证据保留与检索。

Ledger-QA 则故意让答案不直接存在于任何单一片段中。系统必须持续维护由多次更新共同决定的账本状态。

2. 三阶段构造流程

第一阶段，从 2023-01-01 到 2024-12-31 采样 H H H 个日期，并为每次 Session 采样消费场景。

第二阶段，由强模型联合生成自然对话与结构化 Transaction 记录。金额与对话一起生成，以保持语义对齐。

第三阶段，根据结构化账本程序化生成八类问题与精确答案。问题需要对跨 Session 的交易做聚合、筛选或比较。

论文评估的 Session Horizon 为：

H ∈ { 2 , 5 , 10 , 20 , 30 , 40 , 50 , 100 , 500 } H\in\{2,5,10,20,30,40,50,100,500\} H∈{2,5,10,20,30,40,50,100,500}

500 个 Session 的平均原始上下文达到约 405,990 Token，已经远超默认 16k Session Budget。

3. 它真正测量什么

Ledger-QA 的核心不是"财务知识"，而是三种能力：

1. 从每次对话中准确抽取状态更新；
2. 把新更新合并进既有状态，而非留下互相冲突的副本；
3. 在长时间跨度后正确读取累计结果。

它是一个受控诊断集，而不是现实记忆任务的完整替代。透明规则有利于定位状态维护问题，但真实世界还包含模糊指代、虚假陈述、非结构化目标变化和更复杂权限边界。

七、实验设置

1. 三类能力轴

论文没有只在一个数据集上证明结果，而是覆盖三类记忆能力。

• Dynamic State Tracking： Ledger-QA；
• Test-Time Learning（TTL）： TREC-Coarse、TREC-Fine、NLU、Clinic、Banking77、PubMed-RCT；
• Accurate Retrieval（AR）： HotpotQA、LoCoMo、LongMemEval、MSC、PerLTQA、SQuAD、ConvoMem。

TTL 测试能否从上下文中的示例或规则学会新任务；AR 测试能否从长文档和长对话中恢复细粒度事实；Ledger-QA 则测试持续聚合的隐状态。

2. 对比方法

基线包括直接拼接上下文的 Concat、混合检索 RAG、MemAgent 与 query-agnostic 版本 MemAgent-woq，以及 Mem1、A-MEM、Mem- α \alpha α、Mem-T。

这组对比覆盖了无外部记忆、纯检索、循环摘要、结构化外部记忆与可训练记忆 Agent。但不同方法的协议并不完全相同，特别是 MemAgent 在 Ledger-QA 中可以看到问题后为每个问题单独构建状态，而 UMA 只构建一次共享状态。

3. 训练配置

UMA 以 Qwen3-4B-Instruct-2507 初始化。UMA-Generalist 在修改后的 HotpotQA 与过滤后的 Mem- α \alpha α 数据上训练 2 个 Epoch；UMA-Specialist 在独立生成的 Ledger-QA 训练集上训练 6 个 Epoch。

Task-Stratified GRPO 使用 G = 16 G=16 G=16， λ = 0.5 \lambda=0.5 λ=0.5。训练使用 32 张 NVIDIA H200，Generalist 约 2 天，Specialist 约 0.5 天。论文也验证了流水线可在单节点 8 张 A800 80GB 上运行，但并不意味着完整训练成本低。

4. 评价指标

主文使用 DeepSeek-V3.2 作为 LLM Judge，并补充 EM、F1、ROUGE-L 与 Sub-EM。附录还给出 Qwen3-30B-A3B-Instruct-2507 Judge 的结果。

多指标很必要：LLM Judge 能接受语义等价但表面不同的答案，EM 更严格地反映数值或短答案是否真正匹配。Ledger-QA 中某些方法 Judge 尚可而 EM 很低，说明只看语义评分可能高估精确状态维护能力。

八、主实验：UMA 的优势来自跨任务稳定性，而非每一列都第一

1. TTL 与 AR 总体结果

主表包含 13 个任务，完整数值较宽。下面重制最有分析价值的汇总结果：

方法	TTL 平均分	AR 平均分	13 任务平均分
Concat	61.47	40.73	50.30
RAG	48.20	58.08	53.52
MemAgent	34.65	59.06	48.25
A-MEM	56.95	60.29	58.75
Mem- α \alpha α	70.75	56.39	63.02
Mem-T	40.97	57.22	49.72
UMA-Generalist（16k）	82.70	70.00	75.86

Table 1：TTL 与 AR 主实验汇总。 UMA-Generalist 在默认 16k Budget 下获得最高的六项 TTL 平均分、七项 AR 平均分和总体平均分。

UMA-Generalist 的 13 任务平均分为 75.86，比最强对比方法 Mem- α \alpha α 的 63.02 高 12.84 分。

这不是"所有任务都第一"。例如 LoCoMo 上 UMA 为 46.58，低于 RAG 的 54.03；HotpotQA 上 UMA 的 76.56 也低于 Mem- α \alpha α 的 79.69。论文更有说服力的结论是：UMA 在分类式 TTL 和事实型 AR 之间取得更均衡的表现。

它在未见训练域 Banking77 与 Clinic 上分别达到 87 和 91，说明维护策略没有完全绑定某个标签集合。与此同时，它在 ConvoMem 上达到 87.05，说明同一策略也能处理长对话检索。

2. Ledger-QA 平均结果

模型	使用 Ledger-QA 训练	Judge	EM	F1	ROUGE-L	Sub-EM
UMA（无 RL）	否	30.45	19.09	20.15	20.15	42.59
MemAgent	否	40.52	19.28	23.63	23.64	42.50
UMA-Generalist（16k）	否	38.18	34.39	36.24	36.24	43.42
UMA-Specialist（16k）	是	53.02	49.39	51.62	51.62	55.65

Table 2：Ledger-QA 九种 Session Horizon 的平均结果。 Generalist 展示零样本迁移，Specialist 展示任务适配后的上限。

MemAgent 的 Judge 分数 40.52 高于 UMA-Generalist 的 38.18，但其 EM 只有 19.28，明显低于 UMA-Generalist 的 34.39。更重要的是，MemAgent 每个问题都能重新读历史并构建问题条件化状态，而 UMA-Generalist 复用一份事先构建的共享记忆。因此，两者并不是相同成本与信息条件下的直接胜负。

Specialist 经过 Ledger-QA 训练后达到 53.02 Judge 和 49.39 EM，说明端到端策略确实能学到持续账本维护，而不只是把 Generalist 的检索能力搬到新数据上。

3. 长度增长后的退化曲线

Figure 4：Ledger-QA 长度扩展结果。 比较不同方法从 2 到 500 个 Session 时的 LLM-as-a-Judge 分数变化。

方法	H = 2 H=2 H=2	H = 20 H=20 H=20	H = 100 H=100 H=100	H = 500 H=500 H=500	平均
RAG	80.58	17.65	8.65	5.77	23.59
MemAgent	81.55	39.22	29.81	11.54	40.52
A-MEM	33.01	11.76	0.96	1.92	13.25
Mem- α \alpha α	60.19	21.57	14.42	9.62	26.18
UMA-Generalist（16k）	73.79	30.39	21.15	11.54	38.18
UMA-Specialist（16k）	87.38	57.84	34.62	25.00	53.02

Table 16：Ledger-QA 代表性 Session Horizon 的 Judge 分数。 随历史增长，所有方法均退化，但 UMA-Specialist 在长 Horizon 下保持更高分数。

RAG 从 H = 2 H=2 H=2 的 80.58 降到 H = 500 H=500 H=500 的 5.77；MemAgent-woq 从 82.52 降到 2.88。短历史下，检索或摘要仍可能覆盖全部关键交易；历史拉长后，漏召回、重复与错误聚合会累积。

UMA-Specialist 在 H = 500 H=500 H=500 时仍只有 25.00，远非解决问题。但它比最强非 UMA 基线 MemAgent 的 11.54 高 13.46 分，说明主动维护状态比到查询时重读历史更抗长程退化。

九、消融实验：真正起作用的是联合训练与正确分组

变体	13 任务平均分	相对完整 UMA
UMA（无 RL 且无 Phase I）	42.17	-33.69
UMA（无 Phase I）	62.61	-13.25
UMA（无 RL）	59.71	-16.15
UMA（无原文检索）	57.74	-18.12
UMA（Global Group）	69.96	-5.90
UMA（Two-Stage）	64.65	-11.21
UMA-Generalist（16k）	75.86	---

Table 1（续）：UMA 核心消融。 分别移除顺序维护、RL、原文检索、任务分层归一化与端到端联合训练。

1. Phase I 不是可有可无的预处理

完整模型比"无 Phase I"高 13.25 分。这说明仅在问题到来后检索并不足以替代顺序记忆维护。读入过程中执行 Add、Update、Delete，能提前完成跨块整合。

即使没有 RL，保留 Phase I 也比"无 RL 且无 Phase I"更强，说明结构化维护本身具有价值；但没有学习信号时，它还不能稳定决定什么该写、该更新或该保留。

2. RL 带来的不是单纯答案风格变化

完整模型比"无 RL"高 16.15 分，而且提升同时覆盖 TTL 与 AR。这支持 RL 学到的是记忆写入、更新和访问策略，而不只是优化最终回答措辞。

论文还做了 10 万个样本的纯算术控制：基础模型准确率 25.41%，UMA-Specialist 为 25.14%，几乎没有变化。因此 Ledger-QA 的提升不能解释为模型突然更会做加法，更可能来自记忆维护与状态读取。

3. 分层归一化确实必要

把所有 Memory 与 QA Session 放进一个 Global Group 后，平均分下降 5.9。这个消融直接支撑 Task-Stratified GRPO 的必要性：记忆效用和不同问题的回答奖励不应混用同一个统计基线。

4. 两阶段训练不等价于端到端训练

先训练维护、再训练 QA 的 Two-Stage 版本低 11.21 分。分开优化时，上游记忆容易学习"看起来像摘要"的目标，却无法直接知道哪些信息对未来多问题真正有用。

5. 原始上下文仍然重要

移除原文检索后，标准 TTL/AR 明显下降。Ledger-QA 上，UMA-Specialist 的 952 条 QA 轨迹全部访问结构化记忆：878 条（92.2%）只用 Memory Bank，74 条（7.8%）同时使用原文检索，没有一条只使用原文检索。

这说明不同任务的瓶颈不同：Ledger-QA 主要依赖已经聚合好的状态，LoCoMo 等细节密集任务则仍需原文作为证据补充。

十、Session Budget：更长窗口有收益，但很快递减

Session Budget	13 任务平均分
8k	71.45
16k	75.86
32k	76.76

Table 1（续）：Session Budget 扩展。 从 8k 增至 16k 提升明显，从 16k 增至 32k 仅增加 0.90 分。

这里的 Budget 不是原始文档总长度，而是一个 Session 中初始提示、后续动作、工具观察与输入输出累计占用的 Token 上限。

8k 到 16k 提升 4.41 分，说明策略需要足够空间完成多轮工具操作；16k 到 32k 只提升 0.90 分，却需要更高计算与显存成本。因此论文选择 16k 作为默认折中。

十一、效率与资源扩展

1. 528k Token ConvoMem 上的延迟

方法	延迟（秒）	相对 UMA
Concat	2.58	41.6× 更快
RAG	58.01	1.9× 更快
UMA-Generalist	107.32	1.0×
Mem1	368.46	3.4× 更慢
Mem- α \alpha α	1503.87	14.0× 更慢
A-MEM	3251.75	30.3× 更慢
MemAgent	4753.26	44.3× 更慢
Mem-T	8611.18	80.2× 更慢

Table 10：528k Token ConvoMem 上的推理延迟。 在 8 张 A800 上，对同一上下文抽取 10 个问题，UMA 明显快于多种循环式记忆基线，但慢于 Concat 与 RAG。

UMA 的优势来自摊销：长上下文只在记忆构建时处理一次，之后多个问题复用 Memory Bank。MemAgent 则需要针对每个问题重新遍历上下文。

但论文的"高效"是相对于复杂 Memory Agent，而不是相对于所有系统。RAG 仍比 UMA 快 1.9 倍，Concat 更快。只有在问题数量增加、状态聚合难度上升时，UMA 的一次构建成本才更值得。

2. Ledger-QA 扩展规律

Session Horizon	平均问题数	构建时间（秒）	整组 QA 时间（秒）
20	34.0	21.15	18.25
40	35.0	32.09	22.85
50	35.0	43.16	17.65
100	34.7	80.78	19.28
500	34.7	564.67	21.55

Table 11：Ledger-QA 构建与问答耗时。 记忆构建随输入规模近似线性增长，复用已有记忆后的整组 QA 时间基本稳定。

记忆构建时间的拟合 R 2 = 0.995 R^2=0.995 R2=0.995，基本呈线性增长；从 H = 20 H=20 H=20 到 H = 500 H=500 H=500，整组 QA 时间仍约在 18--23 秒区间。这正是 one-to-many 设计的系统价值：历史越长，构建越贵，但新增查询不必重新支付完整历史处理成本。

在 H = 500 H=500 H=500 时，Memory Bank 平均有 4452.7 个条目、序列化后 283.96 KB，约为原始上下文大小的 24.3%。所有 Add/Update 写操作中，Update 占 32.2%，说明策略并非只会追加，也确实会修订既有状态。

十二、失败案例：错误究竟发生在哪一层

1. Ledger-QA：主要瓶颈是写错，而不是找不到

在 H = 50 H=50 H=50 的 105 个问题上，UMA-Specialist 的 Judge 准确率为 45.71%，共有 57 个错误：

最早失败阶段	错误数	比例
记忆形成	37	64.9%
QA 时推理	20	35.1%

Ledger-QA 人工错误分析。 多数错误在记忆写入或聚合阶段已经产生，后续即使正确读取对应条目也无法恢复。

论文给出的典型例子是：同一天两笔购物消费应为 145.50 + 25.99 = 171.49 145.50+25.99=171.49 145.50+25.99=171.49，但 Memory Bank 写成 166.49。之后查询某个金额区间时，Agent 能找到正确条目，却只能基于错误状态回答。

这类错误具有不可逆传播性：越早写错，越多后续问题受影响。它也暴露了平均轨迹奖励的局限------奖励能说明整条轨迹不好，却很难精确定位是哪一次更新造成数值漂移。

2. LoCoMo：写入、寻址和证据使用同样重要

论文抽查了 50 个被 DeepSeek-V3.2 判错的 UMA-Generalist 案例：

错误类型	数量	比例
必要信息未写入或被覆盖	12	24%
记忆存在但未正确访问	19	38%
已取回正确证据但最终未使用	19	38%

LoCoMo 人工错误分析。 对话型记忆不仅要求写对，还要求正确寻址，并避免原文噪声污染最终证据选择。

这解释了 UMA 在 LoCoMo 上没有领先 RAG：结构化维护擅长累积状态，但开放对话事实的键名设计、检索路由和证据融合仍然困难。

十三、与 Agent Memory 系列方法的横向比较

方法	核心关注	记忆何时构建	是否围绕已知问题	与 UMA 的关键差别
A-MEM	记忆节点的动态链接与演化	交互过程中	通常否	强调记忆组织机制；UMA 强调多问题效用驱动的端到端策略学习
MAGMA	多图协同的记忆组织与检索	持续构建	通常否	强调结构表达；UMA 的结构更简单，创新集中在训练信用分配
CoM	可学习的记忆压缩与保留	读入过程中	依具体设置	更关注压缩表示；UMA 显式操作外部 Bank，并联合训练构建与 QA
ReMemR1	读入时回看历史记忆，减少不可逆遗忘	读入过程中	更接近问题条件化训练	解决"写时能否回看"；UMA 解决"一份共享记忆如何由多个未知问题监督"
Mem²Evolve	经验与记忆的持续演化	长期交互中	通常否	更关注演化生命周期；UMA 给出 one-to-many 下明确的端到端 RL 目标
Mem- α \alpha α	RL 管理复合外部记忆	交互过程中	Query-agnostic	同样学习记忆操作；UMA 用嵌套分叉与 Task-Stratified Group 显式绑定多问题效用
Mem-T	层级记忆、检索优化与构建蒸馏	分阶段	Query-agnostic	采用分阶段优化；UMA 实验显示联合端到端训练优于 Two-Stage

Agent Memory 方法横向比较。 UMA 的位置不在于提出更复杂的记忆拓扑，而在于给共享、问题不可见记忆设计端到端多问题训练机制。

从系列演进看，UMA 把研究重心从"记忆应该长什么样"推进到"记忆策略应该由什么任务信号训练"。它甚至刻意使用相对朴素的键值 Bank，以便证明性能提升不是复杂数据结构单独带来的。

十四、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发

以下内容是基于论文机制的工程推演，不是论文已经完成的实验结论。

1. Coding Agent：项目状态应在开发过程中维护

长期 Coding Agent 不应等到用户问"为什么这个测试失败"时才搜索所有提交和终端日志。它可以持续维护：

• 模块职责与依赖关系；
• 已确认的设计约束；
• 当前失败测试与根因；
• 被否决方案及原因；
• 文件修改与验证状态。

一次项目扫描产生共享 Memory Bank，后续代码解释、修复、测试和评审任务共同复用。训练时，可以把多个下游任务的成功率汇总为上游项目记忆的效用，而不是为每个任务重新做一次项目摘要。

2. Tool Agent：奖励不应只看单次工具调用

工具调用有效并不代表记忆决策正确。一个 Agent 可以每次都传入合法参数，却把错误结果写入长期状态。

UMA 的启发是把奖励拆成两层：即时的工具有效性奖励，和延迟的下游结果奖励。对日历、CRM、财务或运维 Agent，可以用后续多个任务是否成功来评估此前的状态维护，而不是只检查 API 是否返回 200。

3. Multi-Agent：共享黑板需要多消费者监督

多 Agent 系统常用共享黑板保存计划、发现和中间结果。写入者并不知道未来哪个 Agent 会消费这些信息，这与 UMA 的 one-to-many 设定高度相似。

可以让多个执行 Agent 从同一黑板状态分叉执行不同任务，再把它们的平均成功率回传给黑板维护 Agent。与此同时，每类子任务应分别归一化奖励，避免简单任务压过困难任务。

4. 状态型任务应优先验证写入，而非继续加大检索

Ledger-QA 的错误分析表明，若多数错误已经发生在 Memory Formation，继续堆更强 Embedding 或更大的 top-k 不会解决根因。工程系统需要写后校验、数值约束、冲突检测与可回滚版本，而不仅是更强检索器。

十五、局限性与证据边界

1. 训练成本很高

Generalist 使用 32 张 H200 训练约两天。嵌套采样对每个上下文生成 16 条记忆轨迹，再分叉成 16 M 16M 16M 条 QA Session，计算开销随问题数增加。论文提到 LoRA 和 8×A800 可行，但没有提供同等性能下的低成本完整训练结果。

2. Ledger-QA 是合成且领域单一的受控诊断集

账本任务适合测量累计状态，却不能覆盖开放世界记忆中的模糊语义、主观偏好、权限、隐私、欺骗信息和多模态事件。Specialist 的高分不能直接外推到真实个人助理。

3. 长程性能仍然绝对偏低

UMA-Specialist 在 500 Session 时 Judge 25.00、EM 7.69。相对基线更好并不意味着可靠。对财务、医疗或生产运维等高风险状态，四分之一的 Judge 正确率远远不够。

4. 上游信用分配仍然粗粒度

一条记忆轨迹中的所有 Memory Session 共享同一组平均 QA Outcome。早期某次错误更新与后期某次正确修复可能得到相同轨迹级信号。未来可以引入因果回放、差分奖励或基于状态变更的局部验证器。

5. 评价依赖 LLM Judge

主结果使用 DeepSeek-V3.2 Judge。论文通过 EM/F1/ROUGE-L 与另一 Judge 补充验证，这是优点；但 MemAgent 在 Ledger-QA 上 Judge 与 EM 的巨大差距也提醒我们，语义评审对精确数值状态可能过宽。

6. 对比协议并非完全同质

不同方法是否能看到问题、是否每个问题重建记忆、使用何种已发布 Checkpoint 与提示模板，都影响结果。UMA 的优势应理解为在论文统一评测流水线下的证据，而非对所有原方法最佳实现的最终裁决。

7. 缺少真实在线纠错机制

Memory Bank 提供 Update/Delete，却没有专门的事务一致性、Schema 校验、数值计算器或版本回滚。失败案例已经表明，一次错误数值更新会长期污染后续答案。生产系统需要把语言模型决策与确定性状态机结合。

十六、我的理解与启发

1. UMA 真正训练的是"未来问题分布下的充分状态"

Query-conditioned Memory 可以针对当前问题保留最小证据；Query-agnostic Memory 则要在不知道问题的情况下，构造对未来问题分布足够的信息状态。

从这个角度看，Memory Bank 不是历史摘要，而是一个面向未来任务的近似充分统计量。Task-Stratified GRPO 用多个问题对它做 Monte Carlo 式评估：一份记忆支持的问题越多，它越接近"可复用状态"。

2. "一次构建，多次查询"改变了记忆系统的成本模型

RAG 的单位成本主要发生在每次查询；UMA 的主要成本发生在信息流读入阶段。若只有一个问题，昂贵的主动维护未必划算；若同一历史会被长期、多次查询，维护成本可以被摊销。

因此，选择记忆架构前应先问：

同一历史的未来查询次数与状态更新频率是多少？ \text{同一历史的未来查询次数与状态更新频率是多少？} 同一历史的未来查询次数与状态更新频率是多少？

高更新、高复用场景更适合 UMA；低复用、答案直接存在于局部文本中的场景，RAG 可能更简单、更快。

3. 记忆质量至少有三个独立维度

论文的失败分析揭示了三阶段链路：

Formation → Access → Evidence Use \text{Formation}\rightarrow\text{Access}\rightarrow\text{Evidence Use} Formation→Access→Evidence Use

写对、找对、用对缺一不可。Ledger-QA 主要暴露 Formation；LoCoMo 同时暴露 Access 与 Evidence Use。一个统一总分会掩盖这些完全不同的工程问题。

4. 更复杂的记忆结构不是永远的下一步

UMA 使用相对简单的键值 Bank，仍取得强结果。这说明某些阶段的瓶颈已经从"结构表达力"转向"训练目标与信用分配"。在继续设计图、树、层级之前，应该先确认现有结构是否已经能表达答案，只是策略没有学会正确维护。

5. 下一步应把确定性更新嵌入可学习策略

Ledger-QA 中 64.9% 的错误属于记忆形成，典型错误甚至是简单加法写错。最合理的工程演进不是让 LLM 独自变成更好的计算器，而是：

• LLM 判断事件语义和应执行的状态操作；
• 确定性工具完成加减、去重、约束检查；
• 版本化 Memory Store 保存变更日志；
• 下游失败触发可定位的回放与修复。

也就是说，学习策略负责"该做什么"，可靠系统负责"准确地做完"。

十七、总结

Learning to Remember 研究的不是如何把更多文本塞进上下文，而是如何训练一个 Agent 在问题出现之前主动维护可复用状态。

UMA 用同一策略连接顺序记忆维护与混合检索问答；通过 16 条记忆轨迹与共享问题集的嵌套采样，把多个 QA 的平均效用回传给上游记忆；再分别对 Memory Group 和每个 Question Group 做优势归一化，避免任务难度与奖励类型互相污染。

实验上，UMA-Generalist 在 13 个 TTL/AR 任务的默认 16k 设置下取得 75.86 平均分；UMA-Specialist 在 Ledger-QA 上达到 53.02 Judge 和 49.39 EM。Global Group 与 Two-Stage 分别下降 5.9 和 11.2 分，为论文的核心训练设计提供了直接证据。

与此同时，500 Session 下仅 25.00 的 Judge 分、昂贵的 RL 训练和大量记忆形成错误，也表明主动记忆仍远未达到可靠状态。

最后用一句话概括本文：

UMA 的关键不是再造一种记忆结构，而是让一份在问题未知时构建的共享记忆，由多个未来问题的真实效用端到端训练出来。

参考资料

1. Kehao Zhang, Shangtong Gui, Sheng Yang, Wei Chen, Yang Feng. Learning to Remember: End-to-End Training of Memory Agents for Long-Context Reasoning. EMNLP 2026 Main Conference, arXiv:2602.18493v2.
2. 论文页面：https://arxiv.org/abs/2602.18493
3. 正式 PDF：https://arxiv.org/pdf/2602.18493
4. 代码仓库：https://github.com/ictnlp/unified-memory-agent