第 4 周：测试 Agent 怎么记住已经探索过的页面？

让测试 Agent 去探索一个博客应用，30 步之后看日志：24 个页面只去过 12 个，又回到首页 6 次、回到"我的主页" 4 次，“注销账号"一次都没点到，“A 的评论"里的 XSS 和"我的收藏"里的 Bug 各被报了两遍（下文实验里 seed 1000 的无记忆运行）。这不是模型笨，是它不记得自己去过哪、报过什么。上下文窗口能记住一次会话里发生的事，可历史一压缩，细节就丢了；换一个新会话，这些更是一概读不到。这一章讲 Agent 的记忆：存什么、什么时候写、什么时候读，以及测开最关心的问题：加了记忆到底好多少，怎么量。

讲解视频

互动演示

一个仿 RealWorld（Conduit）的 24 页小站点，6 个页面藏着注入的 Bug。切换三种策略（无记忆、已访问集合、已访问集合 + 链接表），调记忆容量和遗忘策略（FIFO、LRU、随机），单步或自动播放，看探索路径怎么走，覆盖率、重复访问、重复报 Bug 和估算 token 实时更新。“批量跑 200 次"会用 seed 1000～1199 把当前配置和无记忆基线各跑一遍，给出配对差值的区间。随机数和下文的 Python 脚本逐位一致，两边数字相同。页面底部有自动判分的练习。

记忆分几种

按生命周期分三层：

「Agent 到底是什么？一个 while 循环」说过，API 是无状态的，messages 列表就是全部状态；「上下文快满了，Codex 怎么办？」讲了 Codex 怎么压缩。这一章讲第三层，以及三层怎么配合。

按内容分，常被引用的是 CoALA 框架（Sumers、Yao、Narasimhan、Griffiths，Cognitive Architectures for Language Agents，arXiv 2309.02427，2023；发表于 TMLR 2024）。它借用认知科学和 Soar 认知架构里的划分：一个短期的工作记忆，加三种长期记忆。

两个细节。第一，CoALA 的工作记忆比上下文窗口宽：它定义为一个跨 LLM 调用持续存在的数据结构，每次调用从里面挑一部分拼成 prompt，模型输出再解析回去。实践中上下文窗口是它最主要的载体，但两者不完全等同。第二，CoALA 指出写程序性记忆（让 Agent 改自己的代码）比写情景、语义记忆风险大得多，容易引入 Bug，或者绕开设计者的意图。

三种实现

经验法则：能结构化的就结构化。“这个页面去过没有"“这个 Bug 报过没有"需要精确答案，交给集合和指纹表。向量检索（「Agent 怎么从一堆 Bug 报告里找到相关的那几条？」）只负责找"可能相关"的候选，最后判重要有精确规则，或者交给 Judge、人工复核。

写入：什么时候写、去重、冲突、遗忘

**什么时候写。**结构化状态由代码在每一步自动写，不靠模型自觉。自由文本笔记适合在里程碑（探索完一个模块）和会话结束前写一次交接。MemGPT 的做法是上下文用到警戒线（论文举例为窗口的 70%）时插一条"内存压力"系统消息，提醒模型把重要内容存出去。

**去重。**Bug 先算指纹再写，例如 (路由, 错误类型, 归一化后的错误信息)。只按标题文本比较，“保存失败"和"点击保存没反应"会被当成两个 Bug。

**冲突更新。**新信息和旧信息矛盾时，覆盖旧条目，记下时间和版本，不要两条并存。MemGPT 论文图 4（arXiv v2）的例子是把工作上下文里的"男友叫 James"替换成"前男友叫 James”。BugHunt 里是"Bug #12 在 v1.3 已修复"替换"Bug #12 未修复”。

**遗忘。**三种机制：

• 容量上限加淘汰策略：FIFO、LRU、随机。下面的实验会看到，选哪个取决于访问模式。
• 按时间过期：Claude memory tool 的文档建议定期删除长期没被访问的记忆文件。
• 按版本失效：应用发了新版本，“已测过"要降级成"待复测”。

读取：每轮注入、按需检索、交给模型的工具

按需检索怎么打分，一个常被引用的例子是 Generative Agents（Park 等，arXiv 2304.03442，2023）。每条记忆有三个分数：新近度（按距上次被检索的游戏小时数做指数衰减，衰减因子 0.995）、重要度（写入时让模型打 1～10 分）、相关度（嵌入的余弦相似度）。三项各自 min-max 归一化到 [0, 1] 后加权求和，论文里三个权重都取 1，按总分从高到低放进上下文，直到放不下。

Claude 的 memory tool

Claude API 提供一个由 Anthropic 定义、在客户端执行的 memory 工具。要点来自官方文档（ Memory tool ）：

• 工具定义是 {"type": "memory_20250818", "name": "memory"}。
• 客户端执行：模型只发出文件操作请求，你的代码去执行，存储放在哪（本地文件、数据库、云存储、加密文件）由你决定。
• 命令有 view、create、str_replace、insert、delete、rename，路径都在 /memories 下。
• 工具本身不需要 beta header；SDK 的辅助类（Python 的 BetaAbstractMemoryTool、BetaLocalFilesystemMemoryTool）和 tool runner 放在 beta 命名空间里。
• 请求里带了这个工具，API 会自动往 system prompt 里加一段指令，开头是 IMPORTANT: ALWAYS VIEW YOUR MEMORY DIRECTORY BEFORE DOING ANYTHING ELSE.，其中还有一句 ASSUME INTERRUPTION：上下文随时可能被重置，没写进记忆目录的进度可能丢。
• 安全由你负责：每条命令的路径都要校验，防止 /memories/../../secrets.env 这类路径穿越。

官方文档的 Python 示例（我在本地装了 anthropic 0.125.0，确认 anthropic.tools.BetaLocalFilesystemMemoryTool 和 client.beta.messages.tool_runner 都存在；没有用真实 key 跑）：

import anthropic
from anthropic.tools import BetaLocalFilesystemMemoryTool

client = anthropic.Anthropic()
memory = BetaLocalFilesystemMemoryTool(base_path="./memory")

runner = client.beta.messages.tool_runner(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Remember that customer Acme Corp prefers email follow-ups."}],
    tools=[memory],
)
final_message = runner.until_done()
print(final_message.content)

memory tool 属于"工具化"读取：读不读、写什么由模型决定。测试 Agent 里，已访问集合这种必须精确的状态，更稳妥的做法是 harness 自己维护、每轮注入。memory tool 适合存模型自己总结的经验和跨会话的交接笔记。文档也提到它可以和服务端压缩一起用：压缩让活跃上下文保持小，memory 保存必须撑过摘要的信息。

MemGPT：上下文当内存，外部存储当磁盘

MemGPT（Packer、Wooders、Lin、Fang、Patil、Stoica、Gonzalez，MemGPT: Towards LLMs as Operating Systems，arXiv 2310.08560，2023）借用操作系统的分层内存，叫"虚拟上下文管理”：

溢出时怎么办（论文 2.2 节）：提示 token 超过"警告阈值”（举例为窗口的 70%）时，队列管理器插入一条内存压力警告，让模型把重要信息存进工作上下文或 archival storage。超过"刷新阈值”（举例为 100%）时，队列管理器挤出一部分消息（举例为窗口的 50%），用旧的递归摘要和被挤出的消息生成新的递归摘要，放在队列第一条。被挤出的消息不在上下文里了，但会一直保存在 recall storage，可以用函数调用查回来。

对照 BugHunt：工作上下文放"当前任务 + 已发现 Bug 摘要”，recall storage 是完整 trace（「Agent 做错了，你怎么知道它错在哪一步？」），archival storage 放站点地图和历史 Bug 库。和单纯的压缩相比，关键区别是被挤出的原文能由模型通过函数调用查回上下文。Codex 的 rollout 日志里压缩前的原文也一条不少，但那是给人看、给 resume 用的，模型看到的只有压缩后的历史（「上下文快满了，Codex 怎么办？」）。

动手实验：有记忆到底好多少

设定

站点仿 RealWorld（Conduit）：24 个页面，每页顶部都有导航链接到首页、写文章、设置、我的主页；6 个页面藏着注入的 Bug（收藏数不刷新、分页重复、评论 XSS、编辑后标签丢失、注销没有二次确认、搜索第 2 页 500），大多在两三层深的地方。Agent 从首页出发，每一步点一个链接，算一次模型调用，预算 30 步。

三种策略：

token 按每步固定 3,000（system + 页面快照）加每条记忆 40 来估，两个数都是假设值，只用来比较相对大小。

结果

seed 1000～1199 各跑一次，记忆不限容量：

配对差值（同一个 seed，有记忆 − 无记忆）：已访问集合 +29.3 个百分点 [+27.9, +30.6]，200 次里 199 次更高；加上链接表 +45.1 [+44.0, +46.1]，200 次全部更高。区间用正态近似 mean ± 1.96·s/√n，和 10000 次配对 bootstrap 的结果相差不超过 0.1 个百分点。

只开已访问集合时覆盖率卡在 78%：邻居都去过之后它又退回随机游走，被顶部导航反复拉回首页和设置。链接表让它知道"还有哪些页面没去”，并且知道什么时候可以停。

成本：比每个 Bug，不比每步

有记忆每步多付几百 token，30 步预算下总 token 反而更高（105,359 对 90,000）。只看这个数会得出"记忆更贵"的结论。换个问法：找全 6 个 Bug 要花多少？

加链接表的记忆每步贵约 18%，找全 Bug 的总 token 却只有无记忆的约 5.8%。这个结论有条件：步数主要浪费在重复访问上。站点很小、随机走几步就能走遍时，差距会小得多。

容量有限：忘掉谁

把记忆容量限制在几条，用 FIFO、LRU、随机三种淘汰策略（“已访问集合 + 链接表"策略，覆盖率均值 %）：

容量 12 时，随机淘汰比 FIFO 高 3.8 个百分点 [+2.7, +4.8]（配对）。一个可能的解释，我没有单独验证：Agent 沿差不多固定的路线绕圈，圈比容量大时，FIFO 和 LRU 总是先忘掉最早写入或最久没用的那批，而那批往往正是接下来又要经过的，和缓存里 LRU 遇到大循环扫描时的退化类似；随机淘汰打破了这种规律。换一个站点、换一种探索策略，结论可能不同，要重新量。

这个实验说明不了什么

• **这是理想化设定，不是严格上界。**模拟假设记忆总被正确使用。真实 LLM 可能忘了读、读了不用、写错，真实差距通常更小，但方向和大小都要靠真实运行来量。
• **“无记忆"不是说 LLM 是随机游走。**这里的无记忆指上下文里没有访问记录：新会话、压缩丢了细节、历史太长没被注意到。会话内、上下文还完整时，模型本来就能看到自己走过的路。
• **同一个 seed 的配对很弱。**不同策略消耗随机数的方式不同，同一个 seed 并不意味着"同一条路”。配对几乎没有收窄区间：已访问集合的配对半宽 1.30 个百分点，不配对 1.39；加链接表是 1.08 和 1.10。区间远离 0 是因为效果大（+29 和 +45 个点），不是因为配对。

真实评测怎么设计

1. 任务集：固定的站点快照 × 起始页 × 账号状态，每个组合是一个任务，两种配置跑同一批任务。
2. 指标：探索覆盖率、重复访问率、Bug 召回、重复报 Bug 率、找全 Bug 的步数和 token、每个 Bug 的成本。
3. 配对：配对单位是任务。每个任务跑多次时，先算每个任务两种配置的平均差，再在任务上重抽 bootstrap，不要把所有运行摊平。这是「新 prompt 从 82% 涨到 86%，是真的变好了吗？」里"按用例重抽"的做法。
4. 样本量：真实效果比模拟小，要按「要跑多少次才够？」事先估算要多少个任务。
5. 消融：只开已访问集合、只开 Bug 列表、都开，分别量各自贡献多少。
6. 记忆专项用例：会话 1 探索一半中断，会话 2 能不能接着走而不重复；换一个应用版本，看"已测过"会不会被复测；在页面里放一段投毒文本，看它会不会进记忆。

代码

完整脚本只用标准库，python3 agent_memory_sim.py 约 3 秒跑完。随机数用 mulberry32，和互动演示页的 JS 逐位一致。

import math
import statistics

PAGES = [
    "首页", "登录", "注册", "设置", "写文章", "我的主页", "我的文章", "我的收藏",
    "Feed 第2页", "Feed 第3页", "标签 #qa", "标签 #agent", "文章 A", "A 的评论", "文章 B", "编辑 B",
    "文章 C", "C 的分享", "作者页", "作者的关注者", "修改密码", "注销账号", "搜索", "搜索第2页",
]
NAV = [0, 4, 3, 5]  # 每页顶部导航：首页、写文章、设置、我的主页
LOCAL = {
    0: [1, 2, 8, 10, 11, 12, 14, 22], 1: [2], 2: [1], 3: [20], 4: [14], 5: [6, 7], 6: [14, 16], 7: [12],
    8: [9, 16], 9: [8, 16], 10: [12, 14], 11: [16], 12: [13, 18], 13: [12], 14: [15, 18], 15: [14],
    16: [17, 18], 17: [16], 18: [19, 12], 19: [18], 20: [21], 21: [3], 22: [23, 12], 23: [22, 16],
}
LINKS = {p: [q for q in NAV if q != p] + [q for q in LOCAL[p] if q not in NAV] for p in range(len(PAGES))}
BUGS = {7: "收藏数不刷新", 9: "分页出现重复文章", 13: "评论 XSS", 15: "编辑后标签丢失",
        21: "注销没有二次确认", 23: "搜索第2页 500"}
N_PAGES = len(PAGES)
BUDGET = 30          # 每次运行的步数预算（每步 = 一次模型调用）
RUNS = 200           # 每种配置跑 200 次（seed = 1000 .. 1199）
SEED0 = 1000
BASE_TOKENS = 3000   # 每步的固定输入：system + 页面快照（假设值）
ENTRY_TOKENS = 40    # 每条记忆注入上下文的 token（页面名 + 链接表，假设值）
MAX_STEPS = 5000     # "找全 Bug 要几步"的上限


def mulberry32(seed):
    a = seed & 0xFFFFFFFF

    def rnd():
        nonlocal a
        a = (a + 0x6D2B79F5) & 0xFFFFFFFF
        t = ((a ^ (a >> 15)) * (a | 1)) & 0xFFFFFFFF
        t = ((t + (((t ^ (t >> 7)) * (t | 61)) & 0xFFFFFFFF)) & 0xFFFFFFFF) ^ t
        return ((t ^ (t >> 14)) & 0xFFFFFFFF) / 4294967296

    return rnd


def pick(rnd, items):
    return items[math.floor(rnd() * len(items))]


class Memory:
    """已访问集合（每条记一页和它的链接表），可以设容量和遗忘策略。dict 保持插入顺序 = 写入 / 最近使用顺序。"""

    def __init__(self, cap, policy, rnd):
        self.cap, self.policy, self.rnd, self.items = cap, policy, rnd, {}

    def write(self, page):
        if page in self.items:
            if self.policy == "lru":  # 再次访问算"用过"，挪到最新
                del self.items[page]
                self.items[page] = LINKS[page]
            return
        if self.cap is not None and len(self.items) >= self.cap:
            keys = list(self.items)
            victim = keys[math.floor(self.rnd() * len(keys))] if self.policy == "random" else keys[0]
            del self.items[victim]
        self.items[page] = LINKS[page]


def next_page(strategy, cur, mem, rnd):
    links = LINKS[cur]
    if strategy == "random":
        return pick(rnd, links)
    fresh = [q for q in links if q not in mem.items]
    if fresh:
        return pick(rnd, fresh)
    if strategy == "frontier":  # 沿记住的链接 BFS，找最近的"记忆里没有"的页面
        prev, queue = {cur: None}, [cur]
        while queue:
            p = queue.pop(0)
            if p != cur and p not in mem.items:
                while prev[p] != cur:
                    p = prev[p]
                return p
            for q in (LINKS[p] if p == cur else mem.items.get(p, [])):
                if q not in prev:
                    prev[q] = p
                    queue.append(q)
        return None  # 记得的页面都访问过了：Agent 认为探索完成，主动停
    return pick(rnd, links)


def run(strategy, seed, cap=None, policy="fifo", budget=BUDGET, until_all_bugs=False):
    rnd = mulberry32(seed)
    use_mem = strategy != "random"
    mem = Memory(cap, policy, rnd) if use_mem else None
    cur, seen, reported = 0, {0}, set()
    path, repeats, reports, tokens = [0], 0, 0, 0
    if use_mem:
        mem.write(0)
    step = 0
    while step < (MAX_STEPS if until_all_bugs else budget):
        tokens += BASE_TOKENS + (ENTRY_TOKENS * len(mem.items) if use_mem else 0)
        nxt = next_page(strategy, cur, mem, rnd)
        if nxt is None:
            break
        cur = nxt
        step += 1
        path.append(cur)
        if cur in seen:
            repeats += 1
        seen.add(cur)
        if cur in BUGS and not (use_mem and cur in reported):
            reports += 1  # 无记忆时每次路过都会再报一次
            reported.add(cur)
        if use_mem:
            mem.write(cur)
        if until_all_bugs and len(reported) == len(BUGS):
            break
    return {
        "coverage": len(seen) / N_PAGES, "repeat": repeats / max(step, 1), "bugs": len(reported),
        "reports": reports, "dups": reports - len(reported), "tokens": tokens, "steps": step, "path": path,
    }


def mean_ci(xs):
    """均值和 95% 正态近似区间（mean ± 1.96·s/√n）；互动演示页用同一个公式。"""
    m = statistics.fmean(xs)
    half = 1.96 * statistics.stdev(xs) / math.sqrt(len(xs))
    return m, m - half, m + half


def batch(strategy, cap=None, policy="fifo"):
    return [run(strategy, SEED0 + i, cap, policy) for i in range(RUNS)]


def pct(x, sign=False):
    """比例 → 百分数保留 1 位，四舍五入（0.5 进位），和互动演示页的 JS 一致。
    Python 自带的格式化是"五成双"，0.2925 会被印成 29.2，JS 的 Math.round 给 29.3。"""
    v = math.floor(x * 1000 + 1e-9 + 0.5) / 10
    return f"{v:+.1f}" if sign else f"{v:.1f}"


if __name__ == "__main__":
    res = {s: batch(s) for s in ("random", "visited", "frontier")}
    for s in ("visited", "frontier"):
        d = [a["coverage"] - b["coverage"] for a, b in zip(res[s], res["random"])]
        m, lo, hi = mean_ci(d)
        print(f"{s:9} − random 覆盖率差 {pct(m, True)} 个百分点 [{pct(lo, True)}, {pct(hi, True)}]")

上面是精简版；完整脚本还打印了表格里的其余数字（bootstrap 对照、找全 Bug 的步数、容量扫描）。精简版的输出：

visited   − random 覆盖率差 +29.3 个百分点 [+27.9, +30.6]
frontier  − random 覆盖率差 +45.1 个百分点 [+44.0, +46.1]

记忆带来的三个风险

记忆投毒不是假想。AgentPoison（Chen、Xiang、Xiao、Song、Li，arXiv 2407.12784，2024）对带长期记忆或 RAG 知识库的 Agent 做后门攻击，摘要报告：投毒比例低于 0.1%，查询里带攻击者优化的触发词时，平均攻击成功率超过 80%，对正常输入的影响不到 1%。注意它的威胁模型是攻击者直接往记忆或知识库里注入样本，和上面 BugHunt 的例子（Agent 自己把页面文本写进记忆）不是一回事，后者是投毒的另一条入口。和一次性的 prompt injection 相比，投毒进记忆的内容会在以后每个会话里生效。第 8 周讲间接 prompt injection 时还会回到这里。

隐私这一条，Claude memory tool 的文档说 Claude 通常会拒绝把敏感信息写进记忆文件，同时建议想要更强的保证就在 handler 写文件前做校验、剥掉敏感数据。模型"通常拒绝"不能当成测试通过的依据，脱敏要在你的代码里做，并且有用例覆盖。

测开视角：记忆怎么测

这些都可以用脚本化的假模型确定地跑，不需要真实模型，和「不调真实模型，怎么测一个 Agent？」的思路一样。效果类的问题（有记忆覆盖率高多少）才需要真实运行和区间。

常见错误说法

• “有了向量库就有了记忆”：向量检索只是读取方式之一。判重、已访问这类要精确答案的状态应该结构化。
• “加记忆每步更贵，所以成本更高”：要比每个找到的 Bug 的成本。这个站点上找全 6 个 Bug，加链接表的记忆只花了无记忆约 5.8% 的 token。
• “上下文窗口够大，就不需要记忆”：窗口在会话结束时就没了；每轮重发全部历史，token 和轮数平方增长；Liu 等人的 “Lost in the Middle”（arXiv 2307.03172）发现，相关信息放在长上下文中间时，模型的表现明显差于放在开头或结尾。
• “压缩就是长期记忆”：压缩是有损摘要，只服务于这一条会话线程。Codex 会把压缩结果写进 rollout，resume 时能恢复，原文也留在 rollout 日志里，但模型看到的只有压缩后的历史，新会话也读不到。MemGPT 的区别是被挤出的消息能通过函数调用从 recall storage 检索回上下文。
• “LRU 总比 FIFO、随机好”：淘汰策略的好坏取决于访问模式。这个站点上，容量 12 时随机淘汰比 FIFO 高 3.8 个百分点。
• “模拟里有记忆好 45 个点，真实 Agent 也会好这么多”：模拟是理想化设定（假设记忆总被正确使用），不是严格上界；真实差距通常更小，但方向和大小都要用真实运行、按任务配对来量。

这一周到这里结束。下一周进入长任务可靠性：任务跑到一半挂了，怎么从断点恢复。