【论文阅读】Agent记忆机制（109）：MemComposer——用强化学习学会选哪些记忆、选多少以及怎样排序

文章目录

前言
零、论文基本信息
[一、背景：Similarity Retrieval 为什么没有解决 Memory Usefulness](#一、背景：Similarity Retrieval 为什么没有解决 Memory Usefulness)
- [1. 相似，不等于对当前决策有帮助](#1. 相似，不等于对当前决策有帮助)
- [2. 单条记忆的价值不是固定属性](#2. 单条记忆的价值不是固定属性)
- [3. Memory Count 不是越大越好](#3. Memory Count 不是越大越好)
- [4. Order 不是排版细节](#4. Order 不是排版细节)
[二、相关工作：MemComposer 与已有 Recall Learning 的差异](#二、相关工作：MemComposer 与已有 Recall Learning 的差异)
- [1. Memory Representation](#1. Memory Representation)
- [2. Similarity、Reranking 与 Learned Utility](#2. Similarity、Reranking 与 Learned Utility)
- [3. In-context Demonstration Selection 与 RAG Context Selection](#3. In-context Demonstration Selection 与 RAG Context Selection)
[三、方法总览：Retriever 之后再增加一个 Composer](#三、方法总览：Retriever 之后再增加一个 Composer)
[四、问题定义：从 Top- n n n 候选生成变长有序子集](#四、问题定义：从 Top- n n n 候选生成变长有序子集)
- [1. 输入、动作与环境反馈](#1. 输入、动作与环境反馈)
- [2. 优化目标](#2. 优化目标)
[五、自生成 Memory Bank：轨迹、结果与回顾如何变成记忆](#五、自生成 Memory Bank：轨迹、结果与回顾如何变成记忆)
- [1. 每个训练任务执行 8 次](#1. 每个训练任务执行 8 次)
- [2. 失败回顾与成功审计](#2. 失败回顾与成功审计)
- [3. Consistency Check](#3. Consistency Check)
- [4. Curation 与两种表示](#4. Curation 与两种表示)
- [5. Retrieval 只负责生成 Candidate Pool](#5. Retrieval 只负责生成 Candidate Pool)
六、MemComposer：一次生成内容、数量与顺序
[七、Experience Policy Optimization：如何用完整 Agent 执行训练 Composer](#七、Experience Policy Optimization：如何用完整 Agent 执行训练 Composer)
- [1. 为什么每个 Sequence 要执行多次](#1. 为什么每个 Sequence 要执行多次)
- [2. 长度惩罚](#2. 长度惩罚)
- [3. 格式惩罚](#3. 格式惩罚)
- [4. ExPO 总奖励](#4. ExPO 总奖励)
- [5. Dynamic Sampling：只保留任务结果真正有差异的 Group](#5. Dynamic Sampling：只保留任务结果真正有差异的 Group)
- [6. 组内 Advantage](#6. 组内 Advantage)
- [7. GRPO Clipped Objective](#7. GRPO Clipped Objective)
- [8. 为什么 Order 能在没有单独排序奖励时学出来](#8. 为什么 Order 能在没有单独排序奖励时学出来)
八、实验设置
- [1. Benchmark 与任务](#1. Benchmark 与任务)
- [2. Executor 与 Composer](#2. Executor 与 Composer)
- [3. Baseline](#3. Baseline)
- [4. pass 1 ^1 1 与 pass 4 ^4 4](#4. pass 1 ^1 1 与 pass 4 ^4 4)
[九、主实验：MemComposer 是否真的优于 Top- k k k 和单条 Utility Learning](#九、主实验：MemComposer 是否真的优于 Top- k k k 和单条 Utility Learning)
- [1. Qwen3-4B-Instruct](#1. Qwen3-4B-Instruct)
- [2. Ministral-3-8B-Instruct](#2. Ministral-3-8B-Instruct)
- [3. 统计显著性：最强 Baseline 的单 Executor 差距仍未完全坐实](#3. 统计显著性：最强 Baseline 的单 Executor 差距仍未完全坐实)
[十、效率：更高分是否来自塞入更多 Memory](#十、效率：更高分是否来自塞入更多 Memory)
十一、训练后到底学到了什么
- [1. 选择更多排名靠后的 Candidate](#1. 选择更多排名靠后的 Candidate)
- [2. 不再迷信历史成功标签](#2. 不再迷信历史成功标签)
- [3. Ordering Gain 不是集合变化造成的](#3. Ordering Gain 不是集合变化造成的)
[十二、Generalization：Assembly Policy 能否跨 Domain、Executor 和 Memory Bank](#十二、Generalization：Assembly Policy 能否跨 Domain、Executor 和 Memory Bank)
- [1. 跨 Domain](#1. 跨 Domain)
- [2. 跨 Executor](#2. 跨 Executor)
- [3. 跨 Memory Source](#3. 跨 Memory Source)
[十三、三个 Case Study：组合、失败经验和顺序为什么重要](#十三、三个 Case Study：组合、失败经验和顺序为什么重要)
- [1. 两条互补记忆覆盖两个约束](#1. 两条互补记忆覆盖两个约束)
- [2. 失败 Memory 仍然包含可复用正确动作](#2. 失败 Memory 仍然包含可复用正确动作)
- [3. 同样五条记忆，顺序改变 0/4 与 4/4](#3. 同样五条记忆，顺序改变 0/4 与 4/4)
十四、消融、敏感性与训练成本
- [1. 没有标准模块删除消融](#1. 没有标准模块删除消融)
- [2. Retrieval Budget 敏感性](#2. Retrieval Budget 敏感性)
- [3. Training Cost](#3. Training Cost)
- [4. Reward Design 的潜在敏感点](#4. Reward Design 的潜在敏感点)
十五、失败边界与反例
- [1. 并非所有 Domain Cell 都最好](#1. 并非所有 Domain Cell 都最好)
- [2. Ordering Credit Assignment 仍然纠缠](#2. Ordering Credit Assignment 仍然纠缠)
- [3. Candidate Recall 是硬上限](#3. Candidate Recall 是硬上限)
- [4. Digest 可能丢掉判断所需细节](#4. Digest 可能丢掉判断所需细节)
- [5. 任务反馈昂贵且依赖 Simulator](#5. 任务反馈昂贵且依赖 Simulator)
- [6. 更强 Executor 的必要性尚未验证](#6. 更强 Executor 的必要性尚未验证)
[十六、与 Agent Memory 系列方法的横向比较](#十六、与 Agent Memory 系列方法的横向比较)
- [1. 它补的是"Memory Presentation Policy"](#1. 它补的是“Memory Presentation Policy”)
- [2. 它把 Memory Use 从 Retrieval 变成 Context Construction](#2. 它把 Memory Use 从 Retrieval 变成 Context Construction)
- [3. 它还没有联合优化整个链路](#3. 它还没有联合优化整个链路)
[十七、对 Coding Agent、Tool Agent 和 Multi-Agent 的工程启发](#十七、对 Coding Agent、Tool Agent 和 Multi-Agent 的工程启发)
- [1. Coding Agent：不要只检索最相似 Bug](#1. Coding Agent：不要只检索最相似 Bug)
- [2. Tool Agent：失败轨迹不应被简单删除](#2. Tool Agent：失败轨迹不应被简单删除)
- [3. Multi-Agent：Composer 可以成为共享 Memory 的访问控制层](#3. Multi-Agent：Composer 可以成为共享 Memory 的访问控制层)
- [4. 在线系统应把 Composer 做成可回退组件](#4. 在线系统应把 Composer 做成可回退组件)
十八、局限性
- [1. 只研究 Procedural Memory](#1. 只研究 Procedural Memory)
- [2. Executor 规模有限](#2. Executor 规模有限)
- [3. Ordering 没有 Oracle](#3. Ordering 没有 Oracle)
- [4. 缺少关键组件消融](#4. 缺少关键组件消融)
- [5. 第一阶段 Retriever 固定](#5. 第一阶段 Retriever 固定)
- [6. 训练成本较高](#6. 训练成本较高)
- [7. 单 Executor 最强基线差距的置信区间仍跨 0](#7. 单 Executor 最强基线差距的置信区间仍跨 0)
- [8. Heuristic Budget 在 Test Set 上选择](#8. Heuristic Budget 在 Test Set 上选择)
- [9. User Simulator 可能引入偏差](#9. User Simulator 可能引入偏差)
十九、我的理解与启发
- [1. Memory 的核心单位可能不是 Entry，而是 Context Program](#1. Memory 的核心单位可能不是 Entry，而是 Context Program)
- [2. "失败经验"需要局部价值，而不是全局标签](#2. “失败经验”需要局部价值，而不是全局标签)
- [3. Assembly 应该感知 Executor，而不只是 Query](#3. Assembly 应该感知 Executor，而不只是 Query)
- [4. 真正难的是便宜地获得 Sequence-level Feedback](#4. 真正难的是便宜地获得 Sequence-level Feedback)
- [5. Memory Compression 与 Memory Assembly 应联合考虑](#5. Memory Compression 与 Memory Assembly 应联合考虑)
- [6. 排序收益可能是更深层的 Attention Budget 问题](#6. 排序收益可能是更深层的 Attention Budget 问题)
二十、总结
参考资料

前言

在前面的 Agent Memory 研究中，大家通常把注意力放在两个位置：一是 Memory Bank 里应该存什么，二是面对新任务时应该怎样把相关记忆找回来。

A-MEM 让记忆条目建立动态关联，MAGMA 用多粒度、多关系结构组织历史，CoM 关注长历史的压缩与延续，ReMemR1 让 Agent 在形成新记忆时主动回访旧信息，Mem²Evolve 则进一步研究记忆如何随着经验持续演化。

这些方法不断提升"记忆本身"的质量，但在 Memory Retrieval 和最终 Agent Execution 之间，还藏着一个经常被忽略的环节：

检索器已经返回了 10 条候选记忆，究竟应该把哪几条交给 Agent？应该给几条？又应该按什么顺序摆放？

最常见的做法是按 Embedding Similarity 排序，然后固定取 Top- k k k。这套做法隐含了三个假设：

越相似的记忆越有用；
给得越多越好，或者至少不会更差；
只要记忆集合不变，呈现顺序就不重要。

MemComposer 通过实验说明，这三个假设都不可靠。

一个与当前任务语义高度相似的案例，可能恰好缺少当前任务需要的权限检查；一个表面不太相似的案例，反而保存了可迁移的正确操作。增加记忆数量会引入噪声和冲突，同一组记忆仅仅调整顺序，也可能让 Agent 从 0/4 成功变成 4/4 成功。

因此，作者不再把 Recall 看成"独立给每条记忆打分并截断 Top- k k k"，而是把它重新定义成一个 Query-specific Memory Assembly 问题：模型需要联合阅读 Query 和所有候选，生成一个长度可变、顺序明确的记忆序列。

为了训练这个 Composer，论文提出 Experience Policy Optimization（ExPO）。它不依赖人工标注哪条记忆有用，而是把每个候选记忆序列真正交给冻结的 Agent，在多轮工具交互中执行若干次，再用最终任务是否成功作为奖励。

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

MemComposer 将 Agent Memory 的使用方式，从"按相似度独立排序后固定取 Top- k k k"，改写为"基于完整下游执行反馈，联合学习选择内容、选择数量与呈现顺序的序列级 Memory Assembly Policy"。

它没有替换 Memory Bank，也没有重新训练 Executor，而是在 Retriever 和 Executor 之间增加了一个可学习的"记忆编排层"。这正是本文相对 MemRL、Memento 以及普通 Reranker 的根本区别。

零、论文基本信息

论文名称： MemComposer: Learning to Assemble Memories for LLM Agents via Reinforcement Learning
发表平台： arXiv
代码仓库： 未提供
作者： Yixuan Xie、Xueqiang Xu、Xinyi Fan、Xinxi Lyu、Tao Feng、Xing Fan、Chenlei Guo、Jie Hao、Shaowen Wang、Jiashuo Sun、Jiawei Han

一、背景：Similarity Retrieval 为什么没有解决 Memory Usefulness

1. 相似，不等于对当前决策有帮助

先看论文最直接的反例。

Figure 1：Semantic Similarity ≠ \neq = Memory Usefulness。 当前任务是把销售预测写入共享表格；更相似的销售预测案例忽略了权限问题，较不相似的照片备份案例却提示 Agent 先申请写权限，因此后者真正帮助任务成功。

当前任务要求把准备好的 Sales Forecast 写入 Orion 团队的共享 Spreadsheet。

最相似的记忆同样与 Sales Forecast 有关，于是它指导 Agent 直接写入。但当前任务真正的瓶颈不是数据内容，而是访问权限，结果写入被拒绝。

另一条记忆描述的是自动照片备份，表面语义更远，却记录了"写入失败后先请求权限，再重试"的正确策略。Agent 迁移这条程序性经验后，任务成功。

这说明 Embedding Similarity 衡量的是文本或任务表面是否接近，不能直接衡量一条经验是否能改变当前 Agent 的关键决策。

2. 单条记忆的价值不是固定属性

MemRL、Memento 等工作开始用下游结果学习 Memory Utility，这是重要进步。但如果仍然逐条为记忆估值，再把最高分条目拼起来，就会忽略记忆之间的组合效应。

两条记忆可能分别只覆盖一半约束：

第一条提醒"不要取消订单"；
第二条提醒"不要在缺少政策依据时发放补偿"。

单看任何一条都不完整，组合起来才覆盖当前任务。反过来，两条各自有用的记忆也可能互相冲突，或者在 Prompt 中重复占用大量 Token。

因此，Memory Utility 不是纯粹的 u ( q , m i ) u(q,m_i) u(q,mi)，还取决于它与其他记忆的组合及位置：

u ( q , m i ∣ S − i , pos ⁡ ( m i ) ) u\bigl(q,m_i\mid S_{-i},\operatorname{pos}(m_i)\bigr) u(q,mi∣S−i,pos(mi))

这不是论文单独提出的训练公式，而是理解其问题设定的直观表达：同一条记忆放入不同集合、处于不同位置，边际作用可能不同。

3. Memory Count 不是越大越好

Figure 2：记忆数量与顺序的影响。 左侧扫描不同 Top- k k k，三个领域的最优数量并不一致且曲线非单调；右侧固定记忆集合，仅改变排序规则，任务结果仍发生明显变化。

Retail、Airline、Telecom 三个领域对 k k k 的偏好完全不同。增加候选有时提升 pass 1 ^1 1，有时让 pass 4 ^4 4 下降；即使某个领域偏好多条记忆，最佳数量也不一定迁移到另一个领域。

原因并不难理解：

太少时，关键约束没有覆盖；
太多时，无关步骤、错误轨迹和相互冲突的建议进入上下文；
Memory Token 增多还会稀释 Executor 对关键证据的注意力。

4. Order 不是排版细节

Figure 2 右侧固定同一组记忆，只在 Similarity、Reverse Similarity、Length Ascending 和 Length Descending 之间改变顺序，pass 1 ^1 1 仍然变化。

这与 In-context Learning 中的顺序敏感性一致：位置会影响模型读取、归纳和使用示例的方式。于是，Memory Assembly 至少包含三个耦合决策：

Content： 选哪些；
Budget： 选多少；
Presentation： 按什么顺序给。

二、相关工作：MemComposer 与已有 Recall Learning 的差异

1. Memory Representation

ExpeL、ReasoningBank、AWM、Voyager、SkillOS、MemGPT、Mem0、A-MEM 等方法分别保存反思、轨迹、工作流、技能、事实或通用 Memory Record。它们主要改进"经验如何表示"和"Memory Bank 如何维护"。

MemComposer 不重新定义 Memory Entry，而是接收已有的轨迹记忆与 Hindsight Review，学习怎样把它们组织成当前任务的上下文。

2. Similarity、Reranking 与 Learned Utility

BM25、Dense Retrieval 和 Cross-encoder Reranker 通常学习 Query 与单条 Document 的相关性。MemRL 为记忆维护 Value，Memento 学习一条 Case 是否有帮助。

这些方法的基本单位仍是单条记忆。MemComposer 的动作却是一个完整的 Ordered Subset。它可以：

跳过排名靠前但无用的记忆；
选择排名靠后的补充经验；
同时选择多条互补记忆；
返回空列表，让 Agent 不使用记忆；
把关键记忆放到更有利的位置。

3. In-context Demonstration Selection 与 RAG Context Selection

已有工作也用下游 Likelihood、Relevance Label 或单次回答质量训练示例选择和 Passage Reranking。

本文更困难的地方在于，候选是带 Review 的完整 Agent Trajectory，一次 Memory Context 的质量必须通过多轮工具交互和模拟用户才能知道。奖励稀疏、成本高，而且 Agent Execution 本身具有随机性，不能用一次 Rollout 可靠判断。

三、方法总览：Retriever 之后再增加一个 Composer

理解全文最好的方式，是先看 Memory Bank 构建和 ExPO 训练如何连接。

Figure 3：MemComposer 总体框架。 上半部分从冻结 Executor 的成功与失败轨迹中构建固定 Memory Bank；下半部分从 Top- n n n 候选中采样多个有序、变长的记忆序列，通过完整 Agent Execution 得到奖励，再用 ExPO 更新 Composer，Executor、Retriever 和 Memory Bank 始终冻结。

整个系统分成两条流程。

第一条是离线 Memory Bank Construction：

冻结 Executor 在训练任务上执行多次；
保存完整轨迹和环境结果；
同一模型进行 Hindsight Review；
用确定性规则检查 Review 一致性；
筛选后写入固定 Memory Bank。

第二条是 Composer Training：

Retriever 先返回 Top- n n n 候选；
Composer 联合阅读 Query 和所有 Candidate Digest；
采样 G G G 个不同长度、不同顺序的 Memory Sequence；
每个 Sequence 交给冻结 Executor 执行 J J J 次；
用任务成功率、长度惩罚和格式惩罚得到 ExPO Reward；
计算组内相对 Advantage，只更新 Composer。

关键隔离是：训练期间只有 Composer 改变。若最终性能提升，可以更明确地归因于 Memory Assembly，而不是 Executor 能力、Retriever 或 Memory Bank 发生了变化。

四、问题定义：从 Top- n n n 候选生成变长有序子集

1. 输入、动作与环境反馈

设 Composer Policy 为 π θ \pi_\theta πθ，冻结 Executor 为 π e \pi_e πe。对于任务 Query q q q，固定 Retriever 从 Memory Bank B \mathcal{B} B 中返回：

M ( q ) = { m 1 , m 2 , ... , m n } \mathcal{M}(q)=\{m_1,m_2,\dots,m_n\} M(q)={m1,m2,...,mn}

MemComposer 的动作不是选择单个 Index，而是生成一个不重复的有序子集：

S = ( m i 1 , m i 2 , ... , m i k ) , 0 ≤ k ≤ n S=(m_{i_1},m_{i_2},\dots,m_{i_k}),\qquad 0\le k\le n S=(mi1,mi2,...,mik),0≤k≤n

k = 0 k=0 k=0 表示不使用任何记忆。这一点很重要：如果候选全是噪声，Composer 可以拒绝 Recall，而不是被迫把某条最相似记忆塞给 Agent。

冻结 Executor 接收 ( q , S ) (q,S) (q,S)，与环境和模拟用户进行多轮交互，最终得到二元任务结果：

r ∈ { 0 , 1 } r\in\{0,1\} r∈{0,1}

2. 优化目标

记 R ( q , S ) R(q,S) R(q,S) 为 Executor 在 Query q q q 下使用 Memory Sequence S S S 的期望成功奖励，训练目标为：

max ⁡ θ E q ∼ D t r a i n E S ∼ π θ ( ⋅ ∣ q , M ( q ) ) $R ( q , S )$ \max_{\theta}\; \mathbb{E}{q\sim\mathcal{D}{\mathrm{train}}} \mathbb{E}{S\sim\pi\theta(\cdot\mid q,\mathcal{M}(q))} \left $R(q,S)\\right$ θmaxEq∼DtrainES∼πθ(⋅∣q,M(q)) $R(q,S)$

第一层期望跨训练任务，第二层期望跨 Composer 采样的 Memory Sequence。

它没有要求选出的记忆与 Query 最相似，也没有监督某条记忆应该排第几。唯一最终标准是：这个组合真正交给 Agent 后，任务成功概率是否提高。

五、自生成 Memory Bank：轨迹、结果与回顾如何变成记忆

1. 每个训练任务执行 8 次

对于每个 Domain 和 Executor，作者在每个训练任务上执行 N = 8 N=8 N=8 个独立 Rollout。环境 Outcome Reward 判断数据库最终状态和 Agent 对用户的说明是否满足任务要求。

Memory Bank 只使用训练集轨迹，Test Task 不会进入 Memory Construction。

2. 失败回顾与成功审计

同一个模型对自己的轨迹做 Hindsight Review。

对于失败轨迹，Reviewer 找到第一个错误 Agent Turn，解释 Root Cause，并说明正确动作；如果同一任务有成功轨迹，还会把它作为对照。

对于成功轨迹，系统不会直接假设一切正确，而是检查 Agent 是否：

向用户提供了错误信息；
声称执行了实际没有执行的操作；
虽然数据库状态正确，却违反了交互政策。

因此，轨迹被分成三类：

Clean Pass： 成功且没有关键错误；
Fake Pass： 环境判定成功，但 Review 发现关键交互错误；
Failure： 环境任务失败。

3. Consistency Check

Review 进入 Memory Bank 前必须通过确定性检查：

引用的 Turn 必须真实存在；
被引用 Turn 必须由 Agent 产生；
Review 声称的结果必须与环境 Reward 一致；
输出必须满足规定格式。

任何一项失败，Review 和对应 Rollout 一起丢弃。

4. Curation 与两种表示

每个训练任务最多保留两条记忆：若成功与失败都存在，则尽量各保留一条；否则从同类结果中随机选两条。

一条完整轨迹加 Review 平均有 2.3K-3.0K Token，10 条同时交给 Composer 会过长。因此，每条 Memory 有两种表示：

Digest： 首条用户消息、Outcome Label、关键动作摘要和 Review，平均 1.0K-1.4K Token，供 Composer/Reranker 阅读；
Full Form： 完整轨迹加 Review，只在某条 Memory 被选中后交给 Executor。

这是一种很实用的两阶段压缩：Composer 用摘要做组合决策，Executor 仍然得到完整程序性细节。

Executor	Domain	Memory 数量	Clean Pass (%)	Fake Pass (%)	Failure (%)
Qwen3-4B	Retail	143	37.8	2.8	59.4
Qwen3-4B	Airline	58	19.0	19.0	62.1
Qwen3-4B	Telecom	141	12.8	8.5	78.7
Ministral-3-8B	Retail	144	27.1	11.1	61.8
Ministral-3-8B	Airline	57	15.8	14.0	70.2
Ministral-3-8B	Telecom	144	22.9	6.9	70.1

Table 7：Memory Bank 统计。 各 Bank 中失败轨迹占多数，说明 Composer 不能简单把历史成功标签当作选择标准。

5. Retrieval 只负责生成 Candidate Pool

Memory 以第一条用户消息建立索引，使用 Qwen3-Embedding-8B 计算 Cosine Similarity。每个任务先取 Top-10，所有方法共享同一 Candidate Pool。

因此，实验比较的是"面对相同候选，怎样使用"，而不是谁的第一阶段召回覆盖率更高。

六、MemComposer：一次生成内容、数量与顺序

Composer 联合读取 Query 和 10 条 Candidate Digest，并生成：

S ∼ π θ ( ⋅ ∣ q , M ( q ) ) S\sim\pi_\theta\bigl(\cdot\mid q,\mathcal{M}(q)\bigr) S∼πθ(⋅∣q,M(q))

实际输出包含两个部分：

text 复制代码

<reasoning>
分析每条候选与当前任务的关系、互补性和风险
</reasoning>
<answer>[1, 6, 5, 8]</answer>

列表中的 Index 必须来自 1 1 1 到 n n n，不能重复；顺序就是 Executor 接收完整记忆的顺序。空列表合法，表示无记忆执行。

这套动作空间比 Top- k k k 大得多。若有 n n n 条候选，Composer 可以输出任意长度的排列子集，其数量随 n n n 快速增长。论文没有穷举，而是用 Policy Sampling 与 Group-relative Reward 学习。

七、Experience Policy Optimization：如何用完整 Agent 执行训练 Composer

1. 为什么每个 Sequence 要执行多次

Agentic Execution 具有随机性。同一 Query、同一 Memory Sequence，也可能因为 User Simulator、工具交互或模型采样得到不同结果。

因此，ExPO 对每个 S g S_g Sg 使用冻结 Executor 执行 J J J 次，并以经验成功率作为任务奖励：

r g t a s k = 1 J ∑ j = 1 J r g , j r_g^{\mathrm{task}} =\frac{1}{J}\sum_{j=1}^{J}r_{g,j} rgtask=J1j=1∑Jrg,j

其中 r g , j ∈ { 0 , 1 } r_{g,j}\in\{0,1\} rg,j∈{0,1}。论文使用 J = 8 J=8 J=8，因此任务奖励以 0.125 为最小步长。

2. 长度惩罚

只追求成功率容易让 Composer 把 10 条 Memory 全部塞入 Prompt。作者增加 Selection-size Penalty：

p l e n ( k g ) = λ l e n max ⁡ ( 0 , k g − K max ⁡ ) p_{\mathrm{len}}(k_g)=\lambda_{\mathrm{len}}\max(0,k_g-K_{\max}) plen(kg)=λlenmax(0,kg−Kmax)

Retail 和 Airline 使用 λ l e n = 0.01 \lambda_{\mathrm{len}}=0.01 λlen=0.01、 K max ⁡ = 0 K_{\max}=0 Kmax=0；Telecom 使用 λ l e n = 0.02 \lambda_{\mathrm{len}}=0.02 λlen=0.02、 K max ⁡ = 7 K_{\max}=7 Kmax=7，因为初步实验中 Telecom 容易选得过多。

候选最多 10 条，所以长度惩罚最大不超过 0.1，小于任务奖励的最小差值 0.125。它不会把成功率更低的 Sequence 排到成功率更高的 Sequence 前面，只会在任务结果相同或非常接近时偏好更短上下文。

3. 格式惩罚

输出必须包含闭合的 Answer Section 和合法 Index List。越界 Index、缺少列表或 Answer 未闭合都会直接判无效，不执行 Executor，最终 Reward 为 0。

合法输出若缺少 Reasoning Section，施加 λ f m t = 0.05 \lambda_{\mathrm{fmt}}=0.05 λfmt=0.05 的惩罚。重复 Index 会保留第一次出现，其余去重。

4. ExPO 总奖励

r g E x P O = r g t a s k − p l e n ( k g ) − p f m t ( S g ) r_g^{\mathrm{ExPO}} =r_g^{\mathrm{task}} -p_{\mathrm{len}}(k_g) -p_{\mathrm{fmt}}(S_g) rgExPO=rgtask−plen(kg)−pfmt(Sg)

这三个部分的优先级很清楚：任务成功是主信号，长度用于控制 Context Cost，格式保证 Policy 输出可执行。

5. Dynamic Sampling：只保留任务结果真正有差异的 Group

每个 Query 从旧 Policy π θ o l d \pi_{\theta_{\mathrm{old}}} πθold 采样 G = 8 G=8 G=8 个 Sequence。如果一个 Group 中所有 Sequence 的 Task Outcome Reward 完全相同，作者就丢弃它并继续采样。

筛选依据是 r t a s k r^{\mathrm{task}} rtask，不是含惩罚的总 Reward。这样可以避免一种投机：Group 中所有 Memory Context 对任务都同样无效，却仅因长度或格式不同产生 Advantage。

6. 组内 Advantage

对于保留的 Group，Sequence g g g 的 Advantage 是其 ExPO Reward 减去组均值：

A g = r g E x P O − 1 G ∑ h = 1 G r h E x P O A_g=r_g^{\mathrm{ExPO}}-\frac{1}{G}\sum_{h=1}^{G}r_h^{\mathrm{ExPO}} Ag=rgExPO−G1h=1∑GrhExPO

论文不再除以 Group Standard Deviation，因为当各 Sequence Reward 很接近时，标准差归一化会放大奖励噪声。

7. GRPO Clipped Objective

对 Composer 输出第 t t t 个 Token，记新旧 Policy 的 Likelihood Ratio 为 ρ g , t ( θ ) \rho_{g,t}(\theta) ρg,t(θ)，Clipped Surrogate 为：

ℓ g , t ( θ ) = min ⁡ { ρ g , t ( θ ) A g , clip ⁡ ( ρ g , t ( θ ) , 1 − ϵ , 1 + ϵ ) A g } \ell_{g,t}(\theta)=\min\left\{ \rho_{g,t}(\theta)A_g, \operatorname{clip}\bigl(\rho_{g,t}(\theta),1-\epsilon,1+\epsilon\bigr)A_g \right\} ℓg,t(θ)=min{ρg,t(θ)Ag,clip(ρg,t(θ),1−ϵ,1+ϵ)Ag}

最终 Loss 对 Batch 中全部有效 Sequence 的 Token 求平均：

L E x P O ( θ ) = − 1 ∑ g T g ∑ g ∑ t = 1 T g ℓ g , t ( θ ) \mathcal{L}{\mathrm{ExPO}}(\theta) =-\frac{1}{\sum_gT_g} \sum_g\sum{t=1}^{T_g}\ell_{g,t}(\theta) LExPO(θ)=−∑gTg1g∑t=1∑Tgℓg,t(θ)

T g T_g Tg 是 Composer 输出长度。ExPO 不使用 Reference Policy KL Penalty，也不更新 Executor、Retriever 或 Memory Bank。

8. 为什么 Order 能在没有单独排序奖励时学出来

Executor 严格按照 S g S_g Sg 中的顺序接收记忆。若同一集合在不同顺序下产生不同成功率，Sequence-level Reward 会把这种差异反映到整个输出概率上。

但这也带来归因问题：一次 Sample 往往同时改变 Content 和 Order，所以 ExPO 只能隐式学习排序，无法精确知道收益来自哪一个位置交换。论文在 Limitations 中明确承认这一点。

八、实验设置

1. Benchmark 与任务

实验使用 τ 2 \tau^2 τ2-bench 的三个多轮客服领域：

Retail： 74 个训练任务、40 个测试任务；
Airline： 30 个训练任务、20 个测试任务；
Telecom： 74 个训练任务、40 个测试任务。

每个 Test Task 执行 4 次，共 400 个 Test Episode。Agent 必须遵守领域 Policy、调用工具、修改数据库，并与 GLM-4.7 模拟用户交互。Episode 在任务完成、用户结束对话或达到 50 Step 时终止。

2. Executor 与 Composer

两种冻结 Executor：

Qwen3-4B-Instruct-2507，本地 vLLM Serving；
Ministral-3-8B-Instruct，通过 AWS Bedrock API。

Executor 使用 Temperature 0，不更新参数。Composer 在对应 Backbone 上通过 LoRA 训练，Rank 64、Scaling Factor 128、Dropout 0，共进行 30 次 Policy Update。

每个 Prompt 有 10 条候选，采样 G = 8 G=8 G=8 个 Sequence，每个 Sequence 执行 J = 8 J=8 J=8 次。Qwen Composer 学习率为 2 × 10 − 5 2\times10^{-5} 2×10−5，Ministral 为 1 × 10 − 5 1\times10^{-5} 1×10−5，Policy Clip ϵ = 0.2 \epsilon=0.2 ϵ=0.2，KL 和 Entropy Coefficient 都为 0。

3. Baseline

所有方法使用相同 Executor、User Simulator、Memory Bank 和 Top-10 Candidate Pool。

No Memory： 不注入经验；
Similarity-based： 按 Query Embedding 相似度取 Top- k k k；
Complexity-based： 用完整轨迹 Token 长度近似程序性细节，取最长 Top- k k k；
Qwen3-Reranker-8B： Off-the-shelf Cross-encoder，固定取 5 条；
Vanilla Selector： 使用同一 Selection Prompt，但不训练；
MemRL： 用历史任务结果维护单条 Memory Value；
Memento： 学习 Query-Case Pair 是否有帮助，固定选 5 条。

Heuristic Baseline 扫描 k ∈ { 1 , 2 , 3 , 5 , 7 } k\in\{1,2,3,5,7\} k∈{1,2,3,5,7}；主表在 { 1 , 3 , 5 , 7 } \{1,3,5,7\} {1,3,5,7} 中按 Test Average pass 1 ^1 1 选择最佳 k k k。这一做法对 Heuristic 较有利，但也包含 Test-set Model Selection，属于结果解读时需要注意的评估设计。

4. pass 1 ^1 1 与 pass 4 ^4 4

若一个任务 4 次 Trial 中成功 c c c 次，论文使用：

p a s s k = ( c k ) ( 4 k ) \mathrm{pass}^{k}=\frac{\binom{c}{k}}{\binom{4}{k}} passk=(k4)(kc)

pass 1 ^1 1 等价于平均成功率；pass 4 ^4 4 只有 4 次全部成功时才为 1，因此衡量一致性。跨 Domain 使用不加权宏平均。

九、主实验：MemComposer 是否真的优于 Top- k k k 和单条 Utility Learning

1. Qwen3-4B-Instruct

Method	Retail pass 1 ^1 1/pass 4 ^4 4	Airline pass 1 ^1 1/pass 4 ^4 4	Telecom pass 1 ^1 1/pass 4 ^4 4	Avg. pass 1 ^1 1/pass 4 ^4 4
No Memory	45.6 / 30.0	32.5 / 10.0	22.5 / 2.5	33.5 / 14.2
Similarity-based	53.7 / 30.0	50.0 / 25.0	29.4 / 5.0	44.4 / 20.0
Complexity-based	51.9 / 37.5	40.0 / 30.0	37.5 / 15.0	43.1 / 27.5
Qwen3-Reranker-8B	54.4 / 35.0	46.2 / 30.0	31.9 / 7.5	44.2 / 24.2
MemRL	56.9 / 22.5	41.2 / 10.0	35.6 / 20.0	44.6 / 17.5
Memento	53.1 / 37.5	46.2 / 35.0	35.6 / 7.5	45.0 / 26.7
Vanilla Selector	50.0 / 22.5	43.8 / 30.0	34.4 / 10.0	42.7 / 20.8
MemComposer	60.0 / 42.5	52.5 / 35.0	40.0 / 20.0	50.8 / 32.5

Table 1（Qwen3-4B-Instruct）： τ 2 \tau^2 τ2-bench 主实验。 MemComposer 在三个领域的 pass 1 ^1 1 都最高，并以 50.8/32.5 获得最高宏平均 pass 1 ^1 1/pass 4 ^4 4。

相对最强 Avg. Baseline，MemComposer 的 pass 1 ^1 1 提升 5.9 Point，pass 4 ^4 4 提升 5.0 Point。

更值得注意的是 Telecom。No Memory 的 pass 4 ^4 4 只有 2.5，Similarity 只有 5.0；MemComposer 达到 20.0。它没有只利用成功案例，而是从 Failure-heavy Bank 中选择可迁移操作和 Review，提升了稳定完成任务的概率。

2. Ministral-3-8B-Instruct

Method	Retail pass 1 ^1 1/pass 4 ^4 4	Airline pass 1 ^1 1/pass 4 ^4 4	Telecom pass 1 ^1 1/pass 4 ^4 4	Avg. pass 1 ^1 1/pass 4 ^4 4
No Memory	58.1 / 32.5	17.5 / 10.0	51.9 / 25.0	42.5 / 22.5
Similarity-based	68.1 / 40.0	38.8 / 20.0	63.7 / 45.0	56.9 / 35.0
Complexity-based	65.6 / 45.0	36.2 / 20.0	73.8 / 40.0	58.5 / 35.0
Qwen3-Reranker-8B	62.5 / 35.0	28.7 / 5.0	66.2 / 37.5	52.5 / 25.8
MemRL	70.6 / 45.0	30.0 / 15.0	76.2 / 55.0	58.9 / 38.3
Memento	66.9 / 47.5	36.2 / 10.0	70.0 / 45.0	57.7 / 34.2
Vanilla Selector	64.4 / 30.0	37.5 / 10.0	66.9 / 45.0	56.3 / 28.3
MemComposer	75.0 / 47.5	40.0 / 20.0	75.6 / 52.5	63.5 / 40.0

Table 1（续，Ministral-3-8B-Instruct）： τ 2 \tau^2 τ2-bench 主实验。 MemComposer 获得最高平均 pass 1 ^1 1 和 pass 4 ^4 4，但在 Telecom 上 MemRL 略高，说明它并非所有 Domain-Metric Cell 都占优。

MemComposer 平均 pass 1 ^1 1 比最强 Baseline MemRL 高 4.6 Point，pass 4 ^4 4 高 1.7 Point。论文总共比较 2 个 Executor × 3 个 Domain × 2 个 Metric，MemComposer 在 12 个 Cell 中有 10 个 Best 或 Tied-best。

3. 统计显著性：最强 Baseline 的单 Executor 差距仍未完全坐实

作者对 Test Task 做 10,000 次 Paired Bootstrap。

在 Qwen Executor 上，MemComposer 相对 Memento 的 pass 1 ^1 1 差距为 +5.9，但 95% CI 为 $- 0.8 , 12.7$ $-0.8,12.7$ $-0.8,12.7$ ；在 Ministral 上相对 MemRL 为 +4.6，CI 为 $- 1.0 , 10.4$ $-1.0,10.4$ $-1.0,10.4$ 。两个区间都跨过 0。

把两个 Executor 合并后，pass 1 ^1 1 相对所有 Baseline 的 CI 都排除 0；pass 4 ^4 4 对 Complexity 和 Memento 的 CI 仍跨 0。

因此，最稳妥的结论不是"每个 Executor 上都显著击败最强 Baseline"，而是：

MemComposer 在不同 Domain 和 Executor 上呈现一致的正向趋势，并以更少 Memory Token 达到 Best/Tied-best 结果；但官方 Test Split 只有 20-40 个 Task，尚不足以精确确定它相对单个最强 Baseline 的真实优势幅度。

十、效率：更高分是否来自塞入更多 Memory

Figure 7：Performance-Memory-token Trade-off。 每个点代表一种方法或 Retrieval Budget；虚线表示同一 Token Budget 下 Baseline 的最好前沿，MemComposer 在两个 Executor 上都位于前沿之上。

MemComposer 并不是靠增加上下文换取提升。

跨三个 Domain：

Qwen3-4B-Instruct 使用的 Memory Token 比最强 Baseline 少 16.9%；
Ministral-3-8B-Instruct 少 4.9%。

Figure 8：Retail Trade-off。 Qwen3-4B-Instruct 上，MemComposer 使用约 9.2K Memory Token 达到 60.0 pass 1 ^1 1；Similarity Top-10 使用约 24.3K Token 仍只有 57.5。

在 Retail 上，MemComposer 只用 Similarity Top-10 约 38% 的 Memory Token，性能反而更高；在 9.2K Token 以内，没有 Baseline 超过 51.2 pass 1 ^1 1。

这支持了论文的核心判断：Memory Context 的价值来自有针对性的组合，而不是单纯扩大 Recall Budget。

十一、训练后到底学到了什么

1. 选择更多排名靠后的 Candidate

Figure 4：Selection Rank 的变化。 训练后 Top 1-3 候选的选择占比下降，Rank 4-10 占比上升；被选记忆的平均相似度排名从 3.21 移到 4.35。

在同一组 40 个 Retail Task 和 Top-10 Pool 上，训练让平均选择数量从 2.52 增至 3.73，同时不再高度集中于最相似的前三条。

看似"选择更多"与长度惩罚矛盾，其实不矛盾。长度惩罚只在任务成功差异相同的情况下偏好更少；如果多选一条排名靠后的互补 Memory 能提高成功率，任务奖励会覆盖长度成本。

2. 不再迷信历史成功标签

Figure 5：Outcome Label 与选择率。 未训练 Selector 在所有 Rank Band 都更偏好成功 Memory；训练后这种差距明显缩小，并在 Rank 1-3 出现反转。

训练前，在 Rank 4-6 中，Successful Memory 选择率为 32%，其他记忆只有 10%。训练后差距缩小到 6 Point；总体上，被选 Memory 中历史成功案例占比从 45.5% 降至 35.6%。

原因是 ExPO 奖励"这条记忆对当前任务有没有帮助"，而不是"它过去是否成功"。一条 Failure Memory 可能包含正确工具调用，只是在后来价格计算或沟通环节失败。

3. Ordering Gain 不是集合变化造成的

Alternative Order	Composer 相对成功 Trial 均值差	Δ \Delta Δ pass 1 ^1 1
Similarity	+0.220	+5.5
Reverse Similarity	+0.340	+8.5
Length Ascending	+0.270	+6.8
Length Descending	+0.150	+3.8
Average	+0.245	+6.1

Table 2：Composer Order 相对四种固定排序的收益。 记忆集合完全不变，只改变顺序；Composer 平均提升 6.1 pass 1 ^1 1 Point。

这张表隔离了 Ordering 的影响。它证明 Figure 2 中的顺序敏感性不只是现象，学习后的 Composer 确实能找到比固定规则更有效的排列。

十二、Generalization：Assembly Policy 能否跨 Domain、Executor 和 Memory Bank

1. 跨 Domain

Method	Airline pass 1 ^1 1/pass 4 ^4 4	Telecom pass 1 ^1 1/pass 4 ^4 4
No Memory	32.5 / 10.0	22.5 / 2.5
Similarity	50.0 / 25.0	29.4 / 5.0
Complexity	40.0 / 30.0	37.5 / 15.0
Vanilla Selector	43.8 / 30.0	34.4 / 10.0
MemComposer In-domain	52.5 / 35.0	40.0 / 20.0
Retail-trained → Target	53.8 / 35.0	38.8 / 22.5

Table 3：Retail-trained Composer 跨 Domain 迁移。 在不重新训练的情况下迁移到 Airline 和 Telecom，结果与 In-domain Training 接近，并优于 Heuristic 与 Vanilla Selector。

Retail→Airline 的 pass 1 ^1 1 甚至从 52.5 升到 53.8，pass 4 ^4 4 保持 35.0；Retail→Telecom 损失 1.2 pass 1 ^1 1，却增加 2.5 pass 4 ^4 4。

这说明 Composer 学到的不只是 Retail Tool 名称，而是更一般的经验组合原则，例如约束覆盖、错误诊断互补和程序性步骤匹配。

2. 跨 Executor

Method	Retail pass 1 ^1 1	Retail pass 4 ^4 4
No Memory	58.1	32.5
Similarity	68.1	40.0
Complexity	65.6	45.0
Vanilla Selector	64.4	30.0
MemComposer（Ministral 训练）	75.0	47.5
MemComposer（Qwen 4B 训练后迁移）	70.6	50.0

Table 4：跨 Executor 迁移。 Qwen3-4B 上训练的 Composer 直接服务 Ministral Executor，pass 1 ^1 1 低于 In-domain Composer，但 pass 4 ^4 4 更高。

这项结果很有价值，但不能推到 Frontier Model。两个 Executor 只有 4B 和 8B，而且都使用相似的客服轨迹格式。论文也把更大模型是否仍需要独立 Composer 列为开放问题。

3. 跨 Memory Source

Figure 6：Memory Source 的影响。 固定 Qwen3-4B Executor，只替换由 Qwen3-32B、GPT-5.4 mini、Qwen3-235B、GPT-5.4 等模型生成的 Memory Bank；Composer 不重新训练。

Similarity Top-5 并没有因为 Memory Source 更强就稳定提高。在 Retail 上，GPT-5.4 Bank 与 Executor 自己的 Bank 接近。

MemComposer 在 10 个 Domain-Bank Pair 中有 9 个 Matching 或 Outperforming Similarity Top-5；在所有未见 Bank 上平均 pass 4 ^4 4 提升 9.1 Point，即便 GPT-5.4 Bank 也提升 7.5 Point。

这说明"生成更高质量 Memory"和"为当前 Query 选择合适 Memory"是两个独立问题。把 Bank 做得更强，并不会自动消除 Assembly 的必要性。

十三、三个 Case Study：组合、失败经验和顺序为什么重要

1. 两条互补记忆覆盖两个约束

Airline 任务中，用户抱怨航班延误，但明确不想取消或修改预订，同时要求赔偿。

第一条 Failure Memory 提醒 Agent：没有符合政策的理由时，不要取消或修改 Reservation。第二条 Fake-pass Memory 提醒 Agent：没有满足触发条件时，不要提供 Certificate。

任何一条都只覆盖一个错误面。组合后才能同时满足"保持预订不变"和"不给无依据补偿"。这是逐条 Scoring 难以捕获的 Complementarity。

2. 失败 Memory 仍然包含可复用正确动作

Retail 案例中，一条历史轨迹因为错误计算两台 Laptop 的价格差而失败，但其中一台 Laptop 的 Exchange Tool Call 完全正确。

新任务恰好只要求完成这台 Laptop 的 Exchange。Executor 不使用记忆时 0/4 成功，只使用这条 Failure Memory 时 4/4 成功。

这说明 Outcome Label 只能描述整条轨迹，不等于轨迹中每个 Action 的质量。把失败记忆全部过滤掉，会丢失局部可复用操作。

不过这里也存在数据边界：官方 Train/Test Split 可以包含同一 Customer 和 Order 的相关任务，因此这条记忆中的 Tool Call 与 Test Task 高度直接对应。所有方法共享 Candidate Pool，所以比较仍公平，但它更接近"相关任务复用"，不能完全代表跨客户、跨实体的抽象迁移。

3. 同样五条记忆，顺序改变 0/4 与 4/4

在吸尘器换货任务中，MemComposer 和 Similarity 使用完全相同的五条 Memory。

MemComposer 顺序为 [8] → [1] → [7] → [3] → [6]，Executor 4/4 成功；Similarity 顺序为 [1] → [3] → [6] → [7] → [8]，结果 0/4。

作者推测可能是 Positional Attention：关键 Memory $8$ 在 Composer 顺序中位于开头，在 Similarity 顺序中排在最后而被忽略。这个解释合理，但只是 Case-level Hypothesis，论文没有通过 Attention Probe 或位置交换实验进一步验证机制。

十四、消融、敏感性与训练成本

1. 没有标准模块删除消融

论文没有提供"去掉长度惩罚""去掉动态 Group Filter"或"只学 Selection 不学 Ordering"的标准 Ablation。因此，我们无法从实验中精确量化每个 ExPO 设计分别贡献多少。

已有证据更接近针对核心假设的受控分析：

Top- k k k Sweep 证明固定数量不稳；
固定集合重排证明 Order 有独立作用；
Vanilla Selector 对比证明 Prompt 本身不足；
Rank/Label 分布变化说明 RL 改变了选择策略；
Transfer 说明 Policy 不只记住单一 Domain；
Token Frontier 说明提升不是增加 Context Budget。

2. Retrieval Budget 敏感性

完整 Appendix 扫描 k ∈ { 1 , 2 , 3 , 5 , 7 } k\in\{1,2,3,5,7\} k∈{1,2,3,5,7}，性能明显非单调。

例如 Qwen Retail Similarity 的 pass 1 ^1 1 从 k = 1 k=1 k=1 的 49.4、 k = 2 k=2 k=2 的 46.3，上升到 k = 5 k=5 k=5 的 56.2，再在 k = 7 k=7 k=7 降到 53.7；Ministral Airline 的 Similarity 在 k = 3 k=3 k=3 达到 38.8， k = 5 k=5 k=5 又降到 30.0。

这证明固定全局 k k k 很难覆盖不同 Query 和 Executor。

3. Training Cost

每个 Composer 训练 30 次 Policy Update，使用 H100 80GB。

Qwen3-4B Composer 的本地总 GPU-hour：Retail 24.2、Airline 16.3、Telecom 81.7。Ministral Composer 为 7.1、16.2、24.9 GPU-hour，但 Executor 通过 Bedrock API，数字只计算本地 Composer GPU，不包含远程推理资源。

69%-91% 的每步时间用于 Rollout Generation 和 Environment Simulation，真正的 LoRA Update 反而较便宜。

这说明 ExPO 的主要瓶颈不是 Policy Optimization，而是获取低噪声、序列级下游反馈。每个 Prompt 采样 8 个 Sequence、每个 Sequence 再执行 8 次，理论上形成大量交互；相同 Sequence 可以共享 Trial，Dynamic Filtering 也能减少无效 Update，但成本仍显著。

4. Reward Design 的潜在敏感点

Length Penalty 按 Memory Count 而非 Token Length，短轨迹和长轨迹成本被视为相同；
Telecom 使用不同的 K max ⁡ K_{\max} Kmax 与 λ l e n \lambda_{\mathrm{len}} λlen，说明超参数需要领域适配；
Format Penalty 鼓励显式 Reasoning，但论文没有证明 Reasoning 本身改善 Selection；
不使用 KL Constraint，30 Update 内稳定不代表更长训练仍不会 Drift；
Dynamic Sampling 丢弃全同 Outcome Group，提高训练信号，却可能让训练分布偏向 Composer 能影响的任务。

十五、失败边界与反例

1. 并非所有 Domain Cell 都最好

Ministral Telecom 上，MemRL 的 76.2/55.0 高于 MemComposer 的 75.6/52.5。这说明单条 Value Learning 在某些 Candidate Pool 和 Executor 组合上仍可能更适合。

2. Ordering Credit Assignment 仍然纠缠

ExPO 的 Reward 同时作用于 Content、Count 和 Order。一次 Sample 通常改变多个因素，无法知道是哪次位置交换真正带来提升。固定集合重排只证明 Order 有用，不能证明当前学习顺序接近全局最优。

3. Candidate Recall 是硬上限

Composer 只在 Top-10 内重组。如果真正有用的 Memory 没被 Similarity Retriever 召回，MemComposer 无法恢复。Figure 4 显示它会选 Rank 7-10，但没有实验扩大到 Top-50 或让 Composer直接搜索全 Bank。

4. Digest 可能丢掉判断所需细节

Composer 看的是 1.0K-1.4K Token Digest，Executor 看完整轨迹。若 Digest 没保留某个关键 Tool Argument 或 Policy Exception，Composer 可能错误拒绝一条实际上有用的 Memory。

5. 任务反馈昂贵且依赖 Simulator

训练 Reward 来自 GLM-4.7 模拟用户和 τ 2 \tau^2 τ2-bench 环境。若 Simulator 行为与真实用户不同，Composer 可能优化 Simulator-specific Interaction Pattern。

6. 更强 Executor 的必要性尚未验证

Frontier Model 可能已经能直接判断哪条 Memory 有用，额外 Composer 的边际收益可能下降；也可能因为上下文更长而更能利用复杂组合。论文只覆盖 4B 和 8B，无法回答。

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

MemComposer 处在 Memory Lifecycle 的 Recall-to-Use 接口。它与 A-MEM、MAGMA、CoM、ReMemR1、Mem²Evolve 可以组合，而不是互斥替代。

方法	主要优化环节	核心问题	与 MemComposer 的关系
A-MEM	写入与结构演化	新 Note 如何自动建立链接并更新邻居	A-MEM 产生候选，MemComposer 再决定哪些 Note 以何种顺序进入 Executor Context
MAGMA	多粒度、多关系组织与检索	怎样从不同关系视图恢复证据	MAGMA 提高 Candidate Coverage；MemComposer 学习组合多视图结果并控制最终 Budget
CoM	长历史压缩与持续记忆	如何在有限 Context 中保留关键信息	CoM 改善单条或整体 Memory 表示；MemComposer 决定压缩结果的 Query-specific 组合
ReMemR1	Memory Formation 中的 Callback	边读边记时如何主动回访旧信息	ReMemR1 改善写入阶段的信息完整性；MemComposer 改善读取后的呈现方式
Mem²Evolve	经验与记忆机制持续演化	如何用反馈长期更新 Memory	Mem²Evolve 调整 Bank/Mechanism；MemComposer 固定 Bank，只学习 Assembly Policy
MemRL / Memento	学习单条 Memory Utility	哪一条 Memory 更可能有帮助	最近邻方法；MemComposer 将动作提升为变长、有序的 Memory Sequence
MemComposer	Recall 后的序列级组装	选哪些、选多少、怎样排序	不改变 Retriever 和 Executor，用完整任务结果优化 Context Assembly

1. 它补的是"Memory Presentation Policy"

A-MEM、MAGMA、ReMemR1 让 Bank 中的内容和结构更可靠，却不能保证 Retriever 返回的 10 条候选应该全部使用。MemComposer 可以作为独立层接在这些系统后面。

2. 它把 Memory Use 从 Retrieval 变成 Context Construction

传统 Retrieval 关心 Recall 和 Ranking；MemComposer 更接近一个小型 Planner：它需要判断约束覆盖、互补性、冲突、成本和顺序。

这意味着未来 Memory System 的接口可能不再只是 retrieve(query, k)，而是：

text 复制代码

compose(query, candidates, executor_profile, token_budget)
    -> ordered_memory_context

3. 它还没有联合优化整个链路

当前 Retriever 固定、Bank 固定、Executor 固定，利于归因，却也限制上限。更进一步的系统可以联合学习：

第一阶段 Recall；
Candidate Digest；
Assembly；
Executor 如何引用 Memory；
执行结果如何回写 Bank。

但联合训练会重新引入不稳定性和归因困难，MemComposer 的价值之一恰恰是先把 Assembly 单独拆出来验证。

十七、对 Coding Agent、Tool Agent 和 Multi-Agent 的工程启发

以下内容是基于论文结果的工程推演，不是论文直接实验结论。

1. Coding Agent：不要只检索最相似 Bug

一个代码问题可能同时需要：

相似错误的修复 Patch；
另一个任务中的权限或环境配置经验；
测试失败后的诊断步骤；
项目级编码规范；
某个工具调用的正确参数顺序。

它们未必在 Embedding Space 中彼此接近。Composer 可以选择"一个相似 Patch + 一个环境陷阱 + 一个验证流程"，并把最关键约束放到 Prompt 前部。

2. Tool Agent：失败轨迹不应被简单删除

Tool Agent 的失败常发生在长链条后部：前面 API Discovery、参数解析和权限申请都正确，最后一个确认或金额计算出错。

MemComposer 的 Case Study 表明，失败轨迹中仍可能包含当前任务需要的局部动作。工程上应保存：

最早失败点；
失败前的有效步骤；
错误后的恢复动作；
Tool Argument 与环境结果；
可迁移与不可迁移的边界。

然后由 Composer 针对当前 Query 决定是否复用，而不是按整条 Outcome Label 一票否决。

3. Multi-Agent：Composer 可以成为共享 Memory 的访问控制层

多个 Agent 共享 Bank 时，候选可能来自不同 Role、权限和工具环境。Similarity Retriever 容易把语义相近但权限不兼容的经验混在一起。

Composer 可以联合考虑：

Memory Source Agent；
当前 Agent 能调用的 Tool；
目标环境权限；
多条经验是否互相冲突；
Context Budget；
哪条经验应先呈现给哪个角色。

但这需要把 Executor Profile 和 Tool Schema 显式加入 Composer Input，而不是只给 Query 与 Digest。

4. 在线系统应把 Composer 做成可回退组件

生产实现可以设置：

Composer 置信度不足时回退 Similarity Top- k k k；
输出格式错误时回退空 Memory 或安全 Baseline；
对高风险工具任务限制只能使用通过审计的 Memory；
用 Token Budget 作为硬约束，而不是只靠软 Length Penalty；
记录每条 Memory 在最终执行中被引用的位置，改善 Credit Assignment。

十八、局限性

1. 只研究 Procedural Memory

Memory 是完整轨迹加 Review，目标是复用动作并避免错误。语义事实、个人情景记忆、长期偏好和多模态 Memory 的组合规律可能不同。

2. Executor 规模有限

只有 Qwen3-4B 和 Ministral-3-8B。无法判断更强模型是否偏好更少、更长或不同顺序的经验，也无法判断独立 Composer 是否仍有同等价值。

3. Ordering 没有 Oracle

动作空间随 k k k 近似阶乘增长， G = 8 G=8 G=8 的采样非常稀疏。论文只与四种固定顺序比较，没有穷举或 Search-based Oracle，因此"比 Heuristic 好"不等于"接近最优"。

4. 缺少关键组件消融

没有单独去掉 Length Penalty、Format Penalty、Dynamic Filtering、Reasoning Section 或 Multi-trial Reward。ExPO 每个设计的独立贡献尚不清楚。

5. 第一阶段 Retriever 固定

Composer 只能在 Top-10 中工作。方法改善的是 Precision、Budget 和 Presentation，不能解决 Candidate Recall Failure。

6. 训练成本较高

每个 Sequence 需要多次完整 Agent Interaction，主要成本来自 Simulator 和 Environment。换到真实工具、付费 API 或高风险领域后，收集 Reward 的代价会显著增加。

7. 单 Executor 最强基线差距的置信区间仍跨 0

论文提供了严谨的 Paired Bootstrap，但官方 Test Task 数有限。主表中 4.6-5.9 Point 的优势还需要更大样本验证。

8. Heuristic Budget 在 Test Set 上选择

Similarity 与 Complexity 的最佳 k k k 根据 Test Average pass 1 ^1 1 选择，这让 Baseline 获得有利的 Test-time Oracle Budget；它增强了对照强度，但严格来说也不是完全独立的 Model Selection Protocol。

9. User Simulator 可能引入偏差

Memory Construction、Composer Training 和 Evaluation 都使用 GLM-4.7 模拟用户。统一 Simulator 保证横向比较一致，却可能让 Policy 适应同一模拟行为分布。

十九、我的理解与启发

1. Memory 的核心单位可能不是 Entry，而是 Context Program

过去常把一条 Memory 当作独立知识单元。MemComposer 说明，真正交给 Agent 的不是一组无序记录，而是一段有预算、有位置、有相互作用的 Context Program。

它的质量取决于：

是否覆盖任务全部约束；
是否包含互补步骤；
是否存在冲突或重复；
关键经验是否出现在容易被利用的位置；
总 Token 是否超出 Executor 的有效注意力范围。

2. "失败经验"需要局部价值，而不是全局标签

整条轨迹失败，不代表每个动作都错；整条轨迹成功，也不代表没有错误陈述。论文通过 Fake Pass 与 Failure Case 同时证明，Outcome Label 过于粗粒度。

下一步可以把轨迹切成 Decision Segment，为每段标记：正确动作、错误动作、适用前提和影响范围。这样 Composer 不必注入整条 Full Trajectory，也能降低 Token Cost 和错误迁移风险。

3. Assembly 应该感知 Executor，而不只是 Query

跨 Executor Transfer 有效但不完美，说明不同模型对 Memory Context 有不同偏好。更强 Executor 可能能消化更多冲突信息，小模型可能更依赖简洁、靠前的正确步骤。

未来 Composer 的条件变量可以扩展为：

S ∼ π θ ( ⋅ ∣ q , M ( q ) , e , b ) S\sim\pi_\theta(\cdot\mid q,\mathcal{M}(q),e,b) S∼πθ(⋅∣q,M(q),e,b)

其中 e e e 是 Executor Profile， b b b 是 Token/Latency Budget。这样同一 Query 面对不同 Agent 或设备，可以生成不同 Memory Context。

4. 真正难的是便宜地获得 Sequence-level Feedback

MemComposer 的训练信号强，因为它直接来自完整任务成功；代价也高，因为每个 Context 要执行多次。

可能的工程折中包括：

用 Offline Logged Trajectory 估计 Counterfactual Utility；
先用廉价 Judge 过滤明显无效 Sequence；
用 Learned Reward Model 近似部分 Rollout；
对高不确定 Sequence 才执行真实环境；
用 Bandit 或 Bayesian Optimization 自适应分配 Trial；
共享前缀状态，减少重复 Tool Interaction。

5. Memory Compression 与 Memory Assembly 应联合考虑

当前 Composer 看 Digest，Executor 看 Full Form。Digest 决定选择质量，Full Form 决定执行效果，两者之间存在 Representation Gap。

未来可以学习 Query-aware Digest：同一条轨迹面对不同 Query，生成不同摘要。这样不只选择条目，还选择每条 Memory 中应暴露的部分。

6. 排序收益可能是更深层的 Attention Budget 问题

Table 2 和 Case 3 都显示 Order 有效，但论文只提供 Positional Attention 的可能解释。

更完整的研究需要区分：

Primacy/Recency Effect；
Memory 间逻辑依赖顺序；
前一条 Memory 是否为后一条提供概念定义；
相互冲突信息的最后出现者是否占优；
System Prompt 末端位置是否更接近当前 Query。

如果能识别这些机制，Composer 就可以从黑盒序列奖励进一步走向可解释的 Memory Curriculum。

二十、总结

MemComposer 关注的是 Agent Memory 中长期被忽略的最后一公里：Retriever 已经返回候选后，怎样构造真正交给 Executor 的 Memory Context。

它把 Memory Use 定义为一个变长有序子集生成问题，并提出 ExPO：

每个 Query 采样多组 Memory Sequence；
每组通过多次完整 Agent Interaction 估计任务成功率；
用长度和格式惩罚控制成本与有效性；
用 Group-relative Advantage 更新 Composer；
Executor、Retriever 和 Memory Bank 全程冻结。

实验表明：

MemComposer 在两个 Executor 上取得最高平均 pass 1 ^1 1 和 pass 4 ^4 4；
相对最强 Baseline，Qwen pass 1 ^1 1 提升 5.9 Point，Ministral 提升 4.6 Point；
同时分别减少 16.9% 和 4.9% Memory Token；
训练后会选择更多低相似度排名和更多失败经验；
固定 Memory Set 时，学习顺序平均提升 6.1 pass 1 ^1 1 Point；
Policy 能迁移到未见 Domain、Executor 和更强模型生成的 Memory Bank；
但 Ordering Credit、Top-10 Recall 上限、Rollout 成本、组件消融和 Frontier Executor 仍未解决。

一句话概括本文：

有用的 Agent Memory 不是"最相似的几条历史"，而是一段为当前 Query 和 Executor 定制的、有预算、有组合关系、有呈现顺序的经验上下文；MemComposer 用真实任务成败来学习怎样构造这段上下文。

参考资料

Yixuan Xie et al. MemComposer: Learning to Assemble Memories for LLM Agents via Reinforcement Learning. arXiv:2610.21091.
Barres et al. τ 2 \tau^2 τ2-bench: Evaluating Conversational Agents in a Dual-Control Environment.
Zhang et al. MemRL: Self-Evolving Agents via Runtime Reinforcement Learning on Episodic Memory.
Zhou et al. Memento: Fine-tuning LLM Agents without Fine-tuning LLMs.
Xu et al. A-MEM: Agentic Memory for LLM Agents.
Chhikara et al. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory.
Packer et al. MemGPT: Towards LLMs as Operating Systems.
Ouyang et al. ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory.
Shao et al. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models.