How Memory Management Impacts LLM Agents: An Empirical Study of Experience-Following Behavior

Paper: arXiv:2505.16067 Code: yuplin2333/agent_memory_manage Code reference: main @ 4dc29e36 (2025-05-21)

1. Motivation (研究动机)

LLM agent 的长期能力越来越依赖“可演化的经验记忆”：agent 在执行任务后，把过去的输入 query 与输出 execution 作为 experience 存入 memory bank，之后遇到相似任务时再检索出来作为 demonstrations。这个设计看似只是 RAG / in-context learning 的一个工程模块，但本文强调的关键区别是：agent memory 不是静态外部知识库，而是一个会被 agent 自己的输出持续污染、扩张和裁剪的动态池。因此，memory 管理策略本身会改变未来输入时 agent 看到的上下文分布，也会改变它模仿、推理或复用历史 execution 的倾向。

现有 agent 论文通常把 memory addition / deletion 当作 task-specific trick：有的所有 trajectory 都存，有的用 LLM judge 过滤，有的按检索频率忘记，有的用环境反馈做反思。但这些方法大多只报告某个任务上的收益，缺少跨 agent、跨输入输出形态的行为分析。本文要回答的问题更底层：当 memory bank 随着连续 addition 和 deletion 演化时，LLM agent 的长期执行行为究竟怎样变化？哪些现象是 memory agent 的共性，而不是某个任务或某个 prompt 的偶然结果？

本文把研究重点放在两类最基础的 memory operation：addition 决定新的 query-execution pair 是否进入 memory；deletion 决定旧 experience 何时从 memory 中移除。作者发现，memory 管理不是“记得越多越好”。如果把低质量 execution 加入 memory，后续相似任务会把这些错误当作示例继续模仿，导致性能下降；如果 deletion 只按频率清理，也可能删掉低频但有价值的经验，或留下频繁检索但有害的经验。真正影响长期表现的是 memory 中经验的质量、相关性、未来效用和容量约束之间的平衡。

这篇论文的价值在于它把 memory 模块从“辅助检索组件”提升为“会塑造 agent 行为动力学的系统组件”。对实际部署来说，这意味着 memory bank 不能只看 embedding 相似度和存储规模，还要追踪被检索经验对后续执行的真实影响；对研究来说，它提供了一个可测量的行为属性——experience-following——把“为什么某些 memory 策略会自我强化或自我退化”讲清楚。

2. Idea (核心思想)

核心洞察是：带 memory 的 LLM agent 存在一种 experience-following property：当前任务输入与被检索 memory record 的输入越相似，agent 当前输出与该 record 中历史输出也越相似。这个性质本身是双刃剑。若 memory record 是高质量成功 execution，它会让 agent 复用正确经验，形成 self-improvement；若 record 含有错误或与当前上下文不对齐，它会让 agent 复制错误，形成 error propagation 或 misaligned experience replay。

本文的关键创新不是提出一个复杂新算法，而是用四类 agent 的受控实验系统地证明：memory addition 与 deletion 的设计应围绕“经验质量”和“未来效用”展开。addition 需要可靠 evaluator，避免把噪声 trajectory 写入 memory；deletion 不能只按年龄或检索频率，而应利用未来任务反馈，把“被检索后经常导致低效用输出”的 record 删除。这个想法把环境反馈、trajectory evaluator、retrieval history 结合起来，使 memory bank 从被动缓存变成可维护的数据结构。

与常见的 add-all memory 或固定 memory baseline 相比，本文的根本差异在于：它不把 memory size 当作唯一优化目标，也不假设历史 experience 天然有益。作者显示，固定 memory 有时比粗糙自动 evaluator 更强，因为冻结的少量高质量 memory 至少不会持续引入坏样本；严格或足够强的 evaluator 则可以让 memory 规模增长同时保持质量，从而超过固定 memory。也就是说，memory 管理的关键不是“增加记忆”，而是“控制 agent 学到什么样的执行轨迹”。

3. Method (方法)

3.1 统一 memory workflow

Figure 1 解读：这张图概括了本文研究的 agent memory 生命周期。每次任务执行后，agent 会得到当前 query 与 execution，然后 addition policy 判断是否把它存为新 memory record；之后 retrieval 模块在后续 query 到来时从 memory bank 取出相似 record 作为 demonstrations；deletion policy 再根据检索历史、频率或未来效用删除部分记录。图中的重点不是某个特定 agent 架构，而是 memory bank 处在一个闭环中：过去输出影响未来上下文，未来执行结果又反过来更新或清理过去输出。

形式化地，一个 memory record 可以写成 ((q_i, e_i))，其中 (q_i) 是 agent 输入，(e_i) 是 agent 输出或执行轨迹。给定当前 query，retrieval 返回一个或多个相似 record；LLM 在这些 record 的条件下生成当前 execution。memory addition 用 evaluator (\pi(q,e)) 决定是否存储新 execution：若 (\pi(q,e)=1)，写入 memory；若 (\pi(q,e)=0)，丢弃。memory deletion 用 criterion (\phi(q_i,e_i)) 决定旧 record 是否移除。

3.2 Memory addition：从 add-all 到 evaluator-gated selective addition

作者比较四类 addition 策略。第一类是 fixed-memory baseline：初始 memory 来自训练数据中正确执行的子集，后续不添加新记录，即 (\pi_{\mathrm{fixed}}(q,e)=0)。第二类是 add-all：每个 encountered task 和 execution 都存入 memory，即 (\pi_{\mathrm{all}}(q,e)=1)。第三类是 coarse automatic evaluation：用自动 evaluator 判断 execution 是否值得存储，即 (\pi_{\mathrm{automatic}}(q,e)=\mathrm{Automatic}(q,e))。第四类是 strict human/oracle evaluation：用 ground truth 模拟严格人工判断，即 (\pi_{\mathrm{human}}(q,e)=\mathrm{Human}(q,e))。

coarse evaluator 被设计成三档能力。RegAgent 中 C1/C2/C3 分别使用绝对误差阈值 1.6、1.4、1.2，阈值越小 evaluator 越严格。其他三个真实 agent 中，C1 是 GPT-4o-mini judge，C2 是 GPT-4.1-mini judge，C3 是用 300 条正确 judging data fine-tune 的 GPT-4.1-mini evaluator。这个设计使作者能区分两个因素：memory 规模变大是否有益，以及 evaluator 质量是否足以阻止错误经验进入 memory。

Figure 2 解读：该组合图对应 EHRAgent 与 AgentDriver 在不同 addition 策略下的长期性能曲线。曲线说明 add-all 和部分 coarse addition 会因为错误记录累积而停滞或下降；fixed memory 虽然不会自我提升，但由于不继续引入噪声，表现相对稳定；strict evaluator 与更强的 coarse evaluator 则能随着时间持续筛选高质量 experience，使 memory bank 变得更有用。这里的关键不是单步 accuracy，而是长期曲线是否随着 memory 演化改善。

3.3 Experience-following property：相似输入诱导相似输出

本文定义的 experience-following property 是：若当前 query 与被检索 memory record 的 query 在输入空间中高度相似，那么 agent 当前 execution 与该 record 的 execution 也会高度相似。作者用 input similarity 和 output similarity 的关系来验证这一点。RegAgent 中 input similarity 是输入向量的 cosine similarity，output similarity 使用 RBF kernel；AgentDriver 中 input similarity 遵循原 AgentDriver 的向量距离方法，output similarity 是预测轨迹和参考轨迹之间的 RBF kernel。对于轨迹输出，论文使用类似

[ \text{output_similarity}=\exp(-\gamma\lVert \mathbf{v}_1-\mathbf{v}_2\rVert^2),\quad \gamma=1.0. ]

Figure 3 解读：左图是 RegAgent，右图是 AgentDriver，展示不同 evaluator 下 input similarity 与 output similarity 的累计关系。RegAgent 在 memory 增大、检索样本更贴近当前 query 时，input-output similarity 接近线性同步，论文报告 Pearson (r\approx 1)，说明模型更像是在强烈跟随最近的 demonstration，而不是纯粹重新推理。fixed-memory 条件下 similarity 较低，反而可能保留更多内部推理成分，所以在 coarse noisy memory 下固定 memory 有时更稳。

这个性质解释了为什么 selective addition 能形成 self-improvement：当 evaluator 只允许正确 execution 进入 memory，未来相似 query 会检索到正确 demonstration，agent 生成相似输出，于是正确经验被复制。相反，add-all 或弱 evaluator 会把错误 execution 也放入 memory；由于 experience-following，未来相似 query 会复制这些错误，错误又可能被继续写回 memory，形成自我退化。

3.4 Error propagation：错误 trajectory 被 experience-following 放大

error propagation 是 experience-following 的第一个负面后果。若 memory record 的 execution 本身有噪声或错误，agent 在相似 query 上会复制该 execution 的结构；如果当前 execution 也被 addition policy 接受，错误会进一步传播。作者用 error-free variant 检验这一点：保持 retrieval 与任务顺序不变，但把加入 memory 的 agent output 替换为 ground-truth output。若性能显著上升，就说明原来的性能损失来自 agent output 作为 demonstration 时携带的错误，而不是任务本身不可解。

Figure 4 解读：该图比较“使用 agent 自己输出作为 demonstrations”和“error-free 使用 ground truth 作为 demonstrations”的长期性能。coarse 使用 C1 evaluator。结果表明，哪怕检索机制和任务流程不变，memory 中 execution 的真实质量会明显改变后续性能；ground-truth demonstration 能切断错误传播，而 agent-generated demonstration 会让 early mistake 进入 memory 后被后续相似任务反复模仿。

3.5 Memory deletion：用频率、历史效用或二者组合清理 memory

memory deletion 的目标是防止 memory 无限增长，并删除冗余或有害记录。论文比较三类 deletion。

Periodical-based deletion 用固定周期内的检索频率近似 record 的有用性。令 (\operatorname{fr}{t}(q_i,e_i)) 是 record 到时间 (t) 的累计检索次数，(\operatorname{fr}{t’}(q_i,e_i)) 是前一时间点的检索次数，(\alpha) 是周期内目标检索次数。若

[ \phi_{\text{per}}(q_i,e_i,t,t’)=\mathbf{1}\left[\operatorname{fr}{t}(q_i,e_i)-\operatorname{fr}{t’}(q_i,e_i)\le \alpha\right]=1, ]

则删除该 record。该方法能把 memory size 约束到 (M\le \alpha(t-t’)K)，其中 (K) 是每次执行检索的 memory 数量，但它只看“是否被检索”，不看“被检索后是否帮助执行”。

History-based deletion 使用未来执行效用。设 (\Phi) 是 utility evaluator，可以与 selective addition 的 evaluator 相同。若一个 record 被检索超过 (n) 次，且所有历史检索对应任务的平均 utility 不超过阈值 (\beta)，则删除：

[ \phi_{\text{hist}}(q_i,e_i,t)= \begin{cases} \delta(q_i,e_i,t), & \text{if } \operatorname{fr}_{t}(q_i,e_i)>n,\ 0, & \text{otherwise}, \end{cases} ]

[ \delta(q_i,e_i,t)=\mathbf{1}\left[\frac{1}{\operatorname{fr}{t}(q_i,e_i)}\sum{m=1}^{\operatorname{fr}_{t}(q_i,e_i)}\Phi(q_m,e_m)\le \beta\right]. ]

这里的设计非常实用：未来任务在检索某条 experience 后的表现，天然就是这条 experience 是否有用的免费标签。要求至少检索 (n) 次，是为了降低平均 utility 的估计偏差。

Combined deletion 用逻辑或组合两者：

[ \phi_{\text{comb}}(q_i,e_i,t,t’)=\phi_{\text{per}}(q_i,e_i,t,t’)\lor\phi_{\text{hist}}(q_i,e_i,t). ]

它同时利用频率控制 memory size，并利用历史效用删除有害 record。

Figure 5 解读：该图比较不同 evaluator 下 history-based deletion 的影响。结果说明 deletion 本身不是无条件有益：当 evaluator 可靠时，history-based deletion 能删除未来效用低的 record，提升性能；当 evaluator 粗糙或不稳定时，它可能把错误的 utility 信号用于删除，导致不同 agent 上的效果分化。C3 fine-tuned evaluator 通常更稳定，说明 deletion 的质量同样受 evaluator 质量约束。

3.6 Misaligned experience replay：看似正确但未来有害的经验

misaligned experience replay 是 experience-following 的第二个挑战。某些 record 当初通过了 evaluator 的质量过滤，但它们与后续任务分布或当前 execution context 不对齐；被检索出来后，agent 仍会强烈跟随这些 demonstration，反而降低执行质量。它和 error propagation 的区别是：error propagation 强调 record 本身有错误；misaligned replay 强调 record 对当前 task 的指导价值低，即使它当初可能是“正确”的。

Figure 6 解读：左图是 C1 evaluator 下 history-based deletion 删除与保留 record 的绝对误差 KDE，右图是 strict evaluator 下的对应曲线。被保留 demonstrations 的 error 更低，被删除 demonstrations 的 error 更高，说明 history-based deletion 确实在识别未来效用较差的 records。即使 strict addition 只允许 error (\le 1) 的样本进入 memory，error (>0.5) 的相对嘈杂记录仍更容易导致后续预测退化，从而被删除。

3.7 Released code 与论文方法的对应

Code reference: main @ 4dc29e36 (2025-05-21) — pseudocode and mapping based on this commit

released GitHub 仓库明确说明只包含 AgentDriver 相关实验代码，需要把原始 AgentDriver 仓库中的 agentdriver、assets、data、experiments、scripts 和 requirements.txt 移入本项目，再用 agentdriver_patch / scripts_patch / data_patch 覆盖。也就是说，代码能锚定 AgentDriver 的 strict/coarse/no-error-propagation 实现，但 RegAgent、EHRAgents、CIC-IoT 的完整实验代码没有在该仓库中给出。

论文公式与 released code 实现差异：论文覆盖四个 agent 的 addition / deletion 实验；released repo 只发布 AgentDriver patch。论文中的 history utility (\Phi) 在 AgentDriver strict 代码中具体实现为 UniAD 3-second average L2，coarse 代码中则把 LLM judge 的 yes/no 记录成 0.0/1.0 用于后续 deletion。实验超参不是独立 YAML，而是 Python 脚本常量；例如 main_strict.py 中 N_SAMPLES=2000、SUCCESS_L2_THRESHOLD=2.5、初始 memory assert 为 180，默认 DELETION_L2_THRESHOLD=99999.0 和 DELETION_RETREIVAL_N_TIMES=99999 表示关闭 history deletion，注释中的 5.0/3、500/0 等值对应论文中 deletion variant 的手动改参。

import torch
 
 
def uniad_l2(pred_traj: torch.Tensor, gt_traj: torch.Tensor) -> torch.Tensor:
    """AgentDriver released code uses 6 future points and averages L2 at steps 2, 4, 6."""
    assert pred_traj.shape == gt_traj.shape == (6, 2)
    l2s = torch.sqrt(((pred_traj - gt_traj) ** 2).sum(dim=1))
    return (l2s[1] + l2s[3] + l2s[5]) / 3
 
 
def strict_agentdriver_step(memory, token, perception, reasoning, planner, gt_traj,
                            success_l2_threshold=2.5,
                            deletion_l2_threshold=99999.0,
                            deletion_retrieval_n_times=99999,
                            max_memory_size=99999):
    working_memory = perception.run(token)
    retrieved = memory.run(working_memory)
    reasoning_text = reasoning.run(working_memory, retrieved)
    pred_traj = planner.run(working_memory, retrieved, reasoning_text)
 
    l2_error = uniad_l2(pred_traj, gt_traj)
    memory_token = memory.get_retrieved_memory(token)
    memory.record_l2(memory_token, l2_error, timestep=memory.time_step)
 
    if l2_error < success_l2_threshold:
        new_record = convert_working_memory_to_memory(working_memory, pred_traj)
        memory.add_memory(new_record, time=memory.time_step)
 
    if memory.size > max_memory_size:
        worst = memory.find_worst_memory(l2_threshold=-1.0, deletion_retrieval_n_times=-1)
        memory.delete_memory(worst, time=memory.time_step)
    else:
        worst = memory.find_worst_memory(
            l2_threshold=deletion_l2_threshold,
            deletion_retrieval_n_times=deletion_retrieval_n_times,
        )
        if worst is not None:
            memory.delete_memory(worst, time=memory.time_step)
 
    return pred_traj, l2_error

 
def coarse_agentdriver_addition(memory, token, prompts, pred_traj, coarse_llm_judge):
    """main_coarse.py asks an LLM judge for yes/no and stores accepted trajectories."""
    is_success, judge_reason = coarse_llm_judge(
        ego_prompts=prompts.ego,
        perception_prompts=prompts.perception,
        commonsense_mem=prompts.commonsense,
        planning_target=prompts.planning_target,
        pred_traj=pred_traj,
        temperature=0.0,
    )
    retrieved_token = memory.get_retrieved_memory(token)
    if is_success:
        memory.record_l2(retrieved_token, L2=0.0, timestep=memory.time_step)
        memory.add_memory(convert_working_memory_to_memory(prompts.working_memory, pred_traj),
                          time=memory.time_step)
    else:
        memory.record_l2(retrieved_token, L2=1.0, timestep=memory.time_step)
    return is_success, judge_reason
 
 
def error_free_variant(memory, working_memory, ground_truth):
    """main_noerrorprop.py adds ground-truth trajectory to test whether error propagation is from agent outputs."""
    record = convert_working_memory_to_memory(working_memory, ground_truth)
    memory.add_memory(record, time=memory.time_step)

Paper Concept	Source File	Key Class/Function
AgentDriver strict addition	main_strict.py	eval_l2, convert_working_memory_to_memory, experience_memory.add_memory
AgentDriver coarse addition	main_coarse.py	coarse_judge, record_l2, add_memory
Error-free propagation test	main_noerrorprop.py	REFERENCE_RESULT_FILE, adding ground_truth trajectory
Noisy-memory robustness variants	main_strict_noisymemory.py, main_coarse_noisymemory.py	inject Gaussian noise into initial ego_fut_traj
Evaluation command	scripts_patch/run_evaluation.sh	calls agentdriver/evaluation/evaluation.py --metric --success_threshold --result_file
Repository scope caveat	README.md	code is “for experiments related to AgentDriver only” and patches original AgentDriver

4. Experimental Setup (实验设置)

Agents and datasets. 作者选择一个可控 synthetic agent 和三个真实 agent，覆盖数值回归、EHR code generation、autonomous driving trajectory prediction、IoT traffic classification 四种输入输出形态。

• RegAgent：合成回归任务。先生成隐式权重 (w\in\mathbb{R}^6)，任务是根据检索到的 6 个相关 demonstrations 预测 (y=w^\top x)。初始 memory 由 100 个输入向量组成，(x) 来自三个高斯分布 (N(\mu,1))，(\mu\in{-0.5,0,0.5})，每个向量 6 维，输出含 bounded noise (\epsilon\in[-1,1])。正式执行阶段收集 4000 个 input-output pairs；若 (|\hat y-y|\le1) 则成功，指标为 success rate。
• EHRAgents：基于 MIMIC-III 的 EHR code-generation agent。过滤重复和不可回答项后共 2,392 个任务；每个 query 从初始 100 条 records 的 memory bank 中检索 4 条过去经验；text encoder 使用 OpenAI text-embedding-3-large；指标为 ACC。strict evaluator 用 exact match，coarse evaluator 用 LLM-generated termination signal。
• AgentDriver：基于 nuScenes 的 LLM autonomous driving agent。随机抽取 2,000 个 test cases，初始 memory 包含从 nuScenes training set 随机抽取的 180 条 experiences。原 AgentDriver retrieval 是先 top-3 vector similarity 再由 LLM 选最相关；本文为可复现性简化为 top-1 vector similarity。strict evaluator 使用 UniAD 3-second average L2，L2 error < 2.5 时添加 memory。
• CIC-IoT Agent：IoT traffic detection agent。原 CIC-IoT 有 34 个 attack classes，作者只保留基于 single-flow features 可区分的 8 类；随机采样 1,000 个 test cases；每次执行检索 3 条经验；初始 memory 是 GPT-4o-mini 从 disjoint training subset 生成的 100 条 synthetic records；指标为 ACC。

Addition strategies. 所有实验从相同初始 memory 出发，比较 fixed、add-all、C1/C2/C3 coarse selective addition、strict selective addition。多数实验 backbone language model 使用 GPT-4o-mini。RegAgent 的 C1/C2/C3 是 error threshold 1.6/1.4/1.2；其他 agent 的 C1/C2/C3 分别是 GPT-4o-mini judge、GPT-4.1-mini judge、用 300 条正确 judging data fine-tune 的 GPT-4.1-mini judge。

Deletion strategies and hyperparameters. RegAgent periodic deletion 每 500 steps，(\alpha=0)；history deletion 最小检索次数 5，(\beta=0.5)。EHRAgents periodic period 200，(\alpha=0)；history deletion 最小检索次数 5，(\beta=0.3) 用于 GPT-4o-mini / GPT-4.1-mini coarse evaluator，(\beta=0.7) 用于 strict 和 fine-tuned evaluator。

AgentDriver periodic period 500，(\alpha=0)；history deletion 中若一条 experience 被检索至少 3 次，且平均 UniAD 3-second L2 超过 5.0 则删除；coarse deletion 使用 predicted success rate，累计 success rate < 0.5 删除。CIC-IoT periodic cycle 500，(\alpha=1)；history deletion 中 experience 被检索至少 3 次且平均 score < 0.7 删除。

combined deletion 复用对应 periodical 与 history hyperparameters。

这些数值的来源需要区分：AgentDriver 的 N_SAMPLES=2000、strict addition SUCCESS_L2_THRESHOLD=2.5、初始 memory 180、coarse judge yes/no、error-free variant 写入 ground_truth 等来自 released code；RegAgent、EHRAgents、CIC-IoT 的 setup 与 deletion 阈值来自论文 LaTeX appendix，因为 released GitHub 仓库没有提供这三类 agent 的完整实现。

Evaluation metrics. RegAgent 与 AgentDriver 使用 SR（success rate），EHRAgents 与 CIC-IoT 使用 ACC；所有主表同时报告 final memory size。experience-following 分析使用 input similarity 与 output similarity 的关系：RegAgent input 是 vector cosine，output 是 RBF kernel；EHRAgents input 是 text embedding cosine，output 用 pycode_similar 计算 code plagiarism score；AgentDriver input 用原论文向量距离，output 用轨迹 RBF；CIC-IoT input 是 feature relative change，output 是 embedding similarity。

Challenge scenarios. Task distribution shift 用 EHRAgent 和 AgentDriver 原 test set 构造：先用 text-embedding-3-large 或 AgentDriver 原输入向量得到 query embeddings，再用 GMM 聚成 3 组，最后按 cluster label 重排 query，使三组任务顺序执行，制造明显 distribution shift。Resource constraints 固定 memory capacity，例如 EHRAgent 100 条、AgentDriver 180 条；combined deletion 先做 periodical deletion，若 addition 后仍超过容量，只删除平均 utility 最低的一条 record。

5. Experimental Results (实验结果)

5.1 Addition：strict evaluator 最稳定，add-all 经常最差

Table 1 的核心结果如下，括号内是 final memory size。

• Fixed：RegAgent SR 67.53 (100)，EHRAgents ACC 16.75 (100)，AgentDriver SR 40.11 (180)，CIC-IoT ACC 71.50 (50)。
• Add all：RegAgent 55.48 (4100)，EHRAgents 13.05 (2411)，AgentDriver 32.32 (2125)，CIC-IoT 59.90 (1050)。add-all 在四个 agent 上都明显恶化，说明 unfiltered memory growth 会积累坏 records。
• Coarse C1/C2/C3：C1 = RegAgent 63.18 (3511)，EHR 26.19 (1447)，AgentDriver 36.92 (1161)，CIC 74.00 (1030)；C2 = 65.78 (3347)，32.21 (1467)，40.01 (1119)，68.80 (936)；C3 = 67.35 (3139)，34.66 (1094)，47.37 (1285)，79.50 (952)。C3 在多数 agent 上是最好的 coarse evaluator，说明小规模高质量 judge fine-tuning 比直接使用 vanilla LLM judge 更稳。
• Strict：RegAgent 70.95 (2938)，EHRAgents 38.50 (1012)，AgentDriver 51.00 (1178)，CIC-IoT 85.40 (904)。strict 在所有 performance metric 上最佳，同时 memory size 低于 add-all，证明“高质量筛选 + 有限增长”优于“全部记住”。

从这些数字看，memory size 和 performance 并不单调相关。Add-all 的 memory size 最大，却在四个 agent 上最差；fixed memory 的规模小，但因为没有继续注入噪声，在 RegAgent、AgentDriver、CIC-IoT 上甚至超过一些 coarse evaluator；strict 与 C3 能让 memory 增长同时控制噪声，因此形成长期收益。论文据此提出一个实际原则：addition evaluator 的质量比 memory growth rate 更重要。

5.2 Experience-following 支撑 self-improvement，也解释 self-degradation

RegAgent 的结果最能说明机制。随着 selective addition 让 memory 中出现更相近的 demonstrations，input similarity 与 output similarity 接近一一对应，Pearson (r\approx1)。这意味着模型在相似输入上强烈跟随检索样本输出。如果检索样本是正确的，agent 的当前输出也更可能正确；如果检索样本是错的，当前输出会复制错误。AgentDriver 也出现类似趋势，说明这个性质并非只存在于合成数值任务。

这也解释了为什么 fixed-memory baseline 有时表现不差。固定 memory 的 input/output similarity 更低，表示模型仍保留一定内部推理，而不是完全模仿某个新加入的 noisy record。当 coarse evaluator 把错误 trajectory 加进 memory 后，agent 看到的 demonstrations 更相似但质量更低，于是 experience-following 反而造成退化。

5.3 Error propagation：错误输出被写回 memory 后会复利式传播

error-free variant 是最直接的证据。作者把 agent 自己生成的 trajectory 替换为 ground truth trajectory 作为 memory demonstration，其他流程不变。若 error-free 曲线优于原始曲线，就说明问题不是检索或任务难度本身，而是 memory 中记录了错误 execution。Figure 4 的 RegAgent 和 AgentDriver 对照显示，使用 ground truth demonstration 能显著缓解下降，尤其在 coarse evaluator 条件下说明 C1 无法完全过滤错误输出。对实际系统来说，这意味着只要允许 agent 自己的未验证输出进入长期 memory，就必须引入更可靠的反馈或审计机制。

5.4 Deletion：history-based deletion 需要可靠 utility evaluator，combined deletion 更省 memory

Table 2 比较 deletion 策略。Coarse C1 下，No deletion 为 RegAgent 63.18 (3511)、EHR 25.91 (1447)、AgentDriver 36.92 (1161)、CIC 74.00 (1030)；Period deletion 变为 60.88 (1012)、26.65 (338)、36.38 (426)、78.10 (355)；History deletion 为 62.10 (3205)、33.55 (1004)、34.00 (1019)、73.70 (952)；Combined 为 59.32 (951)、31.47 (279)、35.62 (372)、68.80 (352)。这说明粗糙 evaluator 下 deletion 的效果分化：EHR 从 history deletion 中受益明显，但 AgentDriver 和 CIC 可能下降；combined 大幅减少 memory size，但不一定保持最佳性能。

Strict evaluator 下，No deletion 为 RegAgent 70.95 (2938)、EHR 38.67 (1012)、AgentDriver 51.00 (1178)、CIC 85.40 (904)；Period deletion 为 67.65 (949)、38.59 (302)、50.94 (467)、80.80 (310)；History deletion 为 69.80 (2286)、42.06 (784)、51.81 (846)、89.60 (788)；Combined 为 66.58 (890)、42.34 (248)、49.97 (323)、85.50 (188)。这里 history deletion 在三个真实 agent 上都提升或维持性能：EHR 38.67 → 42.06，AgentDriver 51.00 → 51.81，CIC 85.40 → 89.60。Combined 则把 memory size 压到最小，例如 EHR 248、AgentDriver 323、CIC 188，同时仍保持接近或超过 no-deletion 的性能。

Figure 7 解读：该图展示 task distribution shift 下 EHRAgent 和 AgentDriver 的表现。竖线是任务分布切换点，横向虚线是无分布切换时 combined deletion 的性能。结果说明，distribution shift 不会让所有 memory 策略崩溃，但不同 deletion 的稳定性不同；在 EHRAgent 上，history-based deletion 不如 combined deletion，说明即便 periodical deletion 简单，也能帮助去除旧分布下的冗余 record，从而在分布切换时维持更稳定的 memory bank。

Figure 8 解读：该图比较 unlimited memory 与 limited memory 下 strict / coarse selective addition + combined deletion。即使 memory capacity 被固定到初始规模附近，策略仍能优于 fixed-memory variant，说明无限制 memory growth 并非必要。只要 deletion 能保留最相关、最高质量的 records，有限 memory 也可以承载长期自我改进；AgentDriver 不同容量实验还显示，随着容量增加性能逐步收敛到对应 unlimited variant。

5.5 限制与启发

本文是 empirical study，因此结论是行为规律与工程原则，而不是理论保证。四个 agent 覆盖面较广，但 evaluator 和 task pipeline 仍可能影响结论；strict evaluator 在实验中常用 ground truth 模拟，并不等同于真实部署中廉价可得的人类反馈；released code 只包含 AgentDriver patch，不能完全复现 RegAgent、EHRAgents、CIC-IoT 的所有细节。另一个限制是，论文没有训练一个会主动学习 memory policy 的 agent，而是分析手工设定的 addition/deletion rules。

尽管如此，论文给出的实践启发很清晰。第一，长期 memory 不能 add-all；任何生产系统都应把 trajectory 写入 memory 视为有风险的数据入库操作。第二，检索相似度不等于 demonstration 有效性，需要记录“该 memory 被检索后任务是否成功”的历史效用。第三，deletion 不只是节省存储，更是纠正 memory bank 分布的手段。第四，agent 的 self-improvement 依赖 evaluator 可靠性；如果 evaluator 噪声大，memory system 会把 evaluator 的偏差放大成长期行为偏差。