主题深度对比：记忆系统（Memory System）

"LLM 是无状态函数，agent 却必须有命脉。记忆是把 stateless function 缝成 stateful organism 的针线。"

10 家 agent 框架横向对比。聚焦"长记性 / 持久化 / 工程文件"三件事，跟主题 1（上下文工程）的"压缩算法 / Prompt 拼装"明确划清边界 —— 本主题只关心压缩之后存到哪、怎么找回来、谁负责写。

先验阅读：每家 4-5 章正文（位置见首章 grep 速查），以及 agent-architectures-comparison.md 第 6 节（行 409-473）。

#零、为什么"记忆"是 agent 的护城河

LLM 推理是无状态函数 f(prompt) → text。同一个 prompt 进去，不同时间出来的结果只受温度和模型版本影响。

但 agent 是 长生命周期 的：

用户上周说过的偏好，今天还要记得
项目里的 build 命令，每次进来不能让用户重写一遍
agent 跑了 3 小时、烧了 200K tokens 才学会的项目惯例，重启后不能从零再学
多人协作时，团队规则要能跨人共享

所以 agent runtime 的核心工作之一，就是 在 LLM 之外维护一份"它该记住的东西"，并在每次调用前把对的那部分塞回 LLM context。

记忆不是数据库，是一种"再读一次"的协议。这个协议要回答四个问题：

存在哪：DB / SQLite / markdown 文件 / event log / state schema
由谁写：人 / LLM 自己 / 子代理代为
何时读：每轮自动 inject / agent 主动查 / 关键词触发 / @ 引用拉
多大粒度幸存：压缩到多小、丢哪些、保哪些

10 家给出了 10 套不同答卷。

#一、10 家速览大表

家	短期	压缩态存档	长期消息	向量库	图谱	用户画像	程序性记忆	工程文件
OpenClaw	`session.jsonl`	`compaction-notifier` hook + `session:compact` 流程	append-only jsonl + 可选 lancedb	可选 lancedb（`memory_recall`）	无	无	`MEMORY.md` + `memory/YYYY-MM-DD-HHMM-<slug>.md` 日记	`IDENTITY.md` / `SOUL.md` / `AGENTS.md` / `TOOLS.md`（+ 可选 `DREAMS.md` / `BOOT.md`）
Hermes	messages 数组	ContextCompressor 50%	SQLite + FTS5	8 家 provider 可插	无	Honcho dialectic	`MEMORY.md` + `SKILL.md`（agent 自写）	同左
Claude Code	session 数组	auto-compact + skill re-attach	session JSONL	取决于 MCP	无	auto memory 系统	`CLAUDE.md` + auto memory（用户 / 反馈 / 项目 / 引用 4 类）	`CLAUDE.md` 4 scope（managed / project / user / local）
Codex	turn 序列	server-side `encrypted_content`	session SQLite + resume / fork	无	无	无	无（明确禁止 LLM 写）	`AGENTS.md`（含嵌套目录覆盖 + `.override.md`）
Cursor	chat ctx	rules 按需召回	项目级	Turbopuffer（Merkle + simhash）	无	Memories（自学）	`.cursor/rules/*.mdc`	`.cursor/rules/` + `AGENTS.md` 兼容
Cline	当前 task	`/smol` + `/newtask`	影子 git per-step commit	无原生	无	无	`.clinerules/`	`.clinerules/`
OpenHands	EventStream 内存	Condenser（保前 K + LLM 总结）	event log（可 replay）	无原生（Cloud 可挂）	无	无	`.openhands/microagents/` repo / knowledge / task	同左
AutoGen	model_context (BufferedChatCompletionContext 等)	用户自决	save_state / load_state（dump 成 dict）	ChromaDBVectorMemory	无	Memory protocol（`update_context`）	system_message	无
LangGraph	state schema	用户在 reducer 决	Checkpointer（Postgres / Sqlite / Redis）	✗ 接 LangChain	无	Store API（namespace 长期）	state 字段	无

两条对角线：

静态（人写）↔ 自进化（LLM 写）：Codex / Cline / OpenHands ←→ Hermes / Cursor / Claude Code auto memory

#二、记忆载体的 5 种哲学

"哲学不在 README，在 schema。"

主流派系归纳后 = 5 大类（下面 §2.1-§2.5 各展开一节），但"工程文件即记忆"内部又能按"谁写 / 是否可被 LLM 改 / 是否带影子 git"细分出 4 个子流派：

派系 (5 大类)                                  | 子流派 / 代表家
─────────────────────────────────────────────|──────────────────────────────────────────
2. 全 markdown（文件 + 日记）                   | OpenClaw
3. SQLite + markdown（折中）                    | Hermes
4. 工程文件即记忆                                | 4 个子流派：
   ├─ 工程文件 + auto memory（LLM 受控自写）   | Claude Code
   ├─ 工程文件，明确禁 LLM 写                   | Codex
   ├─ 工程文件 + 自学用户画像                   | Cursor (Rules + Memories)
   └─ 工程文件 + 影子 git per-step              | Cline
                                              | OpenHands 也归此类（.openhands/microagents/repo.md，人写）
5. state schema + event log（程序员视角）       | LangGraph (state + Checkpointer + Store)
                                              | OpenHands (EventStream replay)
                                              | AutoGen (Memory protocol + save_state, 偏插件式)

MySQL (tps_agent_messages 全量历史，按 (project_id, turn_id) 索引) + Milvus（向量召回） + Neo4j（凭证血缘 + 实体图谱）。

特点：

企业级可治理 —— 多用户、有审计、有备份
LLM 主动查 memory_graph 工具入口（preload 5 件套之一，每次都看得到）
压缩不是丢历史 —— 原始消息仍在 MySQL，LLM 想看走 memory_graph_query 等工具
沙箱内还挂了一份 /workspace/.memory_maintainer/memory_maintainer.md（项目级长期笔记），每 turn 重读

代价：所有读写都过网络/服务端，单机部署不友好。

#2.2 全 markdown（OpenClaw）

MEMORY.md（永久事实）+ memory/YYYY-MM-DD.md（按天分桩日记）+ session.jsonl（滚动 transcript）。

"你的记忆不进任何外部数据库、永远在 workspace 目录里、可以直接 cat 出来读、可以 git 起来。" —— openclaw-agent-architecture.md 行 669-671

代价：搜索靠 grep（无原生向量），多机协作靠 git。

#2.3 SQLite + markdown（Hermes）

折中方案：会话 / session lineage / FTS5 全文索引走 ~/.hermes/state.db，但程序性记忆和用户偏好用 markdown 文件 + Honcho。

SessionDB 写入纪律严苛（来自 hermes-agent-architecture.md 行 628-635）：

- short SQLite timeout（1 second）
- application-level retry with random jitter（20-150ms, up to 15 retries）
- BEGIN IMMEDIATE transactions
- periodic WAL checkpoints every 50 successful writes

→ 单进程并发的标准答案。

#2.4 工程文件即记忆（Claude Code / Codex / Cursor / Cline / OpenClaw / OpenHands）

这是 2025-2026 年最大的趋势（独立成第三章详述）：

把 "agent 应该记住什么" 直接放进项目根目录的 markdown 文件，跟代码一起进 git。LLM 每次调用前自动 inject 到 system prompt。

7 家不同程度兼容这一形态。

#2.5 state schema + event log（LangGraph / OpenHands）

最程序员视角的两家：

LangGraph：state 是 TypedDict，里面塞 messages / plan / files / 任何字段。每个 superstep 末尾 checkpointer 全量持久化到 Postgres / SQLite / Redis。"记忆 = state 的某些字段"。
OpenHands：EventStream 是 ordered event log。state 是 derived value，从 event log replay 出来。controller/replay.py 可以从任意 event_id 起跑。

两者都把"记忆"做成 可程序化、可分叉、可审计 的数据结构，但代价是用户必须懂 schema 设计。

#三、工程文件即记忆 ——「AGENTS.md」事实标准的兴起

"开放生态对私有 memory 后台的胜利。" —— agent-architectures-comparison.md 行 472

#3.1 兼容矩阵

家	推荐文件名	agents.md 官方支持	兼容方式	兼容 `CLAUDE.md`
Codex	`AGENTS.md`	✓（OpenAI 是发起方）	原生加载 + `AGENTS.override.md` 强制覆盖 + 嵌套目录	✗（未原生支持）
Cursor	`.cursor/rules/*.mdc`	✓	与 rules 并存读取	部分（仅作为普通文件）
Claude Code	`CLAUDE.md`	✗（仅 CLAUDE.md）	官方建议在 `CLAUDE.md` 中 `@AGENTS.md` 引入或建符号链接；`/init` 会读 `AGENTS.md` 内容并合入新 `CLAUDE.md`	✓（原生）
OpenClaw	`AGENTS.md`	✗（未列入官方名单，使用自家含义）	把 `AGENTS.md` 用作多 agent 协作根规则；支持 `CLAUDE.md` 同名 sibling 软链	✓（同名 sibling 软链）
Cline	`.clinerules/`	✗（未列入官方名单）	用户可以手动把 `AGENTS.md` 路径放进 `.clinerules/` 引用	✗
OpenHands	`.openhands/microagents/repo.md`	✗（未列入官方名单）	repo microagent 是自家约定	✗
Hermes	`MEMORY.md` + `SKILL.md`	✗（自家协议）	不读 AGENTS.md	✗
AutoGen	system_message（代码内字符串）	✗	无文件协议	✗
LangGraph	state 字段（代码内）	✗	无文件协议	✗

数据来源：agents.md 官方支持名单 + 各家官方文档。

总结：

agents.md 官方"支持" 的，10 家里只有 Codex + Cursor 两家（agents.md 官方名单包含 OpenAI Codex、Cursor、GitHub Copilot、Devin、Windsurf、Aider、Zed、Warp 等 20+ 工具，但本次对比的 10 家里只覆盖到这两家）
以"工程文件即记忆"为指令载体 的，10 家里有 6 家（上表前 6 行）：编程类 agent 几乎都把项目根目录的 markdown 文件作为 LLM 必读的"项目说明书"
这不是巧合：从 2025 年开始 OpenAI / Cursor 等公司有意推动开放标准；Anthropic 则保留 CLAUDE.md，但通过 @AGENTS.md import 单向兼容

#3.2 多 scope 合并是统一语法

四层是常态：

最高优先级
├── managed（macOS /Library/Application Support/ClaudeCode/CLAUDE.md，
│             Linux /etc/claude-code/CLAUDE.md，企业 MDM 下发）
├── project（<repo>/CLAUDE.md，进 git，团队共享）
├── user（~/.claude/CLAUDE.md，跟当前用户走）
└── local（<repo>/CLAUDE.local.md，gitignore，仅当前 worktree）
最低优先级

Codex 多了一个嵌套目录级：<git_root>/services/foo/AGENTS.md 离 cwd 越近权重越高，外加 .override.md 强制覆盖。

→ codex-agent-architecture.md 行 168-178。

#3.3 LLM 能不能改自己的工程文件？

家	LLM 自写	备注
Hermes	✓ 完全自写	5+ tool_call 后自动造 `SKILL.md`；用错时 patch 修复；`MEMORY.md` curate；可被 Atropos 反哺训练
Cursor Memories	✓ 隐式	模型从对话学，存 Cursor 后端，UI 可审 / 可删
Claude Code auto memory	✓ 受控	`~/.claude/projects/<x>/memory/MEMORY.md` agent 自己写；`autoMemoryEnabled: false` 可关；`autoMemoryDirectory` 不可在 project settings 里改（防 supply chain）
OpenClaw	部分（`session-memory` hook）	压缩前隐藏一次"silent agentic turn"挑事实写入 `MEMORY.md`
Cline	✗	`.clinerules/` 完全人维护
OpenHands	✗	`.openhands/microagents/` 完全人维护
Codex	✗ 明确禁止	`/init` 只在没文件时生成骨架，之后绝不偷塞 —— 这是 OpenAI 与 ChatGPT memory 截然不同的产品决策
Cursor Rules	✗	`.cursor/rules/*.mdc` 人写

Hermes 是独此一家"完全自进化"（详见第六章）。

#3.4 OpenClaw 的"五件套"是最完整的工程文件人格

单架构文档里也称"四类描述文件"（IDENTITY / SOUL / AGENTS / TOOLS），把 MEMORY.md 单独归入第五章。本对比文档把 MEMORY.md 一起列上，强调"5 个 markdown 文件拼出 agent 人格 + 记忆"是一体的设计。

workspace/
├── IDENTITY.md  ← 名字 / emoji / avatar / theme （工牌）
├── SOUL.md      ← 人格 / 价值观 / 语气 / 拒绝什么（角色设定本，可在 ClawHub 交易）
├── AGENTS.md    ← 多 agent 协作根规则（员工手册）
├── TOOLS.md     ← 工具白名单 / 用法（钥匙板）
└── MEMORY.md    ← 长期记忆（人事档案）

"某 agent 是怎样的人： workspace/SOUL.md + IDENTITY.md 某 agent 记得啥： workspace/MEMORY.md + memory/YYYY-MM-DD.md" —— openclaw-agent-architecture.md 行 184-185

把 "agent identity" 拆成 5 个 markdown 文件这种激进做法，10 家里只有 OpenClaw。

#四、记忆召回的 10 种方式

"压缩好 vs 召回好，是 agent runtime 的两个方向盘。"

按"谁触发 / 何时触发 / 召回什么"梳理。10 家覆盖到 10 种不同机制（部分有重叠，比如 Cline 与 Cursor 的 @ 引用同源）：

[ 主 LLM 调用前 ]
        │
        │       LLM 看到 preload 的 memory tool，自己决定要不要调
        │
        ├── 2. 隐藏子代理前置抢跑（OpenClaw Active Memory）
        │       Gateway 收到 user message → 起一个临时 sub-agent
        │       专门跑 memory_search / memory_get → summary 注进 system 段
        │       好处：用户感受不到延迟；坏处：多一次 LLM 开销 + 不可解释
        │
        ├── 3. 确定性 prefetch（Hermes memory_manager.prefetch）
        │       每个 sync_turn 之前 prefetch() 拉相关旧 session 摘要 +
        │       Honcho user model 当前段，注进 system
        │
        ├── 4. 自动注入（Claude Code auto memory）
        │       启动时 MEMORY.md 前 200 行 / 25KB 进 ctx
        │       超出部分启动时不加载；topic 文件 on-demand
        │       压缩时 project root CLAUDE.md 会被 re-inject
        │
        ├── 5. 工程文件每轮拼到 system prompt（Codex AGENTS.md）
        │       turn 开始时按 user / project / 嵌套目录 / cwd 顺序
        │       merge AGENTS.md，32 KiB 上限
        │
        ├── 6. Rules 多模式触发（Cursor 4 档）
        │       Always       —— alwaysApply: true，每次注入
        │       Auto-Attached —— globs 命中文件时注入
        │       Agent-Requested —— description 进候选区，agent 自己决定要不要
        │       Manual        —— 用户 @rule-name 才加载
        │
        ├── 7. @ 引用语法（Cline @file/@folder/@problems/@terminal/@git/@url）
        │       展开后**直接拼进 user message**，不经过 retriever / 向量
        │
        ├── 8. Microagents triggers（OpenHands 关键词触发性）
        │       user message 命中 frontmatter triggers → RecallAction
        │       → Memory.recall → RecallObservation → 下轮 inject system
        │
        ├── 9. Memory protocol（AutoGen 用户自接）
        │       update_context(model_context) → SystemMessage append
        │       内置 ListMemory / ChromaDBVectorMemory
        │
        └── 10. Store API namespace（LangGraph 长期）
                store.put(("user", uid, "memories"), ...) / search()
                @tool 里走 InjectedStore，LLM 看不到，ToolNode 注入

Cursor 的 4 档 rules 触发是最精细的"按需召回"机制，因为 .cursor/rules/ 能塞 50+ 文件，硬塞会爆 ctx —— 必须分级。

→ cursor-agent-architecture.md 行 116-122。

#五、记忆持久化的取舍光谱

"持久化方式决定了 agent 出事时的可恢复性。"

最重 ───────────────────────────────────────────────────────────────────── 最轻

MySQL + Milvus      SQLite + FTS5 +     session SQLite    影子 git         append-only    用户自选 backend
+ Neo4j +           WAL checkpoint      + resume/fork     per-step commit  session.jsonl  (memsaver/sqlite/pg/redis)
Kafka 异步                              + server-side                      + markdown
                                        encrypted_content                  日记分桩

按 (project_id, turn_id) 分轮，完整、可回溯、压缩源头。这是企业级"绝不丢历史"的兜底。

#5.2 SQLite + FTS5 + WAL checkpoint（Hermes）

单进程友好，FTS5 让"按词搜历史"秒级。代价是写并发要靠 retry，多用户场景换底（mem0 / supermemory）。

#5.3 影子 git per-step commit（Cline checkpoint）

最巧妙的做法：每次工具执行完，Cline 把 workspace 当前状态 commit 到一个与项目 git 完全隔离的影子仓库。

特点：
- 不污染 .git
- 包括未追踪文件（甚至 .gitignore 里的）
- UI 三种粒度回滚：
  - Restore Files Only：撤代码改动，留对话
  - Restore Task Only：删后续对话，文件不动
  - Restore Files & Task：两个都撤

"这是 Cline 区别于 Cursor / Claude Code 的核心安全网 —— 让 YOLO 模式有底气。" —— cline-agent-architecture.md 行 451-452

#5.4 session 持久化（Codex resume/fork）

session 状态存本地 SQLite（sqlite_home / CODEX_SQLITE_HOME）：

命令	行为
`codex resume`	列最近 session，挑一个继续
`codex fork`	当前 session 当 parent 拷一份新分支
`/new`	同进程内开新对话
`/side`	临时开"小窗口"问简短问题（fresh ctx），不污染主线

加上 server-side encrypted_content —— compact 后的"压缩态" 实质是 LLM KV state 的加密引用，存在 OpenAI 后端，CLI 只持有 reference。代价：不可导出 / 不可迁移到别 provider。

#5.5 Checkpointer 多种（LangGraph）

MemorySaver       —— demo / 单测
SqliteSaver       —— 单机 agent / Discord bot
PostgresSaver     —— 生产 / Platform 默认
RedisSaver / DynamoDB —— 已有集群想复用

每个 superstep 末尾全量写入：

checkpoint = {
    thread_id, checkpoint_id, parent_checkpoint_id,
    channel_values: {messages: [...], plan: "..."},
    channel_versions: {...},   # 版本号决定下个 superstep 哪些节点要跑
    pending_sends: [...],
    pending_writes: [...],
    interrupts: [...],
}

→ langgraph-agent-architecture.md 行 681-697。

#5.6 JSONL transcript（OpenClaw / Claude Code）

最朴素的方案：append-only session.jsonl，每行一条 event。

优势：grep 友好，不需要 schema migration、不用启动数据库
劣势：全表扫描，无索引，单文件随时间增长
OpenClaw：workspace/sessions/<id>.jsonl，配 memory/YYYY-MM-DD.md 日记 + MEMORY.md 永久事实分桩
Claude Code：~/.claude/projects/<repo-id>/sessions/*.jsonl，靠 --resume 加载某条 session 重启

#六、自进化记忆：从静态到动态

"模型公司做 agent 的天然优势：让 agent 学会的事，反哺训练。"

#6.1 Hermes：闭环最完整的一家

agent 跑任务
    │
    ├── 5+ tool_call 后 → 自动造 SKILL.md（"我学到了一个新本事"）
    │       skills/ 目录里多一个文件夹
    │
    ├── 用错时 → patch SKILL.md（"上次我把这个搞错了"）
    │       skill self-improvement，文档原话
    │
    ├── 关键事实 → curate MEMORY.md（"以后还要用这个事实"）
    │       agent-curated facts written with periodic auto-curation
    │
    └── 反哺训练（独家）
            Atropos（强化学习训练栈）+ DisTrO 把
            curated MEMORY.md / SKILL.md 当训练数据
            下个版本的 Hermes 模型 baseline 就更聪明

→ hermes-agent-architecture.md 行 158-175。

"MEMORY.md 和 SKILL.md 都是普通 markdown 文件。Agent 学到的东西不是埋在向量库里、不是塞 LLM weight 里，是写在文件里 —— 你能读、能改、能 git。"

#6.2 Cursor Memories：用户偏好的隐式累积

2025 年上线的"第一个真正记忆产品"。

维度	Cursor Rules	Cursor Memories
谁写	用户	模型
触发	确定性（4 档）	agent 自动召回
存哪	文件（进 git）	Cursor 后端（跟账号走）
跨设备	进 git 跟代码	跟账号
可审	直接读文件	UI 列表里看
失效	删文件	单条删除

社区共识："关键约定写 rules，琐碎偏好留 memories"。

#6.3 Claude Code auto memory：四类受控自学

v2.1.59 起默认开。

~/.claude/projects/<git-repo-derived-id>/memory/
├── MEMORY.md          ← 索引；前 200 行 / 25KB 入 ctx
├── debugging.md       ← topic 文件，用时才读
├── api-conventions.md
└── ...

四类 auto memory：

user memory —— 用户行为偏好
feedback memory —— 用户对 agent 输出的纠正
project memory —— 项目惯例（build 命令 / lint 风格）
reference memory —— 频繁查阅的文档片段

关键限制：

200 行 / 25KB 入 ctx 上限，超出启动不加载
topic 文件不在启动时加载，模型用 Read 按需取
autoMemoryDirectory 不可在 project settings 里改（防 supply chain）

→ claude-code-agent-architecture.md 行 630-644。

#6.4 OpenClaw：用户主动 `/new`/`/reset` 时抢救一次

OpenClaw 的 session-memory bundled hook 在每次 /new 或 /reset 时跑一次 silent agentic turn，专门挑出"哪些事实值得长期记"，写到 MEMORY.md / memory/YYYY-MM-DD-HHMM-<slug>.md。

用户输入 /new 或 /reset
    ↓
Gateway 触发 hook: command:new / command:reset
    ↓
session-memory hook 启动一次 "silent agentic turn"
    ↓ 读最近 ~15 轮 user/assistant 消息
    ↓ 让 LLM 生成 slug + 提取关键事实
    ↓ append 到：
      ├─ MEMORY.md（永久事实）
      └─ memory/YYYY-MM-DD-HHMM-<slug>.md（当天发生的）
    ↓
真正的 session 重置 / 新会话开启

触发时机变更：早期版本 session-memory 挂在 session:compact:before（"在 compact 之前抢救一次"），当前版本挂在 command:new / command:reset —— 从"隐式抢救"切到"显式触发"。compaction 本身由 compaction-notifier hook 单独处理，不再绑定 memory flush。

这是从 issue #56072（"Daily session reset silently discards context without memory flush"）里逼出来的设计：早期版本 daily reset 不走 flush，导致用户起床发现 agent 把昨晚说的事全忘了。后续拆出独立 session-memory hook 并改绑 command:new/reset，把"忘事"问题从"框架行为漏洞"转成"用户行为契约"。

#6.5 反例：Codex 明确不让 LLM 写

"Codex 不会偷偷往 AGENTS.md 里塞东西。" —— codex-agent-architecture.md 行 524

OpenAI 在 Codex 上的产品决策 跟自家 ChatGPT memory 截然相反：编程 agent 默认不要"猜你的偏好"，要"读你写下来的规则"。开发者用工程文件 + git review 替代隐式 memory。

#七、用户画像独立成层 —— Honcho 独家创新

"知识图谱抽象的是「项目 / 实体 / 凭证」（任务侧），Honcho 抽象的是「用户这个人」（关系侧）。"

10 家里 只有 Hermes 把"用户人设"做成独立的记忆 provider：

传统记忆层：消息 / 事实 / 知识  ←  agent 任务侧
Honcho（关系侧）：              ←  用户这个人

每次对话后让一个辅助模型反思：
   "用户是个什么样的人？他偏好什么？目标是什么？"
逐步累积成 user model。

下一轮 prefetch 时把当前最相关的人物画像段塞回 system prompt。

为什么独立成层？

任务侧记忆是项目维度的（这个项目用 pnpm，那个项目用 npm）
画像是用户维度的（wangkang 偏好简洁、不喜欢解释术语）
多用户场景下复用：换一个用户就换一份 Honcho user model

→ hermes-agent-architecture.md 行 666-676。

对比：

Cursor Memories 也算用户偏好，但混在项目级，不是独立的"人物建模"
Claude Code user memory 类似，但没有反思式建模，只是"agent 觉得这条以后还用得上"
其他家都没做

#八、time travel / replay / session lineage 对照

"调试 agent 的杀手锏。任何一个超步都能重放，能改 state 再走 —— 比 print + 复现快十倍。"

#8.1 三种"回到过去"的能力

家	机制	粒度
Hermes	session lineage（`/new` / `/fork` 不丢历史，新 session 节点 `parent_session_id` 指回去；FTS5 沿 lineage 检索）	session 树
LangGraph	time travel：`get_state_history()` 列所有 checkpoint，挑一个老 cp 改 state 再 invoke	superstep
OpenHands	deterministic replay：`controller/replay.py` 从任意 `event_id` 起跑	event
Cline	影子 git checkpoint：每个 step 一次 commit，三种粒度 Restore	step
Codex	resume / fork：从某个 session 拷分支	session

#8.2 Hermes session lineage 示意

session A (root)
   │
   │  /new  →  session B (parent_session_id=A)
   │            │
   │            │  /fork →  session C (parent=B)
   │
   │  /reset →  session D (parent=A)

任何 /new / /reset 不是丢历史，而是开一个新 session 节点，链路指回去。跨 session 检索时 FTS5 沿着 lineage 走能恢复"我们上次聊到哪了"。

#8.3 LangGraph time travel 示例

# 拿历史 checkpoint
history = list(app.get_state_history(config))
old_cp = history[3]
new_config = {"configurable": {
    "thread_id": "...",
    "checkpoint_id": old_cp.config["configurable"]["checkpoint_id"]
}}

# 从老 checkpoint 接着跑
app.invoke(None, new_config)

# 或改 state 再跑（探索"如果当初我做了不同选择"）
app.update_state(new_config, {"plan": "...new plan..."})
app.invoke(None, new_config)

这跟 OpenHands 的 event replay 在哲学上是一致的：state 是 derived value，可以从历史任意点重算。

#九、最值得抄走的 5 个记忆系统设计

排序按"工程化复杂度 vs 收益"。

#9.1 OpenClaw 的 Active Memory 子代理（隐藏前置抢跑）

收益：用户感受不到延迟，主 agent 永远拿到最相关的记忆段。实现：Gateway 收 user message → 起临时 sub-agent，只给它 memory_search / memory_get 工具 → summary 拼到 system 段 → 主 agent 才正式 infer。适用：有清晰 Gateway 层、且能多花一次 LLM 调用预算的 runtime。

→ openclaw-agent-architecture.md 行 706-744。

#9.2 Cline 的影子 git checkpoint

收益：YOLO 模式有底气，三种粒度 restore 是用户体验天花板。实现：每次工具执行完，commit 到独立的影子仓库（不污染 .git、含 untracked、含 gitignored）。适用：本地编程 agent，文件系统是主战场。

#9.3 Hermes 的 SessionDB 写入纪律 + FTS5

收益：单进程多 gateway 并发写 SQLite 不爆，全文检索秒级。 抄走清单：

- short timeout（1s）
- random jitter retry（20-150ms × 15）
- BEGIN IMMEDIATE
- WAL checkpoint every 50 writes
+ FTS5 virtual table，session lineage column 一起索引

适用：所有"想用 SQLite 但担心并发"的项目。

#9.4 LangGraph 的 Store API namespace

收益：跨 thread / 跨 agent 的长期记忆有了规范化接口。关键：

namespace 是 tuple（("user", uid, "memories")）—— 层级语义随便切
可选向量索引（pgvector）
InjectedStore 让 tool 直接拿到 store，LLM 看不到注入细节

@tool
def remember(fact: str, config: RunnableConfig, store: Annotated[BaseStore, InjectedStore]):
    user_id = config["configurable"]["user_id"]
    store.put(("user", user_id, "facts"), key=fact[:32], value={"content": fact})

适用：任何"消息历史 vs 跨会话事实"需要分开管的 agent。

#9.5 Hermes 的 Honcho 用户画像独立 provider

收益：用户人设独立成层，多用户场景换 user model 就行。 核心思想：每次对话后用辅助模型反思 "用户是什么样的人？"，逐步累积。这是"反向画像"——不是用户告诉你他是谁，是 agent 自己学。适用：长生命周期、多用户、需要个性化语气的产品。

#十、趋势观察 + 一句话各家总结

#10.1 三个清晰趋势

"工程文件即记忆" 已经是事实标准。10 家里 6 家把项目根目录的 markdown（AGENTS.md / CLAUDE.md / .cursor/rules / .clinerules / .openhands/microagents / OpenClaw 五件套）当作 LLM 必读的"项目说明书"。其中 agents.md 这个开放标准目前官方收录了 20+ 工具（含本对比中的 Codex / Cursor），Anthropic 走 CLAUDE.md、但用 @AGENTS.md import 单向兼容。这是开放生态对私有 memory 后台的胜利。
记忆从单体 vector DB 退潮，分层 + 多 backend 进场。早期"全部塞 Pinecone"的做法被淘汰，现在主流是：短期 messages 数组 + 中期压缩 + 长期分多种存储（消息历史 / 向量 / 用户画像 / 程序性 / 工程文件），每种性质找对应专长的存储。Hermes 的 8 家 MemoryProvider 是这个思路的极致。
自进化记忆开始拉开差距。模型公司（Hermes / Anthropic auto memory / Cursor Memories）在做"让 agent 自己学"，而开发者工具公司（Codex / Cline / OpenHands）则坚守"人写规则、git review"的保守派。这是产品形态决定记忆哲学——编程 agent 要确定性，对话 agent 要个性化。

#10.2 一句话各家总结

家	一句话
OpenClaw	全 markdown 哲学到极致，5 个工程文件拼出 agent 人格
Hermes	SQLite + FTS5 + Honcho + agent 自写 SKILL.md，自进化闭环最完整
Claude Code	五层记忆的工程化典范，CLAUDE.md 4 scope + auto memory 4 类
Codex	唯一明确禁止 LLM 写记忆的家，AGENTS.md 嵌套覆盖 + server-side 加密 compaction
Cursor	Memories + Rules 4 档触发，Turbopuffer + Merkle tree + simhash 是工程美学
Cline	影子 git checkpoint 是 YOLO 模式的安全网，@ 引用六类是用户控的 context 注入
OpenHands	EventStream 即记忆，deterministic replay 把 agent 调试拉到新维度
AutoGen	Memory protocol 抽象 + save_state，框架不假设你的记忆栈
LangGraph	state schema + checkpointer + Store API 三层正交，time travel 是杀手锏

#附：阅读地图

想看	去哪
OpenClaw Active Memory 子代理机制	`openclaw-agent-architecture.md` 第 5.3 节（行 706-744）
Hermes SessionDB + Honcho + 自进化	`hermes-agent-architecture.md` 第 5 章（行 584-688）
Claude Code 五层记忆 + auto memory	`claude-code-agent-architecture.md` 第 5 章（行 575-689）
Codex AGENTS.md 嵌套 + encrypted_content	`codex-agent-architecture.md` 第 5 章（行 495-555）
Cursor Rules 4 档触发 + Memories	`cursor-agent-architecture.md` 第 5 章（行 470-552）
Cline 影子 git checkpoint + @ 引用	`cline-agent-architecture.md` 第 5 章（行 389-486）
OpenHands EventStream + Condenser + Microagents	`openhands-agent-architecture.md` 第 5 章（行 603-741）
AutoGen Memory protocol + save_state	`autogen-agent-architecture.md` 第 5 章（行 663-756）
LangGraph state + Checkpointer + Store + time travel	`langgraph-agent-architecture.md` 第 5 章（行 645-759）
横向对照表（所有家）+ 程序性记忆表	`agent-architectures-comparison.md` 第 6 节（行 409-473）

写于 2026-04-25。10 家答卷里最有意思的一个发现是：真正决定 agent 长记性强弱的，不是它用了多 fancy 的向量库，而是「谁在维护那份 markdown」—— 是人、是 LLM、还是它们的合作。