【论文阅读】Agent 记忆机制（68）：Memp——把历史轨迹沉淀为可检索、可纠错的程序性记忆

文章目录

前言
零、论文基本信息
[一、什么是 Agent 的程序性记忆](#一、什么是 Agent 的程序性记忆)
- [1. 它与事实记忆有什么不同](#1. 它与事实记忆有什么不同)
- [2. 为什么原始轨迹不等于程序性知识](#2. 为什么原始轨迹不等于程序性知识)
- [3. 为什么仅追加记忆不够](#3. 为什么仅追加记忆不够)
二、问题建模
[三、Memp 方法总览](#三、Memp 方法总览)
四、Build：从轨迹中构建"怎样做"
- [1. 统一形式](#1. 统一形式)
- [2. 四种构建策略](#2. 四种构建策略)
- - [No Memory](#No Memory)
  - Trajectory
  - Script
  - Proceduralization
- [3. Build 实验结果](#3. Build 实验结果)
五、Retrieve：找到相关做法，而不只是相似文本
- [1. 基本检索公式](#1. 基本检索公式)
- [2. 三种检索策略](#2. 三种检索策略)
六、Update：记忆库必须会纠错
- [1. 更新的统一形式](#1. 更新的统一形式)
- [2. 三种在线更新策略](#2. 三种在线更新策略)
- - [Vanilla Memory Update](#Vanilla Memory Update)
  - Validation
  - Adjustment
[七、与 ReAct、Expel、AWM 的比较](#七、与 ReAct、Expel、AWM 的比较)
八、强模型记忆能否迁移给弱模型
九、检索数量并非越多越好
十、案例：程序记忆如何减少无效试错
十一、实验设计的证据边界
- [1. 两个 benchmark 覆盖了不同类型的程序](#1. 两个 benchmark 覆盖了不同类型的程序)
- [2. 评价信号依赖 benchmark](#2. 评价信号依赖 benchmark)
- [3. 论文更像系统性探索，而非单一算法验证](#3. 论文更像系统性探索，而非单一算法验证)
[十二、与 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. 依赖显式奖励](#2. 依赖显式奖励)
- [3. "终身记忆"证据仍有限](#3. “终身记忆”证据仍有限)
- [4. 失败纠错可能过拟合](#4. 失败纠错可能过拟合)
- [5. 缺少统计显著性与成本拆解](#5. 缺少统计显著性与成本拆解)
- [6. 硬约束指标出现退化](#6. 硬约束指标出现退化)
十五、我的理解与启发
- [1. 程序性记忆的基本单元应是"带条件的技能"](#1. 程序性记忆的基本单元应是“带条件的技能”)
- [2. 具体轨迹与抽象脚本对应实例和规则](#2. 具体轨迹与抽象脚本对应实例和规则)
- [3. 更新的核心不是追加，而是建立反证机制](#3. 更新的核心不是追加，而是建立反证机制)
- [4. 记忆迁移可能比模型蒸馏更灵活](#4. 记忆迁移可能比模型蒸馏更灵活)
- [5. 下一步应把检索与验证联动](#5. 下一步应把检索与验证联动)
十六、总结
参考资料

前言

假设一个家务 Agent 第一次接到"把鸡蛋加热后放进垃圾桶"的任务。它可能先翻橱柜，再找冰箱；拿到鸡蛋后，可能尝试烤面包机或炉灶，失败几次才找到微波炉。即使最后完成任务，这条轨迹也混杂了正确步骤、无效探索和环境偶然性。

几天后，Agent 又接到"把加热后的苹果放到桌上"。如果它只保存原始对话，就只能检索一条冗长轨迹；如果什么都不保存，就必须重新试错；如果把经验写进模型参数，每次更新又过于昂贵。人类通常不会这样学习。我们会从具体经历中抽象出"先去可能的容器寻找物体，再拿到加热设备中处理，最后放到目标位置"这种做事方法。

这就是程序性记忆（Procedural Memory）：它保存的不是"鸡蛋在哪里"这样的事实，而是"此类任务应该怎样完成"的技能与流程。

在此前的 Agent Memory 系列中，A-MEM、MAGMA、CoM 等方法更多讨论记忆如何表示、组织和组合；ReMemR1 关注写入阶段如何回访旧记忆；Mem²Evolve 关注记忆如何随长期经验演化；MemPO 则把轨迹内的滚动工作记忆纳入策略优化。Memp 把视角转向另一个层次：跨任务复用的程序性知识，应该怎样构建、检索和持续纠错？

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

把 Agent 的程序性记忆作为一个可编辑的外部知识库，系统化打通 Build、Retrieve、Update 三个生命周期，并用"具体成功轨迹 + 抽象脚本"的双粒度记忆与失败驱动的原位修正，让 Agent 从跨任务经验中持续学会怎样做事。

严格来说，论文不是提出一个通过梯度学习出来的新模型，而是提出一个实验框架并系统比较程序性记忆生命周期中的策略。它最有价值的地方，是把过去常被混称为"经验复用"的过程拆成三个可独立分析的工程问题。

零、论文基本信息

论文名称： Memp: Exploring Agent Procedural Memory
发表平台： Findings of the Association for Computational Linguistics: ACL 2026
代码仓库： https://github.com/zjunlp/MemP
作者： Runnan Fang, Yuan Liang, Xiaobin Wang, Jialong Wu, Shuofei Qiao, Pengjun Xie, Fei Huang, Huajun Chen, Ningyu Zhang

一、什么是 Agent 的程序性记忆

1. 它与事实记忆有什么不同

语义记忆或事实记忆回答"是什么"：某家餐厅在哪座城市、某个物体位于哪个房间、用户偏好什么。

程序性记忆回答"怎么做"：怎样先检索航班再安排住宿、如何处理 ALFWorld 中的清洁任务、某个工具报错后应按什么顺序恢复。

程序性记忆通常具有三种特征：

可复用： 不绑定某个具体实例，而能迁移到相似任务；
可执行： 能直接约束步骤、工具顺序或恢复策略；
可修正： 环境变化或旧流程失败后，应更新而不是永久保留。

2. 为什么原始轨迹不等于程序性知识

一条成功轨迹可能包含大量偶然步骤。把它原样存下，优点是细节完整，缺点是长、噪声多、泛化差。抽象脚本更短，也更容易迁移，但可能丢失环境特有的动作语法和关键约束。

因此，Memp 的第一个核心问题是：记忆应保存 concrete trajectory，还是 abstract script，抑或两者结合？

3. 为什么仅追加记忆不够

如果每次执行后都把新轨迹追加进库，容量会持续增长，失败经验也可能污染检索结果。程序性记忆需要真正的生命周期管理：添加新技能、删除过时内容，并根据失败反馈修补已有流程。

二、问题建模

论文把 Agent 与环境交互建模为马尔可夫决策过程。时刻 t t t，Agent 在状态 s t ∈ S s_t\in S st∈S 下，根据策略 π ( a t ∣ s t ) \pi(a_t\mid s_t) π(at∣st) 选择动作 a t ∈ A a_t\in A at∈A，环境产生新状态与观察。完整轨迹为：

τ = ( s 0 , a 0 , o 1 , s 1 , a 1 , o 2 , ... , s T ) \tau=(s_0,a_0,o_1,s_1,a_1,o_2,\dots,s_T) τ=(s0,a0,o1,s1,a1,o2,...,sT)

环境根据终止状态或整条轨迹给出奖励：

r = R ( e n v , s T , τ ) ∈ $0 , 1$ r=R(env,s_T,\tau)\in $0,1$ r=R(env,sT,τ)∈ $0,1$

这里的奖励主要来自 benchmark：ALFWorld 给出任务成功或失败，TravelPlanner 根据生成计划满足常识与硬约束的程度评分。

加入程序性记忆 m p m^p mp 后，策略从 π ( a t ∣ s t ) \pi(a_t\mid s_t) π(at∣st) 变为：

π m p ( a t ∣ s t ) \pi_{m^p}(a_t\mid s_t) πmp(at∣st)

这个下标表达的不是模型参数被重新训练，而是外部程序性记忆作为额外条件改变动作选择。

三、Memp 方法总览

要理解 Memp，最重要的是看到程序性记忆如何在多次任务之间循环：旧轨迹生成记忆，新任务检索记忆，新轨迹再反过来更新记忆库。

Figure 2：Memp 程序性记忆框架。 框架包含 Build、Retrieve 和 Update：从历史轨迹构建程序知识，为新任务检索相关记忆，再依据新任务的成功或失败添加、删除或修正已有记忆。

三个环节分别回答：

Build： 一条经验应该被写成什么形态？
Retrieve： 新任务到来时，怎样找到真正相关的做法？
Update： 新执行结果与旧经验冲突时，怎样让记忆库变好而非变大？

这三者形成闭环，而不是一次性的离线总结。

四、Build：从轨迹中构建"怎样做"

1. 统一形式

对于任务轨迹 τ t \tau_t τt 及其奖励 r t r_t rt，构建器 B B B 生成一条程序性记忆：

m t p = B ( τ t , r t ) m_t^p=B(\tau_t,r_t) mtp=B(τt,rt)

完成 T T T 个任务后，记忆库为：

M e m = ∑ t = 1 T m t p Mem=\sum_{t=1}^{T}m_t^p Mem=t=1∑Tmtp

这里的求和并非数值相加，而是表示多条程序记忆被累积到仓库中。奖励决定轨迹是否值得作为技能来源。

2. 四种构建策略

No Memory

Agent 每次都以 ReAct 方式从头完成任务。它提供基线，用于判断经验复用是否真的有用。

Trajectory

先从训练集中筛选成功轨迹，推理时检索与当前问题最相似的 top- k k k 完整轨迹，作为示例放入上下文。

它保留了动作格式、环境反馈和错误恢复等细节，对与旧任务高度相似的新任务很有帮助；但长度高，也容易携带实例特有噪声。

Script

让模型分析成功轨迹，并抽象为更高层的流程脚本。脚本不复述每个观察，而是提炼可迁移的操作规律。

例如，完整轨迹可能记录"先去 countertop 1，再去 cabinet 2，最后在 fridge 1 找到鸡蛋"；脚本则写成"先检查物体最可能出现的容器，拿取后前往与处理类型匹配的设备"。后者对布局变化更稳健。

Proceduralization

同时提供检索到的具体轨迹与抽象脚本。具体轨迹负责动作语法和环境细节，脚本负责跨实例泛化。这是论文整体表现最稳定的构建方式。

3. Build 实验结果

下面按论文 Table 1 重制完整核心结果。TravelPlanner 的 #CS、#HC 分别表示 Commonsense 与 Hard Constraint 得分；ALFWorld 的 Dev/Test 为成功率。

Model Granularity # C S ↑ # H C ↑ TP Steps ↓ Dev ↑ Test ↑ AW Steps ↓ GPT-4o No Memory 71.93 12.88 17.84 39.28 42.14 23.76 Script 72.08 5.50 15.79 66.67 56.43 18.52 Trajectory 76.02 8.25 14.64 67.17 74.29 16.49 Proceduralization 79.94 9.76 14.62 87.14 77.86 15.01 Claude-3.5 No Memory 63.49 33.06 18.84 39.20 34.97 24.12 Script 62.08 29.61 19.21 56.13 53.59 19.38 Trajectory 65.76 29.61 17.72 69.28 71.78 15.97 Proceduralization 65.46 30.14 15.29 82.50 74.72 15.79 Qwen2.5-72B No Memory 56.57 7.34 18.32 44.91 41.25 21.38 Script 58.59 7.34 18.53 66.24 61.88 17.13 Trajectory 63.41 12.66 18.12 64.49 69.57 16.40 Proceduralization 63.82 14.19 17.94 85.71 77.19 15.32 \begin{array}{ll|rrr|rrr} \text{Model}&\text{Granularity}&\#CS\uparrow&\#HC\uparrow&\text{TP Steps}\downarrow&\text{Dev}\uparrow&\text{Test}\uparrow&\text{AW Steps}\downarrow\\\hline \text{GPT-4o}&\text{No Memory}&71.93&\mathbf{12.88}&17.84&39.28&42.14&23.76\\ &\text{Script}&72.08&5.50&15.79&66.67&56.43&18.52\\ &\text{Trajectory}&76.02&8.25&14.64&67.17&74.29&16.49\\ &\text{Proceduralization}&\mathbf{79.94}&9.76&\mathbf{14.62}&\mathbf{87.14}&\mathbf{77.86}&\mathbf{15.01}\\\hline \text{Claude-3.5}&\text{No Memory}&63.49&\mathbf{33.06}&18.84&39.20&34.97&24.12\\ &\text{Script}&62.08&29.61&19.21&56.13&53.59&19.38\\ &\text{Trajectory}&\mathbf{65.76}&29.61&17.72&69.28&71.78&15.97\\ &\text{Proceduralization}&65.46&30.14&\mathbf{15.29}&\mathbf{82.50}&\mathbf{74.72}&\mathbf{15.79}\\\hline \text{Qwen2.5-72B}&\text{No Memory}&56.57&7.34&18.32&44.91&41.25&21.38\\ &\text{Script}&58.59&7.34&18.53&66.24&61.88&17.13\\ &\text{Trajectory}&63.41&12.66&18.12&64.49&69.57&16.40\\ &\text{Proceduralization}&\mathbf{63.82}&\mathbf{14.19}&\mathbf{17.94}&\mathbf{85.71}&\mathbf{77.19}&\mathbf{15.32} \end{array} ModelGPT-4oClaude-3.5Qwen2.5-72BGranularityNo MemoryScriptTrajectoryProceduralizationNo MemoryScriptTrajectoryProceduralizationNo MemoryScriptTrajectoryProceduralization#CS↑71.9372.0876.0279.9463.4962.0865.7665.4656.5758.5963.4163.82#HC↑12.885.508.259.7633.0629.6129.6130.147.347.3412.6614.19TP Steps↓17.8415.7914.6414.6218.8419.2117.7215.2918.3218.5318.1217.94Dev↑39.2866.6767.1787.1439.2056.1369.2882.5044.9166.2464.4985.71Test↑42.1456.4374.2977.8634.9753.5971.7874.7241.2561.8869.5777.19AW Steps↓23.7618.5216.4915.0124.1219.3815.9715.7921.3817.1316.4015.32

Table 1：程序性记忆构建策略结果。 比较无记忆、抽象脚本、完整轨迹以及两者结合在 TravelPlanner 与 ALFWorld 上的质量和步骤数。

最稳定的结论是 Proceduralization 在 ALFWorld 上对三个模型都取得最高 Dev/Test 成功率和最少步骤。GPT-4o Test 从 42.14 提升到 77.86，步骤从 23.76 降到 15.01；Qwen2.5-72B Test 从 41.25 提升到 77.19。

但 TravelPlanner 展示了重要反例：记忆不保证所有指标都提升。GPT-4o 的 #HC 最优值是无记忆的 12.88，Proceduralization 只有 9.76；Claude 的 #HC 也从 33.06 降至 30.14。程序性经验可能提高总体规划常识与效率，却把旧任务中的约束模式错误迁移到新任务。

Script 与 Trajectory 的差异也符合预期：论文指出 Script 在 ALFWorld Test 相对更有泛化力，而完整轨迹在更接近旧任务的 Dev 上更有优势。二者结合能同时提供抽象规则和落地示例。

五、Retrieve：找到相关做法，而不只是相似文本

1. 基本检索公式

面对新任务 t n e w t_{new} tnew，从记忆库选择最相似的旧任务对应记忆：

m r e t r i e v e d = arg ⁡ max ⁡ m i p ∈ M e m S ( t n e w , t i ) m_{retrieved}=\arg\max_{m_i^p\in Mem}S(t_{new},t_i) mretrieved=argmip∈MemmaxS(tnew,ti)

实验使用向量编码器 ϕ \phi ϕ 与余弦相似度：

m r e t r i e v e d = arg ⁡ max ⁡ m i p ∈ M e m ϕ ( t n e w ) ⋅ ϕ ( t i ) ∥ ϕ ( t n e w ) ∥ ∥ ϕ ( t i ) ∥ m_{retrieved}=\arg\max_{m_i^p\in Mem} \frac{\phi(t_{new})\cdot\phi(t_i)} {\|\phi(t_{new})\|\|\phi(t_i)\|} mretrieved=argmip∈Memmax∥ϕ(tnew)∥∥ϕ(ti)∥ϕ(tnew)⋅ϕ(ti)

公式的关键不是余弦相似度本身，而是"用什么文本作为 key"。同一段程序记忆可以用完整 query 做索引，也可以用模型抽取出的任务要素做索引，二者会召回不同经验。

2. 三种检索策略

Random Sample： 不使用向量键，随机抽取记忆；
Key=Query： 直接用任务描述编码；
Key=AveFact： 先抽取 query 中的关键事实或任务要素，再对匹配关键词相似度取平均。

AveFact 试图减少表面叙述差异的影响。例如"两天内从 A 到 B、预算 X、不能坐飞机"与另一个措辞不同但约束结构相似的任务，关键事实比整句 embedding 更可能对齐。

Model Policy # C S ↑ # H C ↑ Steps ↓ GPT-4o No Memory 71.93 12.88 17.84 Random 74.59 6.72 15.12 Key=Query 73.38 8.95 15.44 Key=AveFact 76.02 8.25 14.64 Claude-3.5 No Memory 63.49 33.06 18.84 Random 63.99 29.91 17.93 Key=Query 64.93 28.56 17.60 Key=AveFact 65.76 29.61 17.72 Qwen2.5-72B No Memory 56.57 7.34 18.32 Random 59.76 8.43 18.31 Key=Query 61.71 11.97 18.54 Key=AveFact 63.41 12.66 18.12 \begin{array}{ll|rrr} \text{Model}&\text{Policy}&\#CS\uparrow&\#HC\uparrow&\text{Steps}\downarrow\\\hline \text{GPT-4o}&\text{No Memory}&71.93&\mathbf{12.88}&17.84\\ &\text{Random}&74.59&6.72&15.12\\ &\text{Key=Query}&73.38&8.95&15.44\\ &\text{Key=AveFact}&\mathbf{76.02}&8.25&\mathbf{14.64}\\\hline \text{Claude-3.5}&\text{No Memory}&63.49&\mathbf{33.06}&18.84\\ &\text{Random}&63.99&29.91&17.93\\ &\text{Key=Query}&64.93&28.56&\mathbf{17.60}\\ &\text{Key=AveFact}&\mathbf{65.76}&29.61&17.72\\\hline \text{Qwen2.5-72B}&\text{No Memory}&56.57&7.34&18.32\\ &\text{Random}&59.76&8.43&18.31\\ &\text{Key=Query}&61.71&11.97&18.54\\ &\text{Key=AveFact}&\mathbf{63.41}&\mathbf{12.66}&\mathbf{18.12} \end{array} ModelGPT-4oClaude-3.5Qwen2.5-72BPolicyNo MemoryRandomKey=QueryKey=AveFactNo MemoryRandomKey=QueryKey=AveFactNo MemoryRandomKey=QueryKey=AveFact#CS↑71.9374.5973.3876.0263.4963.9964.9365.7656.5759.7661.7163.41#HC↑12.886.728.958.2533.0629.9128.5629.617.348.4311.9712.66Steps↓17.8415.1215.4414.6418.8417.9317.6017.7218.3218.3118.5418.12

Table 2：TravelPlanner 检索策略结果。 比较随机取样、完整查询向量和关键事实平均相似度三种检索方式。

AveFact 在三个模型上都取得最高 #CS，且在 Qwen 上同时取得最高 #HC。这支持"任务结构化要素比整句语义更适合程序检索"。不过它并非所有列都最好：Claude 的最少步骤来自 Key=Query，GPT-4o 与 Claude 的最高 #HC 仍来自无记忆。

因此，论文能够证明 AveFact 是较强的实验策略，但不能证明它是普适最优检索器。其关键事实仍由大模型抽取，抽取错误会直接改变索引。

六、Update：记忆库必须会纠错

1. 更新的统一形式

令 M ( t ) M(t) M(t) 为时刻 t t t 的程序性记忆， E ( t ) E(t) E(t) 为执行反馈， τ t \tau_t τt 为此前任务轨迹集合：

M ( t + 1 ) = U ( M ( t ) , E ( t ) , τ t ) M(t+1)=U(M(t),E(t),\tau_t) M(t+1)=U(M(t),E(t),τt)

论文进一步把更新写成三种操作的组合：

U = A d d ( M n e w ) ⊖ D e l ( M o b s ) ⊕ U p d a t e ( M e s t ) U=Add(M_{new})\ominus Del(M_{obs})\oplus Update(M_{est}) U=Add(Mnew)⊖Del(Mobs)⊕Update(Mest)

M n e w M_{new} Mnew 是新增经验， M o b s M_{obs} Mobs 是应删除的过时记忆， M e s t M_{est} Mest 是需要基于反馈改写的已有记忆。这个公式是概念性描述，不代表论文训练了一个可微更新算子。

2. 三种在线更新策略

Vanilla Memory Update

每完成一组任务，就把所有新轨迹整合成程序记忆并直接追加。优点是简单，缺点是失败与噪声也可能进入库中。

Validation

只保留成功轨迹，将其抽象成紧凑程序记忆；失败轨迹和冗余内容被丢弃。它提高数据质量，却浪费了失败提供的"旧流程哪里不适用"信息。

Adjustment

当检索出的程序记忆导致任务失败时，把失败轨迹与原记忆放在一起进行反思，原位修正这条记忆。它不只是新增经验，而是对错误技能打补丁。

下面这张图用于观察记忆库随着任务组推进是否真的持续改善。

Figure 3：程序性记忆在线更新结果。 横轴为依次处理的轨迹组，左图表示相对无记忆的奖励增益，右图表示步骤减少量，比较 Vanilla、Validation 与 Adjustment。

三种策略总体都随任务推进带来更高奖励和更少步骤，但 Adjustment 最强。最终任务组中，其奖励增益约为 0.7，并减少约 14 步，优于单纯追加或只保留成功轨迹。

这里最值得注意的不是"反思"这个词，而是更新对象发生了变化：失败不再只产生一条新的负面经验，而是用于定位并改写曾经被检索、却导致失败的旧程序。程序记忆由此从日志集合变成可维护的技能库。

论文没有给曲线误差条或多随机种子统计，因此"持续近线性增长"更适合作为观察趋势，而非严格的学习曲线定律。

七、与 ReAct、Expel、AWM 的比较

Figure 4：ALFWorld 基线比较。 使用 GPT-4o 比较 ReAct、Expel、AWM 与 Memp 的 Dev/Test 成功率及平均步骤数。

图中 ReAct 成功率最低、步骤最多；Expel 与 AWM 依次改善；Memp 达到最高 Dev/Test 成功率和最少步骤。结合 Table 1 可知，Memp 的 GPT-4o 配置在 ALFWorld 上达到 Dev 87.14、Test 77.86、Steps 15.01。

不过比较公平性需要谨慎。不同方法的记忆形态、检索方式和实现细节并不完全相同，论文图中也未给显著性检验。结果支持 Memp 整体框架的竞争力，但不能把差值全部归因于某个单一模块。

八、强模型记忆能否迁移给弱模型

如果程序性记忆真的描述"怎么做"，它就不应只对生成它的模型有效。论文将 GPT-4o 构建的程序记忆交给 Qwen2.5-14B-Instruct 使用。

Figure 5：程序记忆的跨模型迁移与检索规模。 上图比较 Qwen2.5-14B 使用 GPT-4o 记忆前后的 TravelPlanner 表现；下图展示 ALFWorld 分数随检索记忆数量变化的趋势。

在 TravelPlanner 上，GPT-4o 记忆使 Qwen2.5-14B 的 Delivery 从 91.4 提升到 96.6，Commonsense 从 59.3 提升到 65.5，同时步骤从 16.9 降到 15.3。论文文字概括为完成率提高约 5%、平均步骤减少 1.6。

这说明程序性知识至少部分独立于模型参数：强模型可以充当经验教师，把流程写入外部库，再由更弱模型低成本复用。它与蒸馏相似，但迁移载体是可读、可编辑、可即时替换的文本记忆，而非权重。

九、检索数量并非越多越好

Figure 5(b) 中，GPT-4o 在 ALFWorld 的得分随检索记忆数量从 0 增加到 15 总体上升：0 条时约 40.7，10 条时约 78.2，15 条时达到约 82.5。继续增加到 20 条后下降到约 79.3。

这揭示了典型的 Memory trade-off：

记忆太少时，相关流程可能没有被召回；
记忆增多时，覆盖率提高；
记忆过多时，上下文变长，低相关或错误程序互相干扰。

因此，扩容记忆库与扩大 top- k k k 不是同一件事。库可以很大，但每次执行仍需要精确、受预算约束的检索。

十、案例：程序记忆如何减少无效试错

Figure 6：有无程序性记忆的轨迹对比。 在"加热鸡蛋并放入垃圾桶"任务中，无记忆轨迹会探索错误位置或设备；使用记忆后以 14 步完成，较成功的无记忆轨迹减少 9 步并节省 685 tokens。

第一条无记忆轨迹依次探索 countertop、cabinet、fridge，拿到鸡蛋后错误尝试 toaster 和 stoveburner，最终 27 步、3635 tokens 仍失败。

第二条无记忆轨迹在 toaster 失败后找到了 microwave，最终用 23 步、3274 tokens 成功。

使用程序记忆后，Agent 获得一个抽象流程：先去冰箱或其他高概率位置拿鸡蛋，放入微波炉加热，最后移到目标位置。它用 14 步、2589 tokens 完成任务。

案例说明程序记忆的作用不是替代环境观察，而是减少"重新发现工具可用性与流程顺序"的成本。不过记忆中"先去冰箱"仍带有环境先验；若新环境把鸡蛋放在柜子里，Agent 必须允许观察覆盖旧经验。

十一、实验设计的证据边界

1. 两个 benchmark 覆盖了不同类型的程序

TravelPlanner 测试带复杂约束的信息检索与规划，ALFWorld 测试文本化具身环境中的动作序列。两者共同支持程序记忆对长程工具任务有用，但距离网页 GUI、代码工程和真实组织流程仍有差距。

2. 评价信号依赖 benchmark

ALFWorld 由环境直接返回 0/1 成功奖励。TravelPlanner 则先让 GPT-4o 把计划转换为指定 JSON，再与 gold standard 比较 Commonsense 和 Hard Constraint。这意味着 TravelPlanner 指标还依赖格式转换步骤。

3. 论文更像系统性探索，而非单一算法验证

Build、Retrieve、Update 采用多种提示、抽取和检索策略。论文最强配置由多个选择共同组成，因此不能仅凭最终结果判断某一策略在其他环境中必然最优。

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

方法主要记忆类型核心环节与 Memp 的区别 A-MEM 语义/情节记忆动态链接与组织偏"记住什么"，Memp 偏"怎样做" MAGMA 多粒度记忆多层表示与协同强调粒度，Memp 强调技能生命周期 CoM 可组合记忆单元组合与上下文构造操作记忆内容，不专门蒸馏流程 ReMemR1 可回访历史记忆写入时回调与更新防止不可逆遗忘，Memp 修正程序技能 Mem 2 Evolve 长期演化记忆持续更新与适应范围更广；Memp 聚焦程序知识 MemPO 轨迹内滚动工作记忆记忆级 RL 信用分配单任务内压缩；Memp 跨任务复用 Memp 外部程序性记忆 Build/Retrieve/Update 把经验变成可检索、可纠错的技能 \begin{array}{l|l|l|l} \text{方法}&\text{主要记忆类型}&\text{核心环节}&\text{与 Memp 的区别}\\\hline \text{A-MEM}&\text{语义/情节记忆}&\text{动态链接与组织}&\text{偏"记住什么"，Memp 偏"怎样做"}\\ \text{MAGMA}&\text{多粒度记忆}&\text{多层表示与协同}&\text{强调粒度，Memp 强调技能生命周期}\\ \text{CoM}&\text{可组合记忆单元}&\text{组合与上下文构造}&\text{操作记忆内容，不专门蒸馏流程}\\ \text{ReMemR1}&\text{可回访历史记忆}&\text{写入时回调与更新}&\text{防止不可逆遗忘，Memp 修正程序技能}\\ \text{Mem}^{2}\text{Evolve}&\text{长期演化记忆}&\text{持续更新与适应}&\text{范围更广；Memp 聚焦程序知识}\\ \text{MemPO}&\text{轨迹内滚动工作记忆}&\text{记忆级 RL 信用分配}&\text{单任务内压缩；Memp 跨任务复用}\\ \text{Memp}&\text{外部程序性记忆}&\text{Build/Retrieve/Update}&\text{把经验变成可检索、可纠错的技能} \end{array} 方法A-MEMMAGMACoMReMemR1Mem2EvolveMemPOMemp主要记忆类型语义/情节记忆多粒度记忆可组合记忆单元可回访历史记忆长期演化记忆轨迹内滚动工作记忆外部程序性记忆核心环节动态链接与组织多层表示与协同组合与上下文构造写入时回调与更新持续更新与适应记忆级 RL 信用分配Build/Retrieve/Update与 Memp 的区别偏"记住什么"，Memp 偏"怎样做"强调粒度，Memp 强调技能生命周期操作记忆内容，不专门蒸馏流程防止不可逆遗忘，Memp 修正程序技能范围更广；Memp 聚焦程序知识单任务内压缩；Memp 跨任务复用把经验变成可检索、可纠错的技能

横向比较：Memp 在 Agent Memory 演进中的位置。 Memp 关注跨任务的程序知识生命周期，与单轨迹工作记忆、事实记忆和长期用户记忆形成互补。

Memp 与 MemPO 名称接近，但解决的问题不同。MemPO 训练模型在同一条长轨迹中维护累计摘要；Memp 把已经完成的多条轨迹蒸馏为跨任务可复用的外部技能。前者解决上下文增长与步骤信用，后者解决重复试错与技能积累。

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

以下内容是基于论文机制的工程推演，并非论文直接验证。

1. Coding Agent：沉淀"修复剧本"，而不是复制旧补丁

对于代码任务，Trajectory 可以保存完整的文件查看、修改和测试过程；Script 则抽象为"先复现错误---定位最小责任模块---增加回归测试---修改实现---运行相关测试"。两者结合比直接复用旧 diff 更稳健，因为具体代码会变，调试程序往往可以迁移。

失败更新尤其重要。如果旧剧本导致错误修改，应把失败日志与旧剧本一起反思，补充适用条件，例如"仅当数据库迁移已执行时使用该修复"。

2. Tool Agent：程序记忆应包含前置条件和恢复分支

现实工具流程不是线性步骤列表。一条高质量程序记忆至少应包含：适用条件、动作顺序、成功检查、常见错误和回退动作。否则脚本在环境变化时会变成脆弱模板。

3. Multi-Agent：强模型可以构建、弱模型可以执行

跨模型迁移结果提示了一种成本结构：用较强模型离线整理高质量程序库，再让较便宜模型在线检索执行。多智能体系统还可以让审查 Agent 专门验证或修补记忆，把 Build、Execute、Update 分给不同角色。

4. 生产系统需要版本化与回滚

Memp 的原位修正提高适应性，却可能把只对单个异常有效的补丁写进通用技能。工程实现应记录来源轨迹、适用环境、修改原因、成功率和版本，并支持灰度验证与回滚。

十四、局限性

1. 检索策略仍较单一

论文只使用向量相似度与人工设计的 Query/AveFact 键，没有纳入 BM25、混合检索、学习式 reranker 或结构化约束匹配。作者也把这一点列为首要局限。

2. 依赖显式奖励

Update 需要知道任务是否成功，但真实世界常没有可靠的 0/1 环境反馈。作者提出未来可用 LLM-as-a-Judge，自评又会引入偏差、奖励欺骗和成本问题。

3. "终身记忆"证据仍有限

实验按五个任务组观察更新趋势，但这与数月运行、数万条技能、环境持续变化的 lifelong setting 还有明显距离。论文没有系统测量灾难性遗忘、库容量增长和长期检索延迟。

4. 失败纠错可能过拟合

Adjustment 根据一次失败轨迹改写原记忆。如果失败来自随机网络问题、观察缺失或执行器故障，而不是程序本身错误，直接修改技能可能造成错误归因。

5. 缺少统计显著性与成本拆解

主要结果没有报告误差条或多次运行方差，也没有完整拆分构建脚本、抽取 AveFact、反思更新所消耗的额外 LLM tokens。执行步数下降不等于整个系统总成本必然下降。

6. 硬约束指标出现退化

TravelPlanner 中多个强模型加入程序记忆后 #HC 低于 No Memory。这说明迁移旧流程可能强化常见模式，却忽视新任务的独特硬约束。论文没有深入分析这些失败样本。

十五、我的理解与启发

1. 程序性记忆的基本单元应是"带条件的技能"

只保存"先 A 再 B"还不够。真正可复用的程序应该写成：在什么环境、满足什么前置条件时执行 A；观察到什么结果后执行 B；失败时怎样回退。否则抽象脚本越通用，越可能在边界场景中误用。

2. 具体轨迹与抽象脚本对应实例和规则

Trajectory 类似 case-based reasoning，Script 类似 rule-based reasoning。Memp 的结果表明二者不是替代关系：案例告诉模型动作如何落地，规则帮助模型跨实例迁移。Proceduralization 的优势来自这两种归纳偏置互补。

3. 更新的核心不是追加，而是建立反证机制

很多 Agent Memory 系统把"记忆增长"当成"学习"。Memp 的 Adjustment 提醒我们：真正的学习还包括旧技能被新证据否定后如何定位、修正和降权。记忆库如果只会增加，最终很可能成为相互矛盾的经验堆。

4. 记忆迁移可能比模型蒸馏更灵活

把 GPT-4o 的程序记忆交给 Qwen2.5-14B，无需重新训练权重即可获益。对于频繁变化的工具和业务流程，这比参数蒸馏更快、更透明，也更容易撤回；代价是每次推理需要检索和注入文本。

5. 下一步应把检索与验证联动

Figure 5 表明 top- k k k 过大会退化。一个更稳健的系统不应固定取若干条，而应判断：记忆是否覆盖当前任务结构、是否相互冲突、是否已过期、加入后是否提高执行置信度。也就是说，未来重点不是"存更多"，而是"检索后验证再使用"。

十六、总结

Memp 将程序性记忆从静态 prompt 或零散成功轨迹提升为一个具备完整生命周期的外部技能库。Build 阶段同时保留具体轨迹与抽象脚本；Retrieve 阶段比较随机、完整查询和关键事实索引；Update 阶段则进一步区分无条件追加、成功过滤与失败驱动的原位修正。

实验表明，程序性记忆在 ALFWorld 上能够同时提高成功率、减少步骤，并可从 GPT-4o 迁移给 Qwen2.5-14B。随着经验积累，Adjustment 更新表现最好；但 TravelPlanner 的硬约束退化、检索过多后的性能下降，也说明错误或不匹配的"做法"会反过来干扰 Agent。

一句话总结：

Memp 的核心贡献，是让 Agent 不只保存过去发生过什么，而是把轨迹提炼成可检索、可迁移、会因失败而修正的做事方法。

参考资料

Fang et al. Memp: Exploring Agent Procedural Memory. Findings of ACL 2026.
论文主页：https://aclanthology.org/2026.findings-acl.866/
代码仓库：https://github.com/zjunlp/MemP
Shridhar et al. ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. 2021.
Xie et al. TravelPlanner: A Benchmark for Real-World Planning with Language Agents. 2024.