标签归档:Agent

聊下 OpenClaw 的记忆系统

OpenClaw 是最近 AI 圈最火的一个开源项目,没有之一。

从去年的 Agent 年,到今年的 AI 个人助理,OpenClaw 和去年 Manus 一样的,爆到不行,而且还是开源的版本。

由于最近自己也在做 Agent,于是也看了 OpenClaw 的代码来了解其记忆系统的实现。有一些觉得可以借鉴学习的地方。

OpenClaw 的记忆系统其实比较简单:它把「记忆」拆成了文件索引召回注入

1. 「Agent 记忆系统」的定义

在 Agent 工程里,记忆是一套能力组合:

  1. 持久化:跨会话保存事实、偏好、决策、未完成事项。
  2. 可检索:能在需要时把相关片段拉出来,且可控预算。
  3. 可注入:把召回结果以确定的结构进入模型上下文,不靠「它自己想起来」。
  4. 可审计:出了错能定位「写入发生在什么时候」「召回命中了什么」「注入了哪些行」。
  5. 可治理:能处理泄露风险、过期信息、重复信息、冲突信息。

OpenClaw 的实现路径非常「工程」:Markdown 作为事实源SQLite 作为检索索引toolResult 作为注入通道

2. OpenClaw 的三层记忆

OpenClaw 的记忆从存储逻辑上来看可以分为三层:

2.1 会话记忆

  • 介质:内存为主,但 OpenClaw 会把 session 打印成类似日志的文件,放到 sessions 目录。
  • 内容:用户消息、OpenClaw 的思考过程、工具调用、skill 调用、最终回复。
  • 边界:会话结束后「可用性」就不可靠了。你能在文件里回放,但模型下一次对话并不会天然带着它。

会话记忆更像「trace」。我们不能指望它解决跨会话连续性,只用它做排障、复盘、抽取素材(写入短期/长期)。

2.2 短期记忆

  • 介质:磁盘,memory/YYYY-MM-DD.md 为主(参考内容给了例子 2026-03-10.md)。
  • 内容:当天重要事件、过程笔记、TODO。关键点是「重要性」由人设与调教决定。
  • 边界:短期记忆是追加式日志,质量会漂移。写得越多,噪声越大;但写得太少,又召回不到。

短期记忆适合承接「会话压缩之前的落盘」和「跨几天的上下文连续性」。它不是最终事实源,别把它当永久协议文档。

2.3 长期记忆

  • 介质:工作区根目录 MEMORY.md(参考内容明确)。
  • 内容:核心认知与关系、偏好风格、长期目标、进行中任务、关键事件/教训/决策。
  • 边界:参考内容强调「只在主会话加载」,群聊等任务不加载,避免泄露。

MEMORY.md ==「可执行的组织记忆」。它的价值不在于「写得多」,在于「冲突少、可被召回、能约束后续行为」。这层要治理,要像维护配置一样维护。

3. OpenClaw 的文件布局

3.1 「会话快照」文件

快照文件主要是解决 /new/reset 指令的断片

session-memory 的 Hook 会在你执行 /new/reset 前,把上一会话最近 N 条对话(默认 15 条)抽出来,写成一个 Markdown 文件放到 workspace/memory/ 下。

  • 命名:YYYY-MM-DD-<slug>.md,slug 通常由 LLM 根据主题生成;LLM 不可用就回退成 HHMM
  • 关键点:这种文件也会被检索索引到。原因是 listMemoryFiles() 会递归扫描 workspace/memory/ 下所有 .md,并不要求必须是 YYYY-MM-DD.mdsrc/memory/internal.ts:115-145 )。

这个机制对「人类工作流」很友好。很多团队的真实使用是:今天临时开了个话题,明天又忘了开在另一个会话里。会话快照能把碎片变成可检索素材,后面再沉淀进 MEMORY.md

3.2 memory/main.sqlite:索引库

  • memory/main.sqlite 基本可以确定是「记忆搜索(memory_search)」用的 SQLite 索引库。
  • 索引对象:MEMORY.mdmemory/**/*.md,以及你配置的 extraPaths,可选 session transcripts。
  • 检索方式:FTS/BM25 关键词检索 +(可选)向量相似度检索(sqlite-vec)。
  • 它存的典型结构:fileschunksembedding_cache,以及可选的 FTS 表、向量虚表。

事实源是文本文件索引是可重建的派生物。索引坏了你删掉重建就行;事实源坏了才是真的坏。

4. 怎么建索引:

建索引我们关心的三件事:增量、去重、成本

OpenClaw 的索引构建不是「每次全量重算」,也不是「精细 diff」:

  • 更新粒度:按文件做增量。文件没变直接跳过。
  • 分块粒度:文件变了就重建该文件 chunks。
  • 向量成本:chunk embedding 通过缓存复用,避免重复调用 embedding provider。

4.1 扫描哪些文件会进索引

OpenClaw 会递归扫描 workspace/memory/ 下所有 .md,并包含 MEMORY.md/memory.md。对应定位是 src/memory/internal.ts:115-145

4.2 文件级 hash:没变就跳过

文件 hash 的策略:

  • Markdown:hash = sha256(content)internal.ts:L245-L263
  • 多模态:buffer 也会 hash,最后把 {path, contentText, mimeType, dataHash} 做 JSON 再 sha256(internal.ts:L204-L243
  • 增量判定:对比 files 表里的 hash,一致就跳过(参考内容列了 memory 文件与 session 文件两条路径)。

hash 是增量的核心。它的意义不止省时间,还省钱:embedding provider 往往是计费点。这种主要是对于使用第三方 embedding 的。

4.3 分块策略:tokens*4 的字符近似

chunkMarkdown() 的策略:

  • maxChars = tokens * 4overlapChars = overlap * 4
  • 以「行」为主,超长行会被切段
  • 每块生成 hash=sha256(text),并有 embeddingInput

tokens*4 这种近似在工程里挺常见,优点是简单、稳定、跨模型大差不差。缺点也明显:

  • 语言差异会影响 token/char 比例;中英文混排时 chunk 尺寸会漂。
  • 以行切块对 Markdown 友好,但对「一行很长的 JSON 或日志」不友好。

可以盯两个指标来调 chunking:

  1. 平均召回 snippet 的「可读性」和「自洽性」;
  2. SQLite 体积与索引更新耗时。chunk 太小召回碎,太大注入贵。

4.4 chunk 的唯一标识与 upsert

去重靠 id,chunk 写入策略如下:

  • chunk idsha256("${source}:${path}:${startLine}:${endLine}:${chunk.hash}:${provider.model}")
  • 同一 id:ON CONFLICT(id) DO UPDATE 覆盖更新
  • 文件要重建时会先清旧再写新(参考内容总结了「清旧再写新」语义)

这里有个很实际的 trade-off:

  • 它不做「chunk diff」,所以文件变了就重建该文件 chunks,逻辑简单,坏处是 IO 多。
  • 但 embedding 通过缓存复用,把最贵的部分压下去了。

另外,id 里带了 provider.model,这会带来一个工程后果:embedding 模型换了,chunk id 会变,索引层面等价于全量重建。 provider/model/providerKey 变化会触发 full reindex。

4.5 embedding_cache

embedding 缓存的主键设计:

  • 主键:(provider, model, provider_key, hash)
  • provider_key 会把 endpoint/headers 等纳入指纹,避免跨配置污染缓存(而且会剔除授权头的细节在参考内容里提到)。
  • 批量加载命中就跳过 embed;miss 才请求,成功回写缓存(对应 manager-embedding-ops.ts 的行段)。

这是「上线能用」的关键。否则就会遇到一个很尴尬的情况:
索引更新频繁触发 embedding 重算 → 延迟抖动 → API 费暴涨 → 还可能被 provider 限流。 system prompt 的 skills 段落甚至提醒「假设有 rate limits,避免 tight loop」,这就有点被打过之后写进规范的味道。

5. 更新怎么触发

watch、interval、onSearch、session-delta

索引更新如果做得「过勤」,会把 CPU 和 IO 吃满;做得「过懒」,召回就是过期的。OpenClaw 在触发上给了多条路径:

  1. watch:chokidar 监听 MEMORY.mdmemory.mdmemory/**/*.md(以及 extraPaths、多模态扩展),变更标记 dirty,debounce 后 sync(reason="watch")
  2. intervalsync.intervalMinutes>0setInterval 定时跑。
  3. onSessionStart:search 前 warmSession(sessionKey),若开了 sync.onSessionStart,每个 sessionKey 首次触发后台 sync。
  4. onSearch:search 时如果 dirty 且开了 sync.onSearch,后台触发 sync。
  5. session-delta:监听 transcript 更新,累计新增 bytes/lines,达到阈值后把相关 session 文件标脏,再 sync。

还有两点:

  • 单飞锁:同一时刻只跑一个 sync,复用同一个 Promise(参考内容定位 manager.ts:452-467)。
  • 全量重建的原子 swap:写到 .tmp-UUID,完成后 swap(含 wal/-shm),避免半成品索引(参考内容定位 manager-sync-ops.ts:1050-1158)。

6. 召回是怎么发生的

主要看 buildMemorySection() 的代码,因为它把策略写死了:

提示词:
function buildSkillsSection(params: { skillsPrompt?: string; readToolName: string }) {
  const trimmed = params.skillsPrompt?.trim();
  if (!trimmed) {
    return [];
  }
  return [
    "## Skills (mandatory)",
    "Before replying: scan <available_skills> <description> entries.",
    `- If exactly one skill clearly applies: read its SKILL.md at <location> with \`${params.readToolName}\`, then follow it.`,
    "- If multiple could apply: choose the most specific one, then read/follow it.",
    "- If none clearly apply: do not read any SKILL.md.",
    "Constraints: never read more than one skill up front; only read after selecting.",
    "- When a skill drives external API writes, assume rate limits: prefer fewer larger writes, avoid tight one-item loops, serialize bursts when possible, and respect 429/Retry-After.",
    trimmed,
    "",
  ];
}

function buildMemorySection(params: {
  isMinimal: boolean;
  availableTools: Set<string>;
  citationsMode?: MemoryCitationsMode;
}) {
  if (params.isMinimal) {
    return [];
  }
  if (!params.availableTools.has("memory_search") && !params.availableTools.has("memory_get")) {
    return [];
  }
  const lines = [
    "## Memory Recall",
    "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md; then use memory_get to pull only the needed lines. If low confidence after search, say you checked.",
  ];
  if (params.citationsMode === "off") {
    lines.push(
      "Citations are disabled: do not mention file paths or line numbers in replies unless the user explicitly asks.",
    );
  } else {
    lines.push(
      "Citations: include Source: <path#line> when it helps the user verify memory snippets.",
    );
  }
  lines.push("");
  return lines;
}

工具描述:
 label: "Memory Search",
    name: "memory_search",
    description:
      "Mandatory recall step: semantically search MEMORY.md + memory/*.md (and optional session transcripts) before answering questions about prior work, decisions, dates, people, preferences, or todos; returns top snippets with path + lines. If response has disabled=true, memory retrieval is unavailable and should be surfaced to the user.",
    parameters: MemorySearchSchema,

有三点:

  1. 触发条件写得具体:prior work / decisions / dates / people / preferences / todos。模型不需要猜「算不算记忆相关」。
  2. 两阶段召回:先 memory_search 找片段,再 memory_get 精读少量行,控制注入体积。
  3. 引用策略可控citationsMode 可以关掉,避免模型动不动把路径行号甩出来(对产品形态很重要)。

两阶段召回比「一次性把相关文件 wholefile 塞进去」靠谱太多。

7. 召回结果怎么进上下文

toolResult 消息是关键通道

很多人以为「记忆」是把内容写进 system prompt。OpenClaw 不是这么干的。

召回结果会以工具执行结果的形式进入会话消息列表,后续模型调用自然「看得到」。

  • 工具返回会被包装成 JSON 文本块(参考内容定位 jsonResult()src/agents/tools/common.ts:230-239)。
  • tool 返回会被标准化成 content[] + details(参考内容定位 src/agents/pi-tool-definition-adapter.ts 的 normalize)。
  • 这些 toolResult 会被追加到 session messages,下一次模型调用会携带。

这条通道对排障非常友好:我们可以在 transcript 里看到「这次回答之前它到底召回了什么」。而且 toolResult 天然可控预算、可控格式,比让模型把记忆揉进自由文本稳得多。

8. 写入时机

8.1 会话快照写入

人为触发的「切会话」

当执行 /new/reset 时,上一段会话尾部会被抽取成 YYYY-MM-DD-<slug>.md。这是「防断片」写入,价值是保住最近上下文。

坑:

  • 抽取的 N 条对话里可能包含敏感信息。它会落在 memory/,并进入索引。
  • 如果你把 workspace 目录同步到团队共享盘或提交到 repo,泄露面会扩大。

我们的做法:

  • 明确区分「个人 workspace」和「团队 workspace」。个人的 memory/ 默认不进 repo。
  • 开启 citations 时,产品侧要想清楚是否允许暴露路径与行号。

8.2 短期记忆写入

「需要我们调教,告诉她哪些重要」。

短期记忆要走「稀疏高密度」路线:条目少,但每条都能在未来的某个问题上直接复用。写入策略要围绕「将来会搜什么」来定,不要围绕「当下发生了什么」来记流水账。

8.3 长期记忆更新

心跳 / AGENTS.md / cron

三种更新机制:心跳、核心流程、cron。

读最近几天短期记忆 → 选值得长期记住的 → 提炼写入 MEMORY.md

观点:

  • cron 最稳,可观测、可控、可回滚。
  • 心跳更新很容易在负载高时抖动,或者在你最不想更新的时候更新。
  • 把它塞进核心流程(AGENTS.md)要谨慎,一旦每次任务都触发提炼,会把延迟拉上去。

一般做法:

  • 工作日每天固定一次 consolidation(cron)。
  • 遇到重大决策或事故复盘,当天手动提炼写入 MEMORY.md,不等自动化。

9. 怎么「调教」

把记忆当成协议,不当成日记

「告诉她哪些重要」。把「重要」拆成几类,每类有明确写入规则,避免模型自由发挥。

一般的规则:

  1. 稳定偏好:例如输出格式偏好、技术栈偏好、代码风格偏好。
  2. 组织事实:团队结构、系统边界、核心服务依赖、环境约束。
  3. 关键决策:ADR 级别的决策,包含时间点与理由。
  4. 长期目标与在途事项:能跨周追踪的,不写「今天要做的」。
  5. 事故教训:明确到「哪个坑踩过」「如何避免」。

短期记忆(memory/YYYY-MM-DD.md)会允许更多过程性信息,但要满足一个条件:未来能被搜索问题命中。比如你写「今天讨论了 A」,基本没用;你写「决定 A 的原因是 B,后续若出现 C 用 D 回滚」,会有用一些。

如果希望 memory_search 在关键时刻召回到正确内容,就得用「未来的查询语句」来写记忆。

以上。

如何构建行业 Agent 的 RAG

行业 Agent 和我们常用的「通用聊天 Agent」不是一类东西。

行业 Agent 是要能解决问题的,而查资料只是其中一步,后面还要做判断、走流程、调用系统、校验结果、留痕、可回放。

RAG 在这里的角色也变了:它不只是给模型喂上下文,而是给 Agent 提供可执行任务所需的依据、约束、参数和证据链。

今天我们聊一下行业 Agent 构建过程中的 RAG 怎么写,从目标、数据,检索以及使用 RAG 等等方面。

1. 行业 Agent 的 RAG 要服务什么能力

行业 Agent 常见的工作方式是「多步闭环」:

  1. 识别问题类型与业务对象(客户、设备、合同、工单、订单、项目、账号等)
  2. 查依据(制度、手册、知识库、历史工单、标准、接口文档)
  3. 做动作(查系统、下发指令、开通配置、生成工单、发邮件、写报告、提审批)
  4. 校验与回写(确认变更成功、回填字段、留痕、把引用/证据挂到工单)
  5. 解释(给用户说明依据、影响范围、回滚方案、下一步建议)

所以行业 Agent 的 RAG 不只是「问答检索」,而是至少要覆盖这些信息类型:

  • 规则依据:制度、条款、SOP、合规模板、变更规范
  • 操作依据:系统使用手册、接口文档、参数含义、错误码处理
  • 对象事实:来自业务系统的实时/准实时数据(用户信息、资源状态、库存、账单、设备状态)
  • 历史经验:工单处理记录、故障复盘、已知问题(KEDB)
  • 风险边界:禁用操作清单、权限范围、需要人工复核的条件

如果我们只做「文档向量库 + 生成」,Agent 走到第 3 步就会卡:它不知道该调用哪个系统、需要哪些字段、什么情况下要停下来让人确认,也不知道怎么证明自己做对了。

2. 指标

行业 Agent 场景里,最好用三类指标描述:

2.1 任务完成类指标

  • 任务成功率(最终动作成功并通过校验)
  • 平均完成时长(端到端)
  • 人工介入率(需要人确认/补充信息/兜底)
  • 回滚率(执行后需要撤销/修正)

2.2 风险类指标(红线不能过)

  • 越权率(检索/执行是否越权,目标是 0)
  • 误执行率(不该执行却执行)
  • 误答导致的错误操作(把“编出来的依据”当成执行依据)
  • 引用不可追溯率(给不出来源或来源不支持结论)

2.3 知识与检索类指标(用于驱动迭代)

  • 依据命中率(标准依据是否出现在 topK)
  • 冲突处理正确率(新旧版本/多来源冲突时是否选对)
  • 时效正确率(是否引用过期/废止内容)
  • 覆盖率(高频问题是否覆盖)

行业 Agent 的 RAG 设计,最终要对这些指标负责。否则我们会陷入「答得像那么回事,但不敢让它动系统」的状态。

3. 数据层

行业 Agent 的 RAG,数据比模型更重要。

3.1 三类数据

  1. 静态权威知识:制度、规范、手册、标准、产品文档
    目标:可追溯、版本可控、可引用
  2. 动态业务事实:来自业务系统的数据(CRM、工单、CMDB、监控、计费、IAM 等)
    目标:可校验、可审计、最好可回放(至少保留查询快照)
  3. 过程与经验:历史工单、故障复盘、处理记录、FAQ 演进
    目标:可过滤(质量参差)、可分级(权威/经验/猜测)

很多项目失败是因为把第 3 类当第 1 类用,把「经验」当「制度」。Agent 一旦据此去执行动作,风险会放大。

3.2 每个知识片段必须带的元数据

行业 Agent 需要的不只是「能搜到」,还要「能用来做动作」。建议每个 chunk 至少包含:

  • doc_id / chunk_id
  • source(系统/库)
  • source_url(可点击或可定位)
  • title_path(标题链)
  • doc_type(制度/手册/接口文档/复盘/工单等)
  • versionstatus(草稿/已发布/已废止)
  • effective_from / effective_to(能给就给)
  • owner(维护人/团队)
  • updated_at
  • 适用范围标签:产品线/地区/客户/机型/环境(生产/测试)
  • 权限标签:RBAC/ABAC 所需字段
  • 可执行性标签(建议加):
    • 是否可作为执行依据(例如制度/已发布 SOP 才能)
    • 是否需要人工复核(高风险操作)
    • 是否仅供参考(复盘/经验)

这些标签对 Agent 比较关键:它能决定「能不能做、要不要停、怎么解释」。

3.3 文档解析与切分

行业 Agent 的 RAG 的切分策略,优先级一般是:

  1. 按结构切:章/节/条款/接口字段说明/错误码条目
  2. 把“前置条件/限制/例外”跟规则放一起
  3. 表格与字段定义要保表头(字段含义脱离表头就没法用)
  4. 把可执行步骤单独成块(SOP、Runbook、变更步骤)

注意:不要把「定义」「适用范围」「例外条款」切碎。Agent 执行动作时,最需要的就是边界条件和限制。

4. 索引与检索

行业 Agent 和常规的 Agent 不同,其更依赖于「过滤 + 排序 + 证据链」

4.1 使用混合检索

行业 Agent 的查询里会出现大量「硬信息」:

  • 条款号、标准号、型号、错误码、参数名、接口路径、工单号、配置项名

纯向量在这些场景不稳。工程上更常用的是:

  • 关键词/BM25:抓编号、术语、字段名、错误码
  • 向量召回:抓语义相近、同义表达
  • 融合 + 重排:把候选集排序成「最能支持动作/结论」的那几段

4.2 检索要先过滤,再找相似

行业 Agent 的过滤通常是强约束,如下:

  • 权限过滤(用户/角色/租户/数据域)
  • 状态过滤(废止、草稿默认不进)
  • 生效时间过滤(尤其制度、计费、合规)
  • 适用范围过滤(产品/地区/环境)
  • 数据域隔离(内部/客户侧/合作方)

如果我们把这些留到生成阶段「让模型自己注意」,效果不可控,风险也不可控。

4.3 Agent 专用检索

不止检索答案,还要检索工具与参数

行业 Agent 经常需要两类额外检索:

  1. 工具检索(Tool RAG)
    从「工具说明库/接口文档/SOP」里检索:该用哪个工具、需要哪些参数、有哪些限制、失败怎么处理。
  2. 参数与字段检索(Schema RAG)
    从「数据字典/字段说明/枚举值」里检索:字段含义、可选值、校验规则、示例格式。

这两类检索的结果不一定直接展示给用户,但会决定 Agent 能不能把动作做对。

5. 固化 Agent 使用 RAG 的逻辑

行业 Agent 的 RAG 关键是要「把 RAG 插进决策点」

行业 Agent 常见的内部循环大致是:

  • Plan(决定下一步做什么)
  • Act(调用工具/检索/执行)
  • Observe(拿到结果)
  • Decide(是否继续、是否需要人确认、是否结束)
  • Explain(对外输出)

RAG 的插入点建议固定成三处:

5.1 决策前

用 RAG 找「规则边界」

在 Agent 做出关键决策前,先检索:

  • 是否允许执行(权限、合规、风险等级)
  • 前置条件是什么(必须具备哪些信息、哪些系统状态)
  • 需要的审批/确认是什么(是否必须人工确认)

这一步的输出的是「约束」,不是「答案」。它会影响下一步是继续、暂停还是转人工。

5.2 执行前

用 RAG 找「操作步骤与参数」

执行某个动作前,检索:

  • SOP / Runbook / 接口文档
  • 必填参数、参数来源
  • 校验方式(执行后如何确认成功)
  • 回滚方式(失败/异常如何撤销)

这一步的输出是「可执行步骤」,不是「解释性段落」。

5.3 执行后

用 RAG 做「结果判定与错误处理」

拿到工具返回值后,检索:

  • 错误码含义与处理建议
  • 常见失败原因
  • 是否需要升级/转人工
  • 是否需要二次校验(比如跨系统一致性)

这一步的输出是「下一步动作建议 + 证据」。

6. 生成与输出

行业 Agent 的输出要分层,不要把所有东西都写给用户

行业 Agent 的输出建议拆成三层,分别服务不同目标:

  1. 用户层:结论/进展、需要用户补充什么、下一步怎么走
  2. 证据层:引用依据(链接、页码、版本、生效日期)
  3. 执行层(留痕层):本次调用了什么工具、参数摘要、返回结果摘要、校验结果、回滚点

用户不一定要看到执行层细节,但系统必须存储这些内容。只有出了问题能回放,才敢放权。

同时,行业 Agent 的生成要有硬规则:

  • 没有命中权威依据:不输出肯定结论
  • 有冲突:必须把冲突来源、版本、生效时间写清楚
  • 涉及高风险动作:必须停下来请求确认(并把依据与影响范围给出来)
  • 引用必须来自检索上下文:不允许来虚的,「凭印象补一句」

7. 权限、审计、隔离

**行业 Agent 的 RAG 必须「检索前隔离」。

行业 Agent 一旦能调用系统,风险比问答高一个量级。权限要分两层:

7.1 知识权限

能不能看的问题

  • 文档/知识片段按 ABAC/RBAC 做过滤
  • 按租户隔离(多客户必做)
  • 按数据域隔离(内部策略、客户信息、合作方信息)

7.2 行为权限

能不能做的问题

  • 工具级权限:这个角色能调用哪些工具
  • 动作级权限:同一工具下哪些操作允许(例如只读查询 vs 修改/下发)
  • 参数级权限:同一动作下哪些资源范围允许(例如仅能操作自己负责的项目/客户)

很多团队只做了「知识权限」,没做「行为权限」。

这会导致不放心,即使 Agent 能查到 SOP,也能学会「怎么做」,但你又不敢让它真的做。

7.3 审计要能回答四个问题

  • 为什么这么做(依据是什么)
  • 做了什么(调用了哪些工具、关键参数是什么)
  • 得到了什么(返回结果与校验结果)
  • 谁批准的(如果需要人工确认)

没有这四个问题的答案,行业 Agent 很难通过安全审查,也很难在出事后定位责任与修复点。

8. 灰度上线策略

先控制风险,再谈覆盖率

行业 Agent 的上线节奏建议按权限逐步放开:

  1. 只读 Agent:只检索、只解释、只给建议,不执行任何写操作
  2. 半自动 Agent:可以生成“执行计划/工单草稿/变更单草稿”,必须人工确认后执行
  3. 受限自动 Agent:只允许低风险、可回滚、可校验的动作自动执行(例如查询、对账、生成报表、创建工单、补全字段)
  4. 高风险动作:默认保留人工确认,除非你能做到严格的权限、校验、回滚、审计,并且有明确的责任边界

上线必须准备三套兜底:

  • 超时与降级:检索失败/重排失败/模型失败时怎么退化
  • 失败回滚:执行失败怎么撤销,撤销失败怎么升级
  • 人工接管:在关键节点能一键转人工,并把证据与执行轨迹带过去

9. 常见坑

  1. 把「经验工单」当「标准答案」:Agent 会把偶发处理当成通用规则。必须分级与降权。
  2. 只做知识库,不做数据字典与工具库:Agent 会不知道参数怎么填、字段是什么意思、错误码怎么解。
  3. 只做检索,不做执行前校验与执行后校验:敢执行的前提是可校验、可回滚。
  4. 权限只管文档,不管工具:最容易在这里翻车。
  5. 没有回放评测:你不知道一次小改动会不会让 Agent 在某个分支上开始乱走。
  6. 把「多轮对话」当「任务编排」:行业 Agent 的关键是状态机与决策点,不是聊得多。

最后,行业 Agent 的 RAG 如果要构建,不仅仅是算法的事情,需要更多的业务专家,业务 Owner 来直接参与,他们才是最懂行业的人。需要他们来定义「什么算答对/答错」、哪些文档权威、版本如何取舍、哪些内容不能答。

以上。

从 Claude Code到 Gemini CLI,AI Agent 的上下文管理策略

对于一个与大型语言模型(LLM)打过交道的开发者来说,上下文管理都是一个绕不开的核心问题。它不仅决定了 AI 的智能程度,也直接关系到系统的性能和成本。

上周研究了各家 Agent 系统的实现,各家的上下文管理策略都不相同。最简单最傻的策略是一个不断累加对话历史,这种策略很快就会遇到 Token 限制和 API 的成本问题。

如果你是一个技术负责人,或者正在开发 AI Agent 相关的产品,需要在性能和成本之间找到平衡点,这篇文章应该对你有一些帮助。

今天所聊的内容是基于对 Claude Code、Manus、Gemini CLI,OpenManus 等多个项目的分析,以及自己在实践中的一些思考。

为什么要做上下文管理?

最新的 LLM 现在提供 128K Token 或更多的上下文窗口。听起来还挺多的,但在真实世界的 Agent 场景中,这通常远远不够。

尤其是当 Agent 与网页或PDF等非结构化数据交互时,Token 数需求会爆炸。

并且,随着 Token 数的增加,模型性能会在超过一定长度后明显下降,这就像让一个人同时记住一本书的所有细节,理论上可能,实际上很难做好。

就算我们的大模型有更多的窗口上下文支持,成本也是一个需要考虑的问题,就算有前缀缓存这样的优化,但传输和预填充每个 Token 都是要付费的。

为了解决这些问题,许多团队选择了压缩策略。但过度激进的压缩不可避免地导致信息丢失。

这个问题的本质在于 Agent 必须根据所有先前状态预测下一个动作——而我们无法可靠地预测哪个观察结果可能在十步之后变得至关重要。从逻辑角度看,任何不可逆的压缩都带有风险。

接下来我们看一看各项目的上下文管理策略,看看从中能否给到各位看官一些启发。

OpenManus 的上下文管理策略

OpenManus 采用了一个相对简单直接的上下文管理方案,主要特点是:

  1. 轻量级消息列表机制
  • 使用固定长度(默认100条)的消息列表作为内存存储
  • 采用简单的 FIFO(先进先出)策略,超出限制时截断最早的消息
  • 没有智能的上下文压缩或摘要机制
  1. Token 限制处理
  • 实施硬性 token 检查,超限直接抛出异常终止
  • 缺乏优雅的降级策略或自适应窗口裁剪
  • 在长对话或工具密集场景中容易触碰上限

虽然上下文管理比较简单,但是 OpenManus 为不同使用场景提供了定制化的上下文处理,如浏览器场景会动态注入浏览器状态,截图保存等

总的来说,这是一个原型实现,并不适合作为生产级环境使用,如果要上到生产环境需要自行做精细化的处理和架构。

Manus 的上下文管理策略

Manus 没有开源,但是其官方有发一篇文章出来。

Manus 采用了一种创新的方法:将文件系统作为终极上下文存储,而不是依赖传统的内存中上下文管理。

文件系统作为存储有如下的核心特性:

  • 无限容量:文件系统大小不受限制
  • 天然持久化:数据自动保存,不会丢失
  • 直接操作:智能体可以主动读写文件
  • 结构化记忆:不仅是存储,更是结构化的外部记忆系统

相对于传统的将完整的观察结果保存在上下文中,容易超限,Manus 实现了可恢复的信息压缩

  • 观察结果指向外部文件(Document X, File Y)
  • 上下文中只保留引用,不保存完整内容
  • 需要时可以从文件系统恢复完整信息

具体实现:

  • 网页内容可从上下文移除,只保留 URL
  • 文档内容可省略,只保留文件路径
  • 实现上下文压缩的同时不会永久丢失信息

Manus 团队认为,如果状态空间模型能够掌握基于文件的记忆管理:

  • 将长期状态外部化而非保存在上下文中
  • SSM 的速度和效率优势可能开启新型智能体
  • 基于 SSM 的智能体可能成为神经图灵机的真正继任者

与 OpenManus 的简单消息列表管理,Manus 的方案更加成熟:

  • OpenManus:固定长度消息列表,硬性截断,缺乏智能管理
  • Manus:文件系统作为无限外部记忆,可恢复压缩,主动记忆管理

Claude Code 的上下文管理

Claude Code 没有开源代码,但是国外有大神反编译其源码(虽然大神自己说:这并非真正意义上的反编译或逆向工程尝试,而更像是对 Claude 团队杰出工作的致敬。)

地址:southbridge-research.notion.site/claude-code…

通过反编译内容的分析,可以大概了解一些其策略和比较巧妙的点:

TodoWrite 工具

Claude Code 引入 TodoWrite 工具,支持模型主动维护自己的 To-Do 列表,替代传统的多 Agent 分工策略。

其优势:

  • 专注:Prompt 中反复提醒模型参考 ToDo,始终聚焦目标。
  • 灵活:「交错思考」机制使得 ToDo 可动态增删。
  • 透明:用户可实时查看计划与进度,提高信任度。

Token 统计的反向遍历

Toke 统计从后往前查找这个细节相当精妙。大部分系统都是傻乎乎地从头遍历,但 Claude Code 意识到了一个关键事实:Token 使用情况的统计信息总是出现在最新的 assistant 回复里。这种”知道去哪找”的优化思路,把原本可能的 O(n) 操作优化到了 O(k),在高频调用场景下,这种优化带来的性能提升是指数级的。

92% 阈值

留 8% 的缓冲区既保证了压缩过程有足够的时间完成,又避免了频繁触发压缩带来的性能开销。更重要的是,这个缓冲区给了系统一个”反悔”的机会——如果压缩质量不达标,还有空间执行降级策略。

8 段式结构化摘要

Claude Code 的 8 段式结构特别值得借鉴:

markdown

体验AI代码助手
代码解读
复制代码

1. Primary Request and Intent - 主要请求和意图

2. Key Technical Concepts - 关键技术概念

3. Files and Code Sections - 文件和代码片段

4. Errors and Fixes - 错误和修复

5. Problem Solving - 问题解决过程

6. All User Messages - 所有用户消息

7. Pending Tasks - 待处理任务

8. Current Work - 当前工作状态

优雅降级

当压缩失败时,系统不会死板地报错或者强行应用低质量的压缩结果,而是有一整套 Plan B、Plan C。从自适应重压缩,到混合模式保留,再到最后的保守截断——每一步都在努力保护用户体验。这种”永不放弃”的设计理念,让系统在各种极端情况下都能稳定运行。

向量化搜索

长期记忆层引入向量搜索,实际上是在为 AI 构建一个”联想记忆”系统。当用户提出新问题时,系统不仅能看到当前对话,还能”回忆”起过去处理过的类似问题。这种跨会话的知识迁移能力,让 Claude Code 从一个简单的对话工具进化成了一个真正的智能编程助手。

Gemini-cli 的上下文管理

Gemini-cli 的上下文管理走了一条和 Claude Code 相似但更加轻量的路线。它的核心理念很简单:文件系统就是天然的数据库

三层混合存储架构

与 Claude Code 类似,Gemini-cli 也采用了分层设计,但实现更加简洁:

第一层:纯内存工作区

  • 存储当前会话的聊天历史、工具调用状态、循环检测状态
  • 零延迟访问,不涉及任何 I/O 操作
  • 会话结束即清空,不留痕迹

第二层:智能压缩层

  • 触发阈值:70%(比 Claude Code 的 92% 更保守)
  • 保留策略:最新 30% 的对话历史
  • 压缩产物:5 段式结构化摘要

第三层:文件系统持久化

  • 全局记忆:~/.gemini/GEMINI.md
  • 项目记忆:向上递归查找直到项目根目录
  • 子目录上下文:向下扫描并尊重忽略规则

70/30

Gemini-cli 选择了 70% 作为压缩触发点,30% 作为保留比例。这个比例设计很有讲究:

为什么是 70% 而不是 92%?

  • 更早介入,避免紧急压缩导致的卡顿
  • 给压缩过程留出充足的缓冲空间
  • 适合轻量级应用场景,不追求极限性能

30% 保留的合理性

  • 刚好覆盖最近 5-10 轮对话
  • 足够维持上下文连续性
  • 不会让用户感觉”突然失忆”

5 段式压缩:够用就好

相比 Claude Code 的 8 段式结构,Gemini-cli 的压缩更简洁:

markdown

体验AI代码助手
代码解读
复制代码

1. overall_goal - 用户的主要目标

2. key_knowledge - 重要技术知识和决策

3. file_system_state - 文件系统当前状态

4. recent_actions - 最近执行的重要操作

5. current_plan - 当前执行计划

忽略规则

Gemini-cli 的 .geminiignore 机制是个亮点:

独立但兼容

  • 可以单独在非 git 仓库中生效
  • .gitignore 并行工作,互不干扰
  • 每个工具都有独立的忽略开关

明确的约束

  • 修改 .geminiignore 需要重启会话才生效
  • 这不是 bug,而是 feature——避免运行时状态混乱

Gemini-cli 的设计哲学可以总结为:不求最优,但求够用

它没有追求理论上的完美压缩比,也没有搞复杂的向量检索,而是用最简单的方案解决了 80% 的问题。这种务实的态度在工程实践中往往更受欢迎——系统简单意味着 bug 少,维护容易,用户上手快。

特别是”文件系统就是数据库”这个理念,虽然听起来有点”土”,但在实际使用中却异常可靠。你不需要担心数据库挂了、连接断了、事务死锁了…文件就在那里,看得见摸得着,出了问题 cat 一下就知道怎么回事。

这种设计思路值得很多过度工程化的项目学习:有时候,简单就是最好的复杂。

小结

上下文是智能的边界,压缩是性能的艺术。

在与大型语言模型打交道的过程中,上下文管理已成为决定智能上限与系统稳健性的关键。虽然现代 LLM 提供了百万级 Token 的窗口,但在实际 Agent 场景中,这远远不够,尤其当涉及非结构化数据(如网页、PDF)时,Token 使用会迅速膨胀。即使有前缀缓存等机制,成本与性能的双重压力仍然存在。因此,上下文压缩成了必选项——但压缩得太激进,又会导致信息丢失,损害 Agent 的决策能力。

聪明的系统不是记住所有,而是记住该记住的。

应对上下文限制的最佳方式不是简单保留或截断历史,而是构建一个具备“记忆力”的智能系统。Claude Code 以三层记忆架构为核心(短期、高速;中期、结构化压缩;长期、跨会话向量化搜索),同时引入 TodoWrite 工具,让模型自我管理计划任务。这使得 Agent 能专注目标、灵活调整、透明运行,形成类人思维般的任务记忆系统。关键机制如 Token 反向遍历、92% 阈值缓冲、8段式摘要结构与优雅降级策略,共同打造了一个稳健又高效的上下文生态。

工程的智慧在于‘够用’,而非‘极致’。

对比 Gemini-cli、OpenManus 与 Manus 的上下文策略,可以看出不同系统在工程实现上的取舍哲学。Gemini-cli 采用实用主义的轻量分层设计,70/30 压缩策略既简单又高效,让用户可控又无需担心性能瓶颈;Manus 则大胆将文件系统作为智能体的“外部大脑”,通过引用而非存储规避 Token 限制;而 OpenManus 则为最小可运行原型提供了基础模板。这些方案展现出一个共识:上下文不一定要复杂,关键在于是否服务于目标。

以上。