聊下 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 架构上下文传递的 4 种策略

在多 Agent 系统里,上下文怎么传,决定了系统的稳定性上限、成本下限、以及排障时的血压。

最开始,很多团队把它当成「把聊天记录拼一拼」的问题。上线后就会这样的问题:

  • 同样的输入,输出飘得离谱。这里的问题是上下文污染和信息密度不稳定。
  • Token 成本控不住。明明一个任务只需要 10 句关键信息,每次都喂 200 句。
  • 自动化评测很难做。回归集跑出来波动大到没法设阈值,最后只能靠人工验收。

从工程的角度简单定义一下「上下文传递」:在一条多步协作链路里,把下游完成任务所需的信息,以可控成本、可追踪方式送到它面前。这里面有两个关键词:可控可追踪

下面聊下我理解的 4 种主流策略拆解:原理、适用场景、落地细节、坑、性能和效果的取舍。

先定义一下上下文

很多争论的根源是大家说的「上下文」不是一个东西。可以在团队里先把上下文分层,后面所有策略都能对齐。这里我们把「上下文」拆成 4 类:

  1. 任务上下文:当前这一步要干什么,验收标准是什么。
  2. 状态上下文:链路运行到哪了,已经产生了哪些中间产物。
  3. 记忆上下文:用户偏好、历史约束、长期设定,和当前任务不完全同一层级。
  4. 证据上下文:引用了哪些原始材料(文档片段、对话原句、文件、数据库记录),用于追溯和评测。

策略 1:共享状态或黑板模式

这套是 LangGraph、CrewAI 这类框架最常见的默认选项。工程上它像一个「全局状态对象」,也像一个「写满便签的白板」。

机制

  • 所有 Agent 对同一个 State 读写。
  • Agent A 产出结果写入 State 的某个字段。
  • Agent B 读取字段,继续处理,再写回。

如果我们不想把大对象放内存,也可以用文件系统或对象存储做「外置状态」,State 里只放路径和元信息。像 Manus 文章中说的「将文件系统作为存储,直接共享文件系统的路径,渐进式披露」,就是这么个逻辑:把大内容放外面,把指针放 State 里

什么时候用

  • 复杂图流转:有回路、有分支、有重试、有人工介入的链路。
  • 任务跨度长:要做断点续跑、要保留每一步证据,方便回放和审计。
  • 需要可视化排障:一个状态树摆在那,定位问题快很多。

这类场景里,黑板是省心的。我们不用操心「A 怎么把消息发给 B」,大家都围着同一块板子写字。

落地时的坑

坑 1:状态对象会长成「垃圾堆」

共享状态天然会诱导人偷懒:什么都往里塞。结果一周后 State 变成一个混杂体:

  • 当前任务指令
  • 全量聊天记录
  • RAG 检索结果
  • 中间产物全文
  • 模型输出草稿

后果是下游 Agent 读到的信息密度越来越低,注意力越来越散。我们会直观感受到「同一个 Agent,越跑越不稳定」。

共享状态可以用,前提是要给 State 立规矩。规矩不是写在 Confluence 上那种,是写进代码和评测里那种。

常用的做法是给 State 分区,至少三块:

  • 「control」:流程控制字段(步数、路由、重试次数)
  • 「artifacts」:产物指针(文件路径、对象存储 key、哈希)
  • 「capsules」:给 LLM 的上下文胶囊(后面会讲)

State 里尽量少放大段文本,放「引用」和「摘要」。

坑 2:并发写

多 Agent 并行时很容易出现:

  • 两个 Agent 同时更新同一字段,后写覆盖前写。
  • 一个 Agent 基于旧 State 做决策,写回时把别人新写入的字段抹掉。

解决思路按分布式系统处理:

  • 字段级别乐观锁(版本号 / compare-and-swap)
  • append-only 日志字段,避免覆盖(把「更新」变成「追加事件」),Gemini Cli 就是这个逻辑
  • 把「写入」限定为少数字段,其他字段只读

坑 3:评测没法做「输入对齐」

共享状态经常带来一个隐性问题:每次运行 State 的非关键字段变化很大,导致没法保证下游 Agent 的输入一致。回归测试时同一条用例,今天多了两段日志,明天多了一个草稿,指标就会飘。

建议:评测时固定「胶囊输入」,State 可以变,但进入 LLM 的那段上下文要可快照、可对比、可复现。

成本 vs 效果的取舍

  • 效果:流程可扩展,复杂图最好用。
  • 成本:需要治理 State 的 schema、并发、版本、清理策略。
  • 性能:状态越大,序列化 / 反序列化越痛;如果每一步都把 State 发给 LLM,更是直接烧钱。

共享状态是一把大锤。能砸钉子,也能把玻璃砸碎。关键看有没有「状态卫生」这件事。

策略 2:消息传递与直接调用

这套有点像微服务架构:上游把消息打包发给下游,下游处理完再回一个结果。

机制

  • Agent A 产出一个「消息」发给 Agent B。
  • 消息可以走 HTTP、RPC、队列,也可以是框架内的函数调用。
  • 每条消息都应该有明确的结构和版本。

什么时候用

  • 流水线式任务:每一步都很明确,上游输出就是下游输入。
  • 要强可观测性:链路追踪、审计、回放都好做。
  • 团队边界清晰:不同组负责不同 Agent,接口契约能拉齐。

这类场景用消息传递灵活性更强一些,但是如果规模不大,直接单体应用来搞,函数间调用吧。

落地时的坑

坑 1:消息里塞进「全量上下文」

很多团队为了省事,会把上游拿到的所有东西都塞进消息里。看起来省了裁剪逻辑,实际上把问题推给了下游:下游 LLM 要在一堆噪声里找信号。

如果走消息传递,消息必须有「字段语义」。比如:

  • 「task」字段是当前要做的事
  • 「constraints」字段是硬性限制
  • 「evidence」字段是引用(原文片段或路径)
  • 「history」字段如果存在,必须明确是「最近 N 轮且强相关」

这里的关键词是「必须明确」。否则会出现消息看着结构化,内容依然是散装的。

坑 2:接口版本失控

多 Agent 系统迭代快,接口字段会频繁变动。如果经历过一次「某个 Agent 升级后,下游全挂」就会理解版本的重要性。

建议至少做到:

  • 每条消息带「schema_version」
  • 下游支持 1~2 个旧版本的兼容解析
  • 重要字段改动要有灰度期,别全量切

Agent 世界里「prompt 和策略」变化太快,不做版本控制就是赌博。

坑 3:把「LLM 输出」当成接口返回

LLM 输出天然存在幻觉。如果我们直接把自由文本当成 RPC 返回,然后让下游再去解析,事故率会非常高。

有一个简单的方法:固定栏位的轻量输出格式,别一上来就上复杂 schema,也别放任自由发挥。它在工程上有一个很大的价值:解析稳定,回归测试有抓手。

类似于这样:

PROMPT:
...

NEGATIVE:
...

PARAMS:
- aspect: 16:9
- notes: ...

成本 vs 效果的取舍

  • 效果:可追踪性强,调试体验好。
  • 成本:要做接口契约、版本管理、兼容逻辑。
  • 性能:网络开销和序列化开销可控;真正的成本往往来自传了多少无用字段。

如果业务链路更像「微服务编排」,消息传递会比共享状态更干净。

策略 3:上下文压缩与自然语言传递

核心思路:下游 Agent 不该负责考古

把「长历史」变成「短胶囊」,把「噪声」变成「任务卡」,再交给执行 Agent。

机制

上游做三件事:

  1. 从历史里抽取和当前任务强相关的信息
  2. 把冲突的约束做决策或提出澄清问题
  3. 输出一个高密度、可控的自然语言指令

「上下文胶囊(context capsule)」

把给下游 Agent 的输入,固定成一个胶囊,结构大概是:

  • 必须给:任务卡(Planner 压缩/改写后的自然语言描述)
  • 可选给(按需):

    • 最近 N 轮「与任务强相关」的对话原句(最多 3–8 句)
    • 一段「用户偏好/风格记忆」摘要(1–3 句)
  • 坚决不直接给:全量聊天记录(除非做的就是风格延续式创作,而且做了脱敏)

它解决的是「你能不能控制它理解什么」。

示例:

任务卡:生成一张用于电商 banner 的图。主体是一只穿宇航服的柯基站在月球上,远处能看到地球。风格写实摄影,冷色调,高对比,电影感侧逆光。横向 16:9。不要任何文字、logo、血腥或恐怖元素。用户偏好极简、冷色、不要文字。若信息缺失请提 1–3 个澄清问题,否则直接输出可用于生图的 prompt 与 negative prompt。

这段话有几个关键点:

  • 主体、场景、风格、画幅、禁忌、用户偏好都在
  • 有「缺失信息时的行为规则」
  • 不需要表单,依然可评测、可回归

工具描述要写成「契约」

工具描述很重要。

我更喜欢把工具说明写成「契约」,至少包含:

  • 工具支持的参数(prompt / negative / size / seed / style 等)
  • 哪些信息必须出现(画幅、用途、限制)
  • 输出必须遵守的格式(哪怕只有 PROMPT/NEGATIVE/PARAMS)

可能翻车的地方

以一个增强提示词的 Agent 为例

翻车 1:指代延续没被写进任务卡

用户说「按刚才那张风格」「把她换成红裙子」,Planner 如果没有把「刚才那张」总结成可引用的描述,下游增强 Agent 根本无从得知。

补救方式使用「证据上下文」:把关键原句作为 1~3 条引用附在胶囊里。

翻车 2:约束冲突没被处理

用户一会儿要极简纯色,一会儿又要复杂赛博城市场景。Agent 去解决冲突会很糟糕,因为它的职责是「增强表达」,不是「做产品决策」。

冲突要在 Planner 层解决:要么做裁决(按最新指令为准、按用户偏好为准),要么问澄清问题。别把锅甩给执行 Agent。

翻车 3:压缩带来的信息损失

上下文压缩是有损的。 压缩做得越狠,成本越低,翻车概率越高;压缩做得越松,成本越高,稳定性也未必更好,因为噪声会上来。

建议做一个「胶囊长度预算」,按任务类型分档:

  • 低风险任务(格式化、简单问答):胶囊可以短到 200~400 tokens
  • 中风险任务(生成、改写、推理):600~1200 tokens
  • 高风险任务(工具调用、多约束、多回合创作):1200~2000 tokens,再往上就该考虑别的策略了

这样,可以让成本和稳定性可控一些。

成本 vs 效果的取舍

  • 效果:稳定性提升非常明显,Token 成本能压下来,评测也更容易做。
  • 成本:要多一个 Planner/Summarizer 步骤,链路延迟会上升;压缩质量要靠回归集打磨。
  • 工程判断:这套是「多 Agent 真正开始像工程系统」的起点。

策略 4:路由分发与层级管理

如果说策略 3 解决的是「给下游喂什么」,策略 4 解决的是「谁有资格看到什么」。

我喜欢用「最小信息原则」去设计多 Agent:每个 Agent 只拿自己需要的那一部分上下文,别让它看到不该看的东西。

机制

  • 一个 Supervisor(主管)拿到全量上下文。
  • Supervisor 拆任务、选 Agent、裁剪上下文。
  • 子 Agent 只看到被裁剪后的输入,产出结果回传 Supervisor。
  • Supervisor 汇总,决定下一步。

把「路由」和「信息裁剪」集中起来做,能显著减少上下游互相污染。

这本质就是一个主从的逻辑。

什么时候用

  • 权限和合规敏感:有 PII、有商业机密、有分级数据。
  • 子 Agent 职责清晰:比如「检索」「评审」「生成」「合规检查」。
  • 系统要长期维护:人员流动、策略变动、模型替换都很频繁。

层级路由把复杂性收敛到 Supervisor 这一点上。依赖它,也更容易把它做好。

落地时的坑

坑 1:Supervisor 变成性能瓶颈

所有东西都过 Supervisor,它会成为热点:吞吐、延迟、可用性全压在它身上。

解决办法通常有三种:

  • Supervisor 只做「路由与裁剪」,不要在它身上做重推理
  • 对路由做缓存(同一类任务走同一条路径)
  • Supervisor 逻辑尽量确定性,LLM 参与度降低

我见过很多团队把「大脑」写成一个超级 prompt,然后让它既拆任务又生成内容又做审查。这样迟早会蹦。

坑 2:裁剪策略一开始过度依赖「拍脑袋」

裁剪不是凭感觉。裁剪是一套数据工程问题:哪些字段必须给,哪些字段给了会干扰。

用「失败用例驱动」去迭代裁剪:每次线上翻车,都回放当时给子 Agent 的胶囊,问一个很残酷的问题:

  • 该给的没给,是哪一类信息缺失?
  • 不该给的给了,是哪一类噪声触发了跑偏?

把这两类问题沉淀成裁剪规则,会越做越稳。

坑 3:子 Agent 之间产生「隐性耦合」

很多系统表面上是层级的,实际上子 Agent 会通过共享外部资源互相影响,比如:

  • 共用同一个向量库检索空间,检索结果被不同策略污染
  • 共用同一个临时文件目录,路径命名冲突
  • 共用同一个「用户偏好记忆」,写入时缺少版本控制

如果走 Supervisor 模式,「写入边界」会比较重要:哪些 Agent 允许写记忆,哪些只能读;写入要不要审批;写入是否带证据引用。

成本 vs 效果的取舍

  • 效果:稳定性和安全性非常强,复杂系统更容易控住。
  • 成本:Supervisor 设计难度高,容易成为瓶颈;需要更完善的可观测性和回放能力。
  • 工程判断:当开始被「数据泄露」「上下文污染」「责任边界不清」折磨时,Supervisor 往往是解药。

选择策略时,如何判断

可以用四个可执行的问题来选方案:

  1. 谁需要看到全量上下文?谁只需要胶囊?
    如果答案是「大多数都只需要胶囊」,策略 3 和 4 优先级会上来。

  2. 要不要并发?要不要异步?
    需要并发、异步,策略 5 的价值会非常直接。

  3. 失败主要来自哪里:信息缺失,还是噪声过多?
    信息缺失优先补证据引用;噪声过多优先做裁剪和胶囊预算。

  4. 是否真的在做回归评测?
    没有回归,就别指望系统会「越调越稳」。上下文传递策略的好坏,最终都要落在可复现输入上。

小结

不做结构化,并不等于不做「约束与契约」

我见过的高质量落地项目,往往走的是「看起来很自然,实际上约束很硬」的路线。用户体验上像聊天,工程实现上像协议。

如果准备做多 Agent 的上下文传递,至少把三件事落下来:

  • 「上下文胶囊」:任务卡 + 少量强相关原句 + 记忆摘要
  • 「工具契约」:写清楚工具能力边界和必填信息
  • 「受控输出格式」:固定栏位,解析稳定,评测可做

这三件事做完,再谈共享状态、Supervisor、消息传递,才有意义。

以上。

SaaS 已死?AI 当立?

在 AI 编程逛飙的年份,到当前的阶段,能感觉到速度在加快,形式也在不断的迭代,写代码这个事情也变得门槛很低。

X 上有人在讲「AI 让软件开发成本接近零,所以 SaaS 价值也接近零」

美股前段时间也因此大跌了一波,但当前这个价值为零的逻辑还是不成立的。

这里有一个概念混淆:构建软件的成本 vs 拥有软件的成本。AI 主要压低前者,后者还在,甚至在很多公司里变得更贵。

在各种自媒体、AI 编程培训或者博眼球的报道中,「一个下午做出 Linear 替代」「一个周末写完 Stripe 替代」这种话,我不觉得完全是吹牛。用 Claude Code 这类工具,把界面、CRUD、简单流程、甚至一些边角的自动化都拼出来,确实快。

但在做出来的那一刻,资产没增加多少,负债突然多了。尤其是碰钱、碰身份、碰合规、碰客户数据的时候。

以做了一个 Stripe 为例,我把 Vibe Coding 一个周末后,「现在拥有了什么」用更工程的语言翻译一下:

  • 拥有了 规则持续变化 的税务与开票适配:欧盟 VAT、各国电子发票、免税/退税、税率变更、发票作废红冲。
  • 拥有了 审计与认证的对话成本:PCI DSS、SOC 2、ISO 27001、渗透测试报告、供应商安全评估问卷。企业客户要的往往不是「你写得对不对」,是「谁在对这件事负责」。
  • 拥有了 支付与账务的边界条件:拒付、部分退款、重复扣款、汇率、四舍五入、账期、对账差异、资金在途、延迟入账。
  • 拥有了 全球化的坑:货币重估、货币小数位变化、地区性监管、某个国家突然要求强制 3DS、某个渠道突然不支持某种卡组织。
  • 拥有了 数据与权限的事故半径:某个字段脱敏没做好、某个导出接口忘了做权限校验、某个后台操作没有审计日志。
  • 拥有了 7×24 的值班现实:系统降级策略、容量、限流、重试风暴、第三方故障兜底、SLA 与赔付条款。

这些事大概率不是「可能发生」。按行业经验只是早晚问题。自从拥有系统开始,就等于自己签了那张无限期维护合同。

回想一个问题,SaaS 是什么?软件即服务,核心是服务,根本就没有提代码。

很多团队在内部系统上很执着,原因很直接:控制感强、改需求快、看起来省钱。上线半年以后,气氛通常变得不太好:需求排队、线上出过几次事故、业务抱怨响应慢、研发觉得自己在打杂。

这时候再看 SaaS,价值就很清晰了:SaaS 的核心商品是「运营表面积」的转移

代码只是其中一层,除了代码还有:

  • 基础设施与部署:多区域、容灾、备份恢复演练、变更管理。
  • 安全:漏洞扫描、依赖升级、密钥轮换、权限最小化、WAF、DDoS。
  • 合规:隐私条款、数据驻留、审计证据、流程制度落地。
  • 可靠性:监控告警、事故复盘、容量规划、灰度发布、回滚策略。
  • 支持与客户成功:工单、排障、培训、文档、FAQ、升级沟通。

当我们把软件「买回来」自己跑,这些都要自己补齐。很多公司低估的就是这一块。这也是为什么很多公司在 AI 赋能后,「运营表面积」的转移速度要慢于「代码」的转移速度。除非这些对公司不重要,如果这些都不重要, 这个系统可能也不重要了。

从 SaaS 的生命周期来看,AI 提升的是「0 到 1」,然而从成本的角度看,最贵的是「1 到 ∞」

这件事可以拆成两条曲线:

  • vibe coded 工具:初期成本很低,后期成本增长很快。越多人用、越多数据、越多流程依赖,它的「改动风险」和「维护面」指数上升。
  • 成熟 SaaS:初期采购成本看着不低,后期增长更接近线性。因为供应商把大量共性维护摊薄到所有客户身上。

AI 把 0→1 压得更便宜,直觉上会让人误判「买 SaaS 更不划算」。实际情况常常相反:AI 让 1→∞ 更贵了,因为我们会更频繁地改、更大胆地接更多业务进来,系统的负债增长速度被我们自己加速了。

这个成本不仅仅是 SaaS 软件的。

AI 让一个工程师单位时间产出更高,但单位工程小时的机会成本同步上升

至少当前的认知是这样的,可能到终极形态,完成不用人介入的时候,这个机会成本也会消失掉。

那是另一个话题了。

所以我对「AI 让 SaaS 价值归零」的判断是反的:AI 越强,成熟 SaaS 越值钱,前提是它真的把服务做扎实,真的帮我们把运营表面积吃掉。

SaaS 本质上还是一种服务。

如果 SaaS 只是「界面更好看的 CRUD」,那这样的 SaaS 确实会死掉一批。

这些 SaaS 太薄了。

在 AI 时代要想活得更好,SaaS 通常需要如下的一些特征:

  • 规则密度高,正确性要求高
  • 合规与安全负担重
  • 生态变化快,需要持续跟进
  • 故障代价高,客户不想背锅
  • 接口与集成复杂,长期维护吃人

Stripe、WorkOS、Cloudflare 这类产品的共同点很明显:它们难点不在「写出来」,难点在「长期把它跑对」。正确性要靠无数细碎决策堆出来,运营水位要常年拉满。

AI 始终会改写 SaaS,整体逻辑会有一些变化。这里的 AI 改写过程,肯定不是「加一个聊天框」「做一个总结」「做一个生成报表」。

我觉得至少有三个点在当前阶段能快速跟进:

  1. 意图驱动,SaaS 的用户最终都是想通过 SaaS 完成工作,以前靠 UI 引导的,现在可以让用户意图表达,然后把意图落为可审计的操作序列,不管是用 MCP,还是 SKILLS;
  2. 更关注结果,传统 SaaS 交付的是工具,客户负责把工具嵌进流程。AI 让厂商有机会把流程吃进去,直接交付结果,比如「自动完成对账」「自动完成入职」「自动完成工单分流」。关键点在「责任」
  3. 定制方式的迭代,企业客户永远会提定制。以前定制意味着项目制和人力黑洞;AI 让「生成」变得便宜,但不要把生成等同于可维护,可以允许客户用自然语言提出规则,系统把规则编译成可测试、可审计的约束,每次变更都能跑回归校验,出问题能定位到规则版本与变更人。

我们常听到对于自研和购买 SaaS 的一个判断逻辑是:「核心业务自研,非核心买 SaaS」。

这句话太粗,没有啥指导意义。

如下一个判断清单,可以做为决策的一些依据:

适合买 SaaS 的场景

  • 领域合规重:支付、税务、身份、隐私、审计
  • 失败代价高:一出错就上新闻、上法务、上客户群
  • 生态变化快:标准常变、监管常变、攻击手法常变
  • 需要对外背书:企业客户会问「谁负责」「有没有认证」「有没有 SLA」

这种场景自研的隐性成本巨大。AI 再强,也只是让我们更快地把「维护合同」签在自己身上。

适合自研的场景

  • 强差异化:流程就是你的竞争力,外部产品很难贴合
  • 业务规则变化快,且只对内部负责:错了能快速纠正,不会引发合规事故
  • 生命周期短:一个季度就会重构或下线的东西
  • 数据高度敏感,且已经有成熟的数据治理与安全团队

这里自研的价值很实在:迭代速度、贴合度、数据控制。

AI 时代的「自研陷阱」会更隐蔽

以前自研失败,多数死在「做不出来」。现在会死在「做出来以后一路堆债」。

AI 会在早期持续正反馈:

  • 功能做得快
  • Demo 好看
  • 业务觉得爽
  • 老板觉得省钱

债务也在同期累积:

  • 没有威胁建模
  • 没有权限与审计体系
  • 没有数据分级与脱敏
  • 没有灾备演练
  • 没有 SLA 与值班机制
  • 没有供应链安全策略(依赖库、镜像、密钥)

等到系统进入关键路径,会发现自己已经没有退路。再想补课,代价是「停业务」或者「带病重构」。

这也是我反复强调「拥有软件是负债」的原因。负债不会因为 AI 变聪明就消失,它只会增长得更快。

AI 把「做一个能用的软件」变成了常态,把「把软件长期跑对」推成了门槛。薄 SaaS 会被挤压,真正提供服务、背负责任、把运营表面积吃掉的 SaaS,会更值钱。

以上。