标签归档:Agent

如何构建行业 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 则为最小可运行原型提供了基础模板。这些方案展现出一个共识:上下文不一定要复杂,关键在于是否服务于目标。

以上。

Multi-Agent 系统的主从架构

最近一年,Multi-Agent 系统持续发热发烫,融资不断,火了起来。

从 AutoGPT 到 MetaGPT,从 CrewAI 到 LangGraph,各种多代理框架层出不穷。国内现象级的 Manus,以及当天由 MetaGPT 的同学开源的 OpenManus。OpenAI 的 Swarm、微软的 AutoGen,还有 Anthropic 的 Claude Code,每个大厂都在探索自己的 Multi-Agent 方案。GitHub 上相关项目的 Star 数动辄上万,社区讨论热度持续攀升。

从这股热潮,我们可以看出 AI 应用的一个重要趋势:从单一模型调用走向多智能体协作。就像软件开发从单体应用演进到微服务架构,AI 系统也在探索如何通过多个专门化的 Agent 协同工作,完成更复杂的任务。

当我们仔细观察这些 Multi-Agent 系统的架构时,会发现一个规律:

MetaGPT 里有个产品经理角色,负责协调其他工程师角色;AutoGen 支持 Manager-Worker 模式;Claude Code 更是明确采用了主循环引擎加子任务代理的设计。在 OpenAI Swarm 中,也能看到 Orchestrator Agent 的影子。

这些系统都采用了某种形式的「主从」架构——有一个 Agent 负责全局协调,其他 Agent 提供专门化支持。

为什么?巧合吗?

今天我们就聊聊 Multi-Agent 系统的主从架构。从大模型的底层原理开始。

1 从大模型的原理说起

1.1 大模型的「注意力」机制

要理解为什么需要主从架构,得先理解大模型是怎么「思考」的。

大模型的核心是 Transformer 架构,而 Transformer 的灵魂是注意力机制(Attention)。简单来说,模型在生成每个 token 时,会「注意」到输入中的所有相关信息(上下文窗口内),然后综合这些信息做出决策。

这里有个关键点:大模型的每次决策都是基于它能「看到”」的全部上下文

这就像你在做一道数学题。如果题目是”小明有 5 个苹果,给了小红 2 个”,你要回答”小明还剩几个”,你必须同时看到”5 个”和”给了 2 个”这两个信息。如果你只看到其中一部分,就无法得出正确答案。

大模型也是如此。它的智能来源于对上下文的完整理解(其智能还来源于预训练时学到的知识,模式识别、知识迁移等能力)。一旦上下文缺失或者矛盾,模型的输出质量就会急剧下降。

1.2 多个模型协作的挑战

当多个大模型(Agent)需要协作时,如何保证它们都拥有必要的上下文?

假设我们有三个 Agent 并行进行开发部署工作:

  • Agent A:负责前端开发
  • Agent B:负责后端开发
  • Agent C:负责部署运维

理想情况下,它们应该像一个经验丰富的全栈工程师一样,时刻知道其他部分的设计决策。但实际上,每个 Agent 都是独立的大模型实例,它们各自维护着自己的上下文。

这就产生了第一个问题:上下文分裂

Agent A 决定使用 React,Agent B 决定用 Python Flask,这本来没问题。但当 Agent A 后续生成代码时假设后端返回 GraphQL,而 Agent B 实际提供的是 REST API,最终代码就无法正常工作。

并且大模型有个特性叫「自回归生成」——每个新的输出都依赖于之前的所有输出。这意味着一旦某个 Agent 做出了错误假设,这个错误会在后续生成中不断放大。

2 主从架构的设计哲学

2.1 为什么主从架构有效

主从架构的核心思想很简单:一个指挥,多个执行。一个主 Agent 掌控全局,其他从 Agent 提供子领域专业化的支持

这个设计直接解决了上下文分裂的问题。主 Agent 始终维护着完整的任务上下文,它知道:

  • 整体目标是什么
  • 已经做了哪些决策
  • 各个部分如何配合
  • 当前的优先级是什么

从 Agent 则像是主 Agent 的「外脑」——当主 Agent 需要专门知识时,会调用相应的从 Agent,但最终的决策和执行都由主 Agent 完成。

在我们做具体实现的时候,每个不同的从 Agent 都有自己的角色和系统 Prompt。

2.2 Claude Code 的实践印证

Claude Code 的设计诠释了主从的理念。根据 Github 上逆向工程的分析,它的架构中:

nO 主循环引擎(主 Agent)负责:

  • 维护完整的代码上下文
  • 协调所有子任务
  • 做最终决策
  • 生成实际代码

I2A 子任务代理(从 Agent)负责:

  • 回答特定问题
  • 提供专业建议
  • 探索可能的解决方案

Claude Code 刻意避免了子 Agent 的并行修改。当需要调查多个方向时,主 Agent 会有限范围内并行地咨询不同的子 Agent,确保每个决策都基于最新的完整上下文。

这种设计看起来「低效」,但实际上避免了大量的错误和重做,总体效率反而更高。

2.3 生物学的启发

并且,主从架构在生物界也是有比较多例子的。

人脑就是一个典型的例子。前额叶皮质充当「主 Agent」,负责高级决策和规划。而各个专门脑区(视觉皮层、听觉皮层、运动皮层等)就像「从 Agent」,处理特定类型的信息。

所有的感官输入最终都会汇聚到前额叶皮质,由它整合信息并做出决策。即使是反射动作,大脑也会在事后「知晓」并可能调整后续行为。

这种中心化的架构经过了数亿年的进化验证。

3 主从架构的技术实现

3.1 上下文管理

实现主从架构,最核心的是上下文管理。主 Agent 需要:

1. 维护完整但精简的上下文

并不是所有信息都同等重要。主 Agent 需要智能地压缩和总结历史信息。Claude Code 使用了一个策略:

当 token 使用量达到阈值的 92% 时,触发压缩机制。关键决策被保留,而从 Agent 的中间探索过程被压缩或丢弃。这样既保持了决策的连贯性,又避免了上下文爆炸。

2. 构建结构化的决策记录

不要只是简单地拼接所有的对话历史。需要结构化地记录:

  • 任务目标和约束
  • 已做出的关键决策
  • 各决策之间的依赖关系
  • 待解决的问题队列

3. 动态调整上下文窗口

根据任务的复杂度和当前阶段,动态调整传递给从 Agent 的上下文量。初期探索阶段可以更开放,后期执行阶段需要更精确。

3.2 Agent 的设计原则

Agent 不是越智能越好,而是要专注可控

1. 明确的能力边界

每个从 Agent 应该有清晰定义的能力范围。比如:

  • 代码审查 Agent:只负责发现潜在问题
  • 重构 Agent:只负责改进代码结构
  • 测试 Agent:只负责生成测试用例

2. 标准化的输入输出

从 Agent 的接口要标准化,这样主 Agent 可以用统一的方式调用它们。输出格式也要规范,便于主 Agent 解析和整合。

3. 无状态设计

从 Agent 最好是无状态的,每次调用都是独立的。这样可以避免状态管理的复杂性,也便于并行化(当任务确实独立时)。

3.3 协调机制的关键点

主 Agent 的协调能力决定了整个系统的表现:

1. 任务分解策略

并不是所有任务都要分解。主 Agent 需要学会判断:

  • 简单任务直接处理
  • 复杂任务分解但保持上下文
  • 探索性任务可以并行但结果需要串行整合

2. 冲突检测与解决

即使在主从架构下,从 Agent 的建议也可能相互矛盾。主 Agent 需要:

  • 检测潜在的冲突
  • 评估不同方案的优劣
  • 做出最终决策并保持一致性

3. 优雅降级

当从 Agent 失败或不可用时,主 Agent 应该能够:

  • 尝试从其它从 Agent 获取
  • 降级到自己处理
  • 调整任务策略

4 主从架构的优势与局限

4.1 主从架构的核心优势

1. 全局一致性保证主 Agent 作为唯一的决策中心,天然保证了架构决策的一致性。不只是技术栈的选择(比如统一使用 REST 还是 GraphQL),更重要的是接口约定、错误处理策略、命名规范等细节都能保持统一。这种一致性在复杂项目中价值巨大。

2. 清晰的决策链路每个决策都有明确的来源和依据。你可以在主 Agent 的对话历史中追踪每个架构决定是如何做出的,为什么选择某个方案。这种可追溯性在调试问题或向他人解释系统设计时非常有价值。

3. 优雅的错误处理主 Agent 掌握全局状态,当某个子任务失败时,它可以准确判断影响范围并制定恢复策略。比如,如果数据库设计出错,主 Agent 知道哪些 API 设计需要相应调整。而在去中心化系统中,这种级联影响很难追踪和修复。

4. 上下文利用最大化看似串行的决策流程,实际上优化了整体效率:

  • 避免了重复劳动(多个 Agent 不会各自生成相似的代码)
  • 减少了协调开销(不需要 Agent 间的大量通信)
  • 上下文复用充分(主 Agent 的决策历史可以直接传递给从 Agent)

在 Claude Code 的实践中,这种设计让系统能在有限的 token 预算内完成相当复杂的编程任务。

4.2 主从架构的局限性

1. 主 Agent 成为性能瓶颈所有决策都要经过主 Agent,当需要并行处理多个复杂子任务时,主 Agent 的串行决策会限制整体效率。就像一个项目经理同时管理太多团队,协调成本会急剧上升。

2. 对主 Agent 能力的高度依赖系统的智能上限取决于主 Agent 的能力。如果主 Agent 对某个领域理解不深,即使有专业的从 Agent,整体表现也会受限。这就像一个不懂技术的经理,很难充分发挥技术团队的潜力。

3. 缺乏真正的协作智能主从架构本质上是”分解-执行-组合”的模式,缺少 Agent 之间的平等协商和创造性互动。在需要头脑风暴或多视角探索的任务中,这种层级结构可能限制了解决方案的多样性。

4. 任务分解的粒度难题主 Agent 需要准确判断任务分解的粒度。分得太细,协调成本高;分得太粗,从 Agent 可能无法胜任。而且随着任务复杂度增加,找到合适的分解方式越来越难。

4.3 适用场景分析

主从架构特别适合:

1. 工程化任务

  • 代码生成
  • 系统设计
  • 文档编写

这些任务需要高度的一致性和结构化。

2. 有明确目标的任务

  • 问题诊断
  • 数据分析
  • 流程自动化

目标明确时,中心化协调更高效。

3. 需要可控性的场景

  • 金融交易
  • 医疗诊断
  • 法律咨询

这些领域不能接受不可预测的行为。

不太适合:

1. 创意生成

  • 头脑风暴
  • 艺术创作
  • 探索性研究

2. 大规模并行处理

  • 日志分析
  • 图像批处理
  • 分布式爬虫

3. 对等协作

  • 多人游戏 AI
  • 群体仿真
  • 去中心化系统

5 小结

随着大模型能力的提升,主从架构也在演进:

  • 更长的上下文窗口:GPT-4 已经支持 128K 的上下文,Claude 3 甚至到了 200K。这意味着主 Agent 可以维护更完整的历史,减少信息损失。
  • 更好的指令跟随:新一代模型在指令跟随上有显著提升,从 Agent 可以更准确地理解和执行主 Agent 的指令。
  • 原生的工具调用:模型开始原生支持函数调用,这让主从 Agent 之间的接口更加标准化和可靠。

如果你要实现一个主从架构的 Multi-Agent 系统,以下是一些建议:

1. 设计清晰的 Agent 角色:不要让从 Agent 职责过于宽泛。每个从 Agent 应该像 Unix 工具一样——做一件事,并做好。

2. 实现鲁棒的错误处理

从 Agent 失败是常态,不是异常。主 Agent 需要:

  • 超时机制
  • 重试策略
  • 降级方案
  • 错误隔离

3. 优化上下文传递:控制上下文的边界,并不是所有上下文都需要传递给给到 Agent。根据任务类型,精心设计上下文的内容和格式。

4. 监控和可观测性:记录所有的决策点和 Agent 交互,后面调试和优化用得上。

Multi-Agent 的主从架构,本质上是在解决一个古老的问题:如何组织多个智能体高效地完成复杂任务

从生物进化到人类社会,从计算机架构到分布式系统,我们一次次地发现:在需要一致性和可控性的场景下,某种形式的中心化协调是必要的。

大模型的出现并没有改变这个规律。相反,由于大模型对上下文的强依赖,主从架构变得更加重要。

随着大模型能力的提升和 Agent 技术的成熟,我们会看到更多创新的架构出现。但无论如何演进,那些基本的原则——上下文一致性、决策可控性、错误可恢复性——都是我们在实践中需要谨慎考虑的。

以上。