---

前言

在 Agent Memory 系列中，我们通常把“记忆”理解为存进向量库、图结构或外部存储中的内容。但对一个持续调用推理模型的 Agent 来说，还有一种更直接、也更昂贵的记忆：不断增长的对话与推理历史本身。

Agent 每调用一次模型，往往会把任务描述、观察、工具返回、历史动作和先前推理重新提交。为了节省上下文，工程上常见的做法是删除旧推理、只保留最近若干步，或者周期性摘要。直觉上，上下文缩短了，计算就应该更便宜。

这篇论文指出，这个直觉并不可靠。

删除一段历史虽然减少了后续注意力需要读取的内容，却可能破坏前缀缓存，使仍然保留在它后面的内容被重新计算；模型看不到旧推理后，还可能重新生成计划、重复探索，甚至改变任务结果。更重要的是，客户端决定保留或编辑什么，服务端决定缓存复用什么，二者共同决定真实成本。只比较 Token 数量，无法说明一个上下文策略究竟更省还是更贵。

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

论文将 Agent 上下文管理的成本拆成“处理 Token 的线性成本”和“回看历史的注意力成本”，用架构汇率 $P^{\ast }=c/\beta$ 刻画重新思考与继续记忆的分界，并进一步把策略变化拆成固定输出下的机械成本与行为改变后的成本，从而证明上下文策略必须与模型架构、缓存规则和任务结果一起比较。

它讨论的并不是“哪种记忆压缩算法最好”，而是更基础的问题：思考与记忆之间到底按什么汇率交换？

零、论文基本信息

• 论文名称： Think or Remember: The Exchange Rate of Agentic Inference
• 发表平台： arXiv:2611.10982（cs.CL / cs.AI）
• 作者： Juan Wisznia、Santiago Luis Groba Alonso、Matías Gómez Taddeo、Gonzalo Zabaleta、Joaquín Cullen、Luciano Del Corro

一、问题背景：短上下文为什么不一定更便宜

1. Agent 的上下文由两方共同决定

论文把系统中的决策者分成两方：

• 客户端： 决定保留、删除、摘要或改写哪些消息；
• 服务端： 决定以前的 reasoning 是否重新出现在 prompt 中，以及哪些计算状态能够从缓存复用。

作者把返回历史 reasoning 的策略称为 Keep，把删除历史 reasoning 的策略称为 Drop。

这两个选择不能混为一谈。文本仍在上下文里，不代表服务端一定复用其 KV 状态；文本被删除，也不代表后面的内容可以继续复用，因为前缀一旦改变，后续缓存可能全部失效。

2. Token 数量隐藏了位置与缓存状态

同样是 1000 个 Token：

• 位于短上下文前部时，注意力开销较低；
• 位于很长的历史之后时，每个新 Token 都要关注更多 Key；
• 已经缓存的 Token 不需要重新通过模型投影层；
• 编辑发生在历史中间时，它后面的幸存文本可能都要重新计算。

因此，“Prompt Token 少了 20%”并不能直接推出“推理成本下降 20%”。

3. 删除历史还会改变 Agent 行为

如果模型仍能看到先前计划，它可能直接沿用；如果计划被删除，它可能重新规划、重复试错，或者更早停止。上下文策略不只改变同一条轨迹的处理成本，也会改变轨迹本身。

这就产生两个不同问题：

1. 如果 Agent 后续输出完全相同，删改历史会造成多少机械性计算变化？
2. Agent 因历史不同而生成了不同内容后，总成本与任务效果如何变化？

论文的理论与实验都围绕这两个问题展开。

二、相关工作与本文的位置

1. 上下文压缩与记忆管理

自动摘要、滑动窗口、Context Language Model、连续上下文管理等方法都试图减少长程 Agent 的上下文负担。许多工作报告 Token、API 费用或 FLOPs，但通常固定在一种服务端缓存约定下。

本文并不再提出一种压缩器，而是给这些方法提供统一的计价框架：同一个编辑策略换到另一种缓存规则或架构上，成本排序可能反转。

2. 缓存感知的上下文编辑

已有工作注意到历史编辑会使前缀缓存失效，也有方法通过保留 KV 状态减少重新 prefill。但论文认为，仅记录缓存失效仍不够，因为还要同时考虑：编辑位置、幸存尾部长度、后续注意力、重新生成成本以及行为变化。

3. 推理轨迹保留与遗忘

SWE-AGILE、Memento、状态承诺学习以及 Agent Forgetting 相关工作研究如何删除、屏蔽或压缩推理。本文与它们的区别是：它既计算删除带来的重建成本，也实测删除后 Agent 生成了什么、是否还完成任务。

4. 与 Agent Memory 系列的关系

A-MEM、MAGMA、CoM 等工作主要回答记忆如何组织、检索和更新；ENGRAM 研究经验何时可以从外部检索迁移到权重；本文则把视角推进到在线服务层：

即使记忆内容完全相同，模型架构与服务端缓存规则也会改变“保留它”和“重新想一遍”的价格。

三、系统总览：一次 Agent Run 到底花在哪里

1. 一次调用中的四个量

在第 $t$ 次调用中：

• $P_t$：服务端渲染后的 Prompt 长度；
• $R_t$：能够从缓存中复用的前缀长度；
• $G_t$：本次生成所处理的位置数；
• $\rho$：缓存规则，$\rho =1$ 表示生成状态也可复用，$\rho =0$ 表示只复用 Prompt。

缓存命中时，前 $R_t$ 个位置不需要重新经过模型计算，但它们仍然作为后续注意力的 Key 存在。

2. 为什么需要先看缓存重建示意图

下面的图把“文本是否保留”与“计算是否复用”拆开。它是理解全文最重要的起点。

Figure 1：Serving changes the price of the same history。 示例中已有 16000 Token 任务、2000 Token 推理和 100 Token 动作；下一次调用加入 500 Token 输入并生成 100 Token。阴影块表示必须重算的部分。生成状态可复用时 Keep 为 33.6 TFLOPs、Drop 为 38.6 TFLOPs；仅复用 Prompt 时 Keep 升至 149.9 TFLOPs，而 Drop 仍为 38.6 TFLOPs。

同样一段历史，在左侧规则下保留更便宜，在右侧规则下删除更便宜。区别不是模型输出，而是服务端是否复用生成 Token 的状态。

四、成本模型：Token 处理价与注意力价

1. 两种基础价格

作者用两个架构系数描述计算：

• $c$：每处理一个位置经过投影层等线性模块的成本；
• $\beta$：每形成一个 Query-Key 注意力对的成本。

设 $N_{\rho }$ 为所有实际处理的位置数，$Q_{\rho }$ 为所有注意力对数量，$G$ 为生成位置总数，$w$ 为生成相对普通处理的价格溢价，则一次完整运行的成本是：

$$C_{\rho ,w}(\pi ;\xi )=c{N}_{\rho }+\beta Q_{\rho }+(w-1)cG$$

其中 $\pi$ 是上下文策略，$\xi$ 是该策略下实际产生的后续轨迹。

第一项计算 Token 通过模型主体的成本，第二项计算注意力回看历史的成本，第三项用于描述解码路径相对 Prefill 更贵的情况。

2. 实际处理位置数

$$N_{\rho }=\sum _t(P_t-R_t+G_t)$$

Prompt 中只有 $P_t-R_t$ 个位置需要重新处理，再加上生成的 $G_t$ 个位置。某个位置如果因缓存失效被处理两次，就会被计算两次。

3. 注意力对数量

$$Q_{\rho }=\sum _t\left[\sum _{i=R_t+1}^{P_t}i+\sum _{j=1}^{G_t}(P_t+j)\right]$$

Prompt 中每个重新处理的位置会关注它之前的 Key；生成第 $j$ 个 Token 时，则需要关注 $P_t+j$ 个位置。这个公式把“Token 位于上下文的什么位置”纳入成本，而不是把所有 Token 视为同价。

五、核心概念：思考与记忆的架构汇率

1. 汇率定义

论文把两个价格的比值定义为：

$$P^{\ast }=\frac{c}{\beta }$$

$P^{\ast }$ 的单位可以理解为“每处理一个 Token 的线性成本，相当于多少个注意力对”。当一个位置可见的历史长度为 $P$ 时，其边际成本为：

$$c+\beta P$$

在 $P=P^{\ast }$ 时，线性处理与注意力两部分正好相等。

• 当 $P<P^{\ast }$，处理 Token 本身更占主导，属于 thinking regime；
• 当 $P>P^{\ast }$，回看历史的注意力更占主导，属于 memory regime。

2. 架构会改变分界点

Figure 2：The architectural crossover。 注意力边际成本占比达到 50% 时，混合架构 Qwen3.6-27B 的交叉点约为 124K Token；把其循环层替换成全注意力层后的合成版本约为 30K Token。

Qwen3.6-27B 的 64 层中只有 16 层使用注意力，因此注意力相对便宜，能够在更长上下文中仍停留在 thinking regime。由此可见，“多长算长上下文”不是固定常数，而是模型架构属性。

3. 服务端还会移动“重新思考”的汇率

如果一个已生成 Token 将来需要再次出现，重新生成它要支付 $wc$；若保留它但生成状态不能复用，则还需再次处理。作者定义重新生成汇率：

$$P_{\mathrm{regen}}^{\ast }=\frac{wc-(1-\rho )c}{\beta }=(w+\rho -1)P^{\ast }$$

当 $\rho =1$ 时，保留生成状态更有价值；当 $\rho =0$ 时，旧输出返回 Prompt 仍需重算，重新生成与保留之间的差距缩小。生成越昂贵，即 $w$ 越大，删除后重新写一遍越不划算。

六、保留一段推理多久才划算

1. 重建成本

设可复用前缀长度为 $H$，需要重建的连续内容有 $n$ 个 Token。其成本为：

$$A(H,n)=cn+\beta \left[Hn+\frac{n(n+1)}{2}\right]$$

第一部分是重新处理 $n$ 个位置，第二部分是它们对前缀以及彼此进行注意力的成本。

2. 保留时长的盈亏平衡点

设一段 reasoning 有 $r$ 个 Token，位于长度为 $H$ 的前缀之后、长度为 $a$ 的答案之前。后续又处理了 $L$ 个位置。

在生成状态可复用时，保留 reasoning 会让每个后续位置多关注 $r$ 个 Key；删除 reasoning 则要一次性重建后面的答案：

$$\Delta M_{\mathrm{keep}}=\beta rL-A(H,a)$$

令两者相等，可得到保留期限：

$$L^{\ast }=\frac{a}{r}\left(P^{\ast }+H+\frac{a+1}{2}\right)$$

当 $L<L^{\ast }$ 时，保留更便宜；超过 $L^{\ast }$ 后，持续注意这段 reasoning 的累计成本超过了一次性重建答案。

论文给出的例子很直观：在 Qwen3.6-27B、$H=20$K、reasoning 长度 2000 的情况下，如果后续答案只有 7 Token，保留约 500 个后续处理位置后就不再划算；如果答案是 4000 Token 的长命令，删除后重建代价很大，保留期限会拉长到约 290K。

3. Prompt-only 缓存下的结论相反

如果服务端只复用 Prompt，Keep 和 Drop 都要重建后续答案，Keep 还要重新处理旧 reasoning：

$$\Delta M_{\mathrm{keep}}=\beta rL+A(H,r)>0$$

在这组严格假设下，Keep 从机械成本上永远不会更便宜。这再次表明，讨论“该不该保留推理”时必须声明缓存规则。

七、编辑历史：删得多不如删得对

设已缓存历史中，在长度为 $H$ 的前缀后，把 $b$ 个 Token 替换成 $s$ 个 Token，并保留其后的 $\ell$ 个 Token。生成替换文本的成本为 $K_{\mathrm{gen}}$，则编辑相对不编辑的机械成本为：

$$\Delta M_{\mathrm{edit}}=K_{\mathrm{gen}}+A(H,s+\ell )-\beta (b-s)L$$

三部分分别是：

1. 生成摘要或替换文本；
2. 因前缀改变而重建替换文本与幸存尾部；
3. 未来少关注 $b-s$ 个 Key 所节省的注意力成本。

这条公式解释了一个反直觉现象：编辑位置可能比压缩比例更重要。 如果编辑发生在很早的位置，后面有很长的幸存尾部，缓存重建会非常昂贵；如果一段推理刚生成就立即决定是否删除，后面几乎没有尾部需要重建，成本反而可能接近 Keep。

八、机械变化与行为变化必须分开

1. 为什么只重放日志还不够

固定已有输出进行回放，可以计算同一轨迹在不同缓存规则下的机械成本；但看不到模型因为历史不同而产生的新计划、新动作和新结果。反过来，只比较两次真实运行，又无法判断成本差异来自缓存重建还是行为改变。

2. 精确分解

设策略 1 产生轨迹 ${\xi }_1$，基线策略 0 产生轨迹 ${\xi }_0$。总成本差为：

$$\Delta C=C(1;{\xi }_1)-C(0;{\xi }_0)$$

加入并减去 $C(0;{\xi }_1)$ 后，可以拆成：

$$\Delta M=C(1;{\xi }_1)-C(0;{\xi }_1)$$

$$\Delta B=C(0;{\xi }_1)-C(0;{\xi }_0)$$

$$\Delta C=\Delta M+\Delta B$$

$\Delta M$ 固定轨迹，只改变处理策略，表示机械变化；$\Delta B$ 固定处理策略，只替换轨迹，表示行为变化。

策略 1 真正省钱的条件是：

$$-\Delta B>\Delta M$$

也就是，行为带来的节省必须覆盖编辑或缓存重建造成的机械开销。如果机械部分本身已经节省，那么它可以容纳一定的后续行为膨胀。

3. 分解依赖参考轨迹，但总差值不依赖

用 ${\xi }_1$ 还是 ${\xi }_0$ 作为回放参考，会改变机械项与行为项各自分到多少；不过二者之和 $\Delta C$ 不变。因此，论文并没有把某个分解比例当作唯一因果解释，而是强调总成本以及明确声明的参考轨迹。

九、实验设置

1. 任务与模型

论文主要使用：

• ScienceWorld： 多步科学环境交互；
• HotpotQA： 隐藏段落标题的多跳问答，只评最终答案；
• Chained ScienceWorld： 连续执行多个任务，比较 Fresh Session 与跨任务携带历史；
• Hosted Compaction： 在 Qwen3.7-Plus 上比较自动 Summary 与 CLM 编辑。

开放模型包括 Qwen3-4B、Qwen3-8B、Qwen3-30B-A3B、Qwen3-32B、gpt-oss-20b，以及附录中的其他模型与控制组。

2. 证据分为三层

1. 引擎验证： 用 instrumented vLLM 核对公式预测的操作数；
2. 固定轨迹回放： 保持生成结果不变，只改变架构价格和缓存规则；
3. Live fork： 从同一历史分叉点真实运行 Keep 与 Drop，同时测成本和任务结果。

这种分层很重要：第一层验证计价是否正确，第二层识别机械效应，第三层才观察行为和成功率。

十、计数模型是否可信

论文在 RTX 3070 上使用 instrumented vLLM，对 dense Qwen3-1.7B 与 hybrid Qwen3.5-2B 的 27 种调度、共 648 个请求进行验证。

Figure 9：Predictions agree with GPU execution。 横轴是理论预测的 Keep-Drop 操作数差异，纵轴是引擎实际记录的差异；两类模型的点均落在对角线附近，所有请求的计数一致。

这验证的是 Token、注意力对和缓存位置的操作计数，不是端到端延迟。作者特别指出，实际时间还受批量大小、显存带宽和实现影响，因此用 $w=1$ 到 $w=5$ 做敏感性分析，而不是把 FLOPs 直接冒充延迟或费用。

十一、固定轨迹实验：上下文更短，计算反而可能更多

1. 滑动窗口的重建陷阱

论文在 132 条 ScienceWorld 记录上保持所有生成、动作与外部输入不变，只改变 reasoning 删除计划。

Figure 3：Editing history and generating more work have different costs。 左侧比较立即删除、每五步清空、只保留最近一块和最近五块；右侧给出生成一个 Token 并在下次 Prompt 返回它，相对一次输入读取的价格。

结果最反直觉的是：

• Keep latest 5 只把提交 Prompt 缩短了约 1.6%，成本却达到 Keep all 的 3.97 到 4.56 倍；
• Drop immediately 在生成状态可复用时始终与 Keep all 相差不到 2%；
• 无任何前缀复用时，所有删除策略才都比 Keep 便宜。

原因是滑动窗口每前进一步，就在不同位置改变历史，导致后面的幸存内容反复重建；立即删除虽然删得更激进，却在尾部尚未增长前作决定，缓存破坏更小。

$$\begin{array}{lrrrr}\text{Reasoning Policy}& \text{Prompt Volume}& \text{Full Reuse}& \text{Prompt-only}& \text{No Reuse}\\ \text{Keep all}& 1.000& 1.000& 1.000& 1.000\\ \text{Drop immediately}& 0.976& 0.983& 0.955& 0.946\\ \text{Keep latest 1}& 0.978& 1.861& 1.809& 0.949\\ \text{Keep latest 5}& 0.984& 4.542& 4.416& 0.960\\ \text{Clear every 5}& 0.978& 1.598& 1.560& 0.948\end{array}$$

Table 17：固定 132 条 continuation 的删除计划成本。 成本均相对 Keep all；参考设置为 $w=1$、16 Token 缓存块。该表说明 Prompt 体积与真实计算量可能严重背离。

十二、服务端缓存规则可以让排名反转

作者对同一组 103 个 Qwen3-8B ScienceWorld 分叉轨迹重新计价，不改变任何响应或结果。

Figure 4：Prices reverse rankings on unchanged work。 在生成状态可复用时，Drop/Keep 总成本为 1.74；只复用 Prompt 时约为 1.02；完全不复用时降至 0.34。蓝线为 $w=1$，橙色虚线为 $w=5$。

$$\begin{array}{lcc}\text{缓存规则}& \text{Median D/K}& \text{Total D/K}\\ \text{Prompt + generation}& 1.87[1.38,2.29]& 1.74[1.46,2.08]\\ \text{Prompt only}& 1.04[0.79,1.40]& 1.02[0.86,1.23]\\ \text{No reuse}& 0.40[0.30,0.49]& 0.34[0.28,0.42]\end{array}$$

Table 11：同一批 103 个 ScienceWorld 分叉的重新计价。 Full reuse 与 no reuse 的置信区间分别位于 1 的两侧；Prompt-only 的区间跨过相同成本。

这组实验几乎是论文核心观点的最干净证据：策略、轨迹和任务结果完全不变，只改变 serving rule，哪一个更便宜就反转了。

十三、Live 结果：便宜与正确不是同一个目标

$$\begin{array}{llrcc}\text{任务}& \text{模型}& n& \text{Cost D/K}& \text{Solved D-K(pp)}\\ \text{SW}& \text{Qwen3-8B}& 103& 1.74[1.46,2.08]& -3.9[-10.2,2.0]\\ \text{SW}& \text{Qwen3-4B}& 126& 1.18[0.93,1.49]& 0.8[-8.8,9.0]\\ \text{SW}& \text{Qwen3-30B-A3B}& 119& 1.73[1.43,2.09]& -0.8[-6.6,5.4]\\ \text{SW}& \text{gpt-oss-20b}& 88& 1.20[0.96,1.49]& 19.3[10.7,29.3]\\ \text{HP}& \text{Qwen3-8B}& 165& 0.81[0.64,1.00]& -13.3[-20.6,-6.1]\\ \text{HP}& \text{Qwen3-4B}& 122& 0.70[0.48,1.04]& -13.9[-22.1,-5.7]\\ \text{HP}& \text{Qwen3-30B-A3B}& 88& 0.92[0.80,1.06]& -22.7[-33.0,-11.4]\\ \text{HP}& \text{gpt-oss-20b}& 195& 0.92[0.78,1.09]& -9.2[-14.9,-4.1]\end{array}$$

Table 1：同一分叉点上的 Live Keep 与 Drop。 使用生成状态复用和 $w=1$；Cost D/K 小于 1 表示 Drop 点估计更便宜，Solved D-K 为完整答对率差值。ScienceWorld 与 HotpotQA 的方向明显不同。

1. HotpotQA：更便宜，但答错更多

在四个模型上，Drop 的点估计成本为 Keep 的 0.70 到 0.92，但成本置信区间都包含 1；与此同时，完整答对率稳定下降 9.2 到 22.7 个百分点，而且成功率差异区间不跨 0。

Qwen3-8B 的重复实验在相同问题样本上再次得到约 11 个百分点下降。它不是独立问题样本，因此加强的是同一设置下的可重复方向，而不是广泛外推能力。

2. ScienceWorld：Drop 通常更贵，但存在强反例

对三个 Qwen3 模型，Drop 成本达到 Keep 的 1.7 到 1.9 倍，而成功率差异大多跨 0。gpt-oss-20b 是显著反例：Drop 在 88 个任务中完成 20 个，Keep 只完成 3 个，提高 19.3 个百分点。

因此，论文不支持“保留 reasoning 总是更准确”，也不支持“删除 reasoning 总是更便宜”。任务、模型和历史格式都会改变结果。

十四、为什么历史会改变后续工作

Figure 12：Retention changes future work。 一个 ScienceWorld 样例中，Keep 在第 60 与 66 次调用重复完全相同的 371 Token 推理和动作；Drop 因看不到旧 reasoning，在后续调用中重新表述 232 Token 与 617 Token 的计划，并采取不同动作。

这张图提醒我们，保留历史也可能让模型陷入重复，而删除历史也可能触发更有用的重规划。行为项不是噪声，而是上下文策略真正作用的一部分。

十五、跨任务携带历史：成本下降，成功率也下降

作者让 Qwen3-8B 执行 32 条五任务链：四个不同 ScienceWorld 任务，最后重复第一个任务。比较每个任务新建 Session、跨任务携带历史，以及允许模型主动 clear memory。

Figure 5：Lower cost comes with fewer completed tasks。 左侧为相对 Fresh 的回放成本，右侧为原生任务成功率；误差线是以完整任务链为单位的 95% Bootstrap 区间。

$$\begin{array}{lrrrrr}\text{策略}& \text{Calls}& \text{Solved}& \text{Cost/Fresh}& \text{New Tasks}& \text{Clear}\\ \text{Fresh/Keep}& 1094& 47/160& 1.00& 30/96& 0\\ \text{Carry/Keep}& 1139& 34/160& 0.60& 17/96& 0\\ \text{Clear option/Keep}& 1207& 42/160& 0.98& 25/96& 45\\ \text{Fresh/Drop}& 1199& 33/160& 1.00& 26/96& 0\\ \text{Carry/Drop}& 1222& 19/160& 0.43& 13/96& 0\end{array}$$

Table 16：五种跨任务历史策略。 Carry 在 Keep 下只需 Fresh 约 60% 的成本，在 Drop 下只需 43%，但对后续新任务的成功数分别从 30 降至 17、从 26 降至 13。

历史携带使缓存复用更多，所以更便宜；但旧任务内容干扰新任务，导致完成率下降。允许模型主动清理介于两者之间：成功率 42/160，成本接近 Fresh，而且模型调用 clear memory 45 次，其中 42 次发生在新任务的第一次调用。

十六、摘要与模型自主编辑：不存在固定赢家

论文还比较自动 Summary 与 CLM 自主编辑，并与 Keep/Drop 原生 reasoning 做 $2\times 2$ 交叉实验。

Figure 6：Client-policy rankings change across cohorts。 纵轴是 CLM/Summary 的 API 总费用；小于 1 表示 CLM 更便宜。三个实验批次在 Keep 和 Drop 条件下出现不同排序。

三个 cohort 中，CLM 相对 Summary 的成本从 0.62 倍到 1.79 倍：

• 原始 cohort：Keep 下 CLM 更便宜，Drop 下更贵；
• 第一次扩展：排序反转；
• 第二次扩展：Keep 下便宜约 15%，Drop 下贵约 33%。

但每个单元只是每条任务流一次、温度 0.7 的运行，且 cohort 之间 harness 与输出额度不同。论文因此把它作为“策略排名依赖系统和运行群体”的证据，而不是宣称 CLM 或 Summary 谁普遍更优。

十七、论文中没有传统消融，但有哪些控制实验

这是一篇成本建模与系统实验论文，没有典型的“移除模块”消融。它用以下控制代替：

1. 固定 continuation 的机械回放

保持生成内容、动作和环境输入不变，只改变删除计划、缓存规则和架构汇率，用于隔离机械成本。

2. 同一 fork 的 Live Keep/Drop

从完全相同的历史节点分叉，比较两个策略后续真实行为，用于测量行为项和任务结果。

3. 多缓存规则重新计价

在生成状态复用、只复用 Prompt、完全不复用三种条件下重新计价，直接验证 serving rule 会改变排名。

4. 解码价格敏感性

把 $w$ 从 1 扫到 5。删除策略若诱导更多生成，$w$ 越高越不利；固定输出的删除计划共享相同 $G$，其绝对成本差不受 $w$ 影响，但比值会向 1 收缩。

5. 重复与反例保留

论文保留 gpt-oss 在 ScienceWorld 上 Drop 显著更好的异常结果、HotpotQA 重复实验以及零调用样本等，而不是只展示符合主要叙事的数据。这让结论边界更清楚。

十八、效率结论应该如何正确表述

论文的结果不能简化成“Keep 更省”或“Drop 更省”。更准确的总结是：

1. 有生成状态复用时，删除 reasoning 可能因缓存重建而更贵；
2. 无复用时，短 Prompt 更直接地带来成本下降；
3. 滑动窗口可能比立即删除贵得多，因为它反复改变前缀；
4. Drop 诱导更多输出时，解码越贵，Drop 越不利；
5. Carry 虽节省计算，却可能降低新任务成功率；
6. 操作数、延迟、能耗和 API 账单不是同一个指标。

十九、与 Agent Memory 方法的横向比较

$$\begin{array}{llll}\text{方法}& \text{主要问题}& \text{核心对象}& \text{是否显式建模 Serving}\\ \text{A-MEM}& \text{记忆如何关联演化}& \text{动态记忆网络}& \text{否}\\ \text{MAGMA}& \text{多视角记忆如何组织}& \text{多图记忆}& \text{否}\\ \text{CoM}& \text{何时读写修改记忆}& \text{记忆控制动作}& \text{否}\\ \text{ReMemR1}& \text{写入时如何回看历史}& \text{可回访记忆}& \text{否}\\ {\text{Mem}}^2\text{Evolve}& \text{记忆系统如何长期演化}& \text{自演化记忆}& \text{否}\\ \text{ENGRAM}& \text{何时让经验退出检索}& \text{经验到权重的迁移}& \text{否}\\ \text{Think or Remember}& \text{保留或删除历史如何计价}& \text{架构、缓存、轨迹与结果}& \text{是}\end{array}$$

横向比较：本文在 Agent Memory 系列中的位置。 前述方法主要研究记忆内容和生命周期，本文则研究在线历史作为计算对象的价格。它可以作为这些记忆系统的成本层，而不是替代其语义组织机制。

对记忆系统而言，这篇论文带来一个重要修正：检索到多少 Token 只是第一层指标，还要问这些 Token 是否命中前缀缓存、插入位置是否破坏缓存、是否诱发额外推理，以及目标模型的 $P^{\ast }$ 是多少。

二十、对 Coding Agent 的启发

1. 不要只按上下文长度触发压缩

Coding Agent 的历史包含 Shell 输出、补丁、测试日志和推理。传统“达到 80% Context 就摘要”只看容量，没有考虑编辑位置和缓存重建。更合理的控制器应估计：

• 被替换块的长度；
• 替换后仍需保留的尾部；
• 摘要生成成本；
• 预计还剩多少次模型调用；
• 服务端能否复用生成状态。

2. 尽量在阶段边界编辑

当一次测试或子任务刚结束、后续尾部尚短时进行压缩，比在长历史中部反复滑窗更容易保留缓存。对于 Coding Agent，可以在“定位问题完成”“补丁提交”“测试通过”这些边界形成稳定 checkpoint。

3. 成本优化必须绑定回归测试

Carry 历史便宜却降低新任务成功率，HotpotQA Drop 便宜却少答对 9 到 23 个百分点。Coding Agent 的上下文优化同样不能只以 Token 或账单作为奖励，还要同时保留测试通过率、误改文件数与完成时间。

二十一、对 Tool Agent 与 Multi-Agent 的启发

1. Tool Agent

Tool Agent 经常把工具返回加入历史。可以把工具输出分成：

• 长期仍需逐字引用的证据；
• 已转化为结构化状态的结果；
• 只服务于刚完成步骤的临时日志。

删除临时日志前，应先检查其后是否已有大量幸存历史。必要时在生成工具结果时就决定保留形式，而不是等历史很长后再从中间改写。

2. Multi-Agent

多 Agent 系统会在消息传递与共享上下文之间选择。把所有角色历史复制给每个 Agent 会增加注意力成本；只传摘要又可能产生重建和重新协商。$P^{\ast }$ 提供了一个架构相关尺度，而机械/行为分解提醒我们：通信压缩必须同时评估后续协作轮数与任务质量。

二十二、局限性

1. 成本模型不是实际延迟或能耗

大部分结果是声明系数下的操作计数。解码可能受显存带宽限制，批量大小也会改变时间价格。论文只在一个 GPU、两个模型上补充时间测量，并用 $w$ 扫描代替部署级校准。

2. 服务端缓存状态来自重建

开放模型实验根据日志 Prompt 重建缓存状态，而不是直接读取远端服务内部状态；Hosted 轨迹还使用参考开放模型系数重新计价。因此它们是明确假设下的 counterfactual price，不是供应商真实账单。

3. 任务覆盖有限

主要任务是 ScienceWorld 和 HotpotQA，调用上限与上下文长度有限。Coding Agent、浏览器 Agent 和长周期个人助理中的缓存与行为模式可能不同。

4. Keep-or-Drop 规则没有作为成熟在线策略部署

论文推导了 $L^{\ast }$ 和近似规则，但核心贡献是计价与比较框架，不是一套经过大规模部署验证的动态控制策略。

5. Compaction 实验样本较小且设置变化

CLM 与 Summary 只有 20 条完整链，分成三个 cohort，并且 Harness、输出额度等存在修订。排序反转可能包含运行随机性，不能当作稳定方法排名。

6. 精度与架构效应没有完全分离

不同模型以不同精度运行，因此跨模型的成本与成功差异不能全部归因于架构。gpt-oss 的成本系数也不是完整滑动窗口层操作账户。

7. 答案正确率不是完整任务质量

HotpotQA 只评最终答案；Hosted Coding 链中的人工审计还发现一些原生 verifier 判定通过、但存在临时文件、修改测试或规则实现过窄的问题。成功指标本身也需要审慎解释。

二十三、我的理解与启发

1. Memory Policy 实际上是 System Policy

过去我们容易把上下文策略写成模型端算法：摘要器压缩了多少、检索器召回多少、窗口保留多少。论文最重要的提醒是，策略的成本属于整个系统：客户端文本、模型架构、服务端缓存和模型行为缺一不可。

2. “少 Token”应该降级为诊断指标

Token 数量仍有价值，但它不是最终成本。更完整的运行日志至少应记录：Prompt 长度、缓存命中前缀、生成长度、编辑位置、重建尾部、任务成功以及服务端缓存约定。

3. 最好的压缩时机可能是内容刚产生时

滑动窗口之所以昂贵，不是因为它删得少，而是因为它反复在旧历史中移动切口。工程上更好的策略可能是在每个 reasoning block、工具阶段或子任务结束时立即做一次“保留原文、结构化或丢弃”的决定，让后续历史建立在稳定前缀上。

4. 需要缓存感知的 Agent Memory Controller

未来的记忆控制器不应只预测相关性和重要性，还应估计一个编辑动作的 $\Delta M$、可能诱发的 $\Delta B$ 以及质量风险。它可以在运行前用日志回放估计机械项，再通过小规模 A/B fork 学习行为项，最终针对具体部署选择策略。

5. 思考与记忆不是价值判断，而是动态交换

长历史并不天然浪费，重新思考也不天然智能。短期内保留一段 reasoning 可能避免昂贵重建；长期看，持续注意它又可能超过重新生成的成本。$L^{\ast }$ 的意义正在于：保留或遗忘应该依据未来工作量动态决定，而不是永久规则。

二十四、总结

《Think or Remember》给 Agent Memory 补上了一个常被忽略的系统层：记忆不只有语义价值，还有由架构和 Serving 共同决定的计算价格。

论文用 $C=cN+\beta Q$ 将 Token 处理与注意力回看分开，用 $P^{\ast }=c/\beta$ 定义思考与记忆的架构汇率，再把策略差异拆成机械项和行为项。实验表明：同一批 Qwen3-8B ScienceWorld 轨迹，Drop 在生成状态复用时是 Keep 的 1.74 倍，在完全无复用时却只有 0.34 倍；而在 HotpotQA 上，Drop 虽然点估计更便宜，却让四个模型少答对 9 到 23 个百分点。

一句话总结：

Agent 应该思考还是记住，不能只看上下文有多长，而要看架构如何给 Token 与注意力定价、服务端复用哪些状态，以及历史变化会让 Agent 接下来做出什么。

参考资料

1. Think or Remember: The Exchange Rate of Agentic Inference
2. 论文 PDF