去年我认真搭过一版三角色的 Agent:产品经理拆需求、开发写代码、测试做验收。日志里三个角色你来我往,产品经理输出三页 PRD,开发照着 PRD 列函数,测试按 PRD 的字面挑毛病,看起来特别像一支小团队。

跑了两周,我把产品经理这个角色删了,又把开发和测试合并成一个。效果反而更好。

原因不复杂。那个「产品经理」没有用户访谈、没有业务上下文,它做的事是把用户的一句话扩写成三页文档。开发再把这三十页压回几个函数。信息在两跳里损耗了两次,每次损耗还带着上一层角色的措辞习惯。测试 agent 更冤,它拿到的是 PRD 的字面,不是真实需求,于是它认真地验证了一堆没人要求的东西。

这不是说多 Agent 没用。它有用,但理由不是「多个角色更像人」。恰恰相反,越是把 Agent 往人的岗位上套,越容易得到一场表演。

一、多 Agent 的第一价值是上下文隔离

/AI/02/ 已经讲过子 Agent 的隔离价值,这里不重复论证,只补三个工程上的延伸。

第一,隔离的单位是注意力,不是人。一个子 Agent 的全部意义,是让它在一个只装相关材料的窗口里工作。它读三十个文件、试五次错、跑两轮测试,这些过程全留在自己的窗口;主 Agent 只收到一句结论。主窗口的增量从几万 token 降到几百,这才是收益的来源。

第二,隔离真正治的是上下文腐化。主循环跑到四十轮,窗口里混着试错记录、无关文件、半成品的判断,模型的判断质量会肉眼可见地下降——它开始忽略早期约束,开始在两个方案之间摇摆。这时候开一个干净的子窗口专门做一件事,比在主窗口里继续挤有效得多。腐化不是「信息不够」,是「信息太杂」,加信息治不了,只能换窗口。

第三,隔离有代价,代价是信息要重新获取。子 Agent 没有主 Agent 的历史,你不知道的它也不知道。背景传少了,它会在错误的前提上干活;传多了,隔离就白做了,等于把主窗口复制了一份。这个度,是下面第三节要解决的问题。

把这三条合起来,可以得到一个我觉得最准确的定位:多 Agent 的本质,是把一个装不下的大上下文切成几个装得下的,而不是把一个大脑变成几个大脑。能力没有变多,变多的是并行度和隔离度。任何期待「三个 Agent 比一个聪明三倍」的设计,最后都会失望。

账也要这么算。三个 Agent 各跑三十轮,token 是单 Agent 的三倍左右,再加上编排和汇总;换回来的是墙钟时间可能降到三分之一,以及每个窗口的质量更稳定。这笔交易值不值,取决于你更缺时间还是更缺预算。如果两者都不缺,单 Agent 慢慢跑往往更省心,因为它的状态是连续的,不需要在窗口之间搬信息。

二、四种拓扑

工程上能站住的多 Agent 结构,其实只有四种。它们的差别不在「有几个 Agent」,在「谁决定下一步」和「信息往哪个方向流」。

拓扑 结构 适用场景 主要代价
主从 一个编排者派活,多个执行者回报 任务可切分、子任务相对独立 编排者成瓶颈,汇总易失真
流水线 A 的产出是 B 的输入,串行推进 阶段清晰、每段职责单一 延迟叠加,上游错误被放大
对等辩论 多方就同一问题各给方案,互相批评 方案评审、开放性判断 成本高,易收敛到折中
群体投票 多方独立作答,取多数或共识 分类、抽取、有明确对错的判断 只适合可投票任务,错误可能相关

主从是最常见的一种,Coding Agent 的 sub-agent 就是它。主 Agent 拆任务、派活、收结论,子 Agent 在各自的窗口里执行。优点是扩展性好,加机器就能并行;缺点是主 Agent 成了单点,它的拆分质量和汇总质量决定整体上限。还有个隐蔽成本:所有子 Agent 的结论最后都要塞回主窗口,如果结论不做压缩,隔离省下的空间会被汇总重新吃掉。

流水线像一条 CI:需求分析、方案设计、实现、测试,一段接一段。它的优点是每段职责单一,prompt 可以写得很专;缺点是上游一个错误会被下游放大,而且下游没有能力质疑上游——它只看到上游的产物,看不到原始需求。所以流水线必须在每两段之间插验证点,否则错误会一路传到交付。

对等辩论适合「这个方案有没有漏洞」这类没有标准答案的判断。让两个 Agent 各写一版方案,再互相挑刺,确实能挖出单方想不到的问题。代价是 token 翻倍,而且辩论有一种很强的收敛倾向:双方最后会同意一个都能接受的折中方案,而折中往往不是最优。要让它有用,必须设终止条件和一个明确的裁决者,否则会无限礼貌地互相认同。

群体投票适合分类、抽取、事实判断这种有明确对错的任务。同一段文本让五个 Agent 各打一个标签,取多数。这里有个容易忽略的统计学问题:如果五个 Agent 用同一个模型、同一份 prompt,它们的错误是高度相关的,投票只能降低随机波动,纠不了系统性偏差。要真有效,得让它们看到不同的信息切片,或者用不同视角的 prompt。

四种拓扑不是互斥的。真实系统里最常见的是「主从套流水线」:主 Agent 把任务拆成几条流水线,每条流水线内部串行,流水线之间并行。选拓扑的时候问自己两个问题就够了——子任务之间有没有依赖,答案需不需要交叉验证。有依赖就走流水线,需要交叉验证就上辩论或投票,都没有就用主从并行。

三、上下文怎么传

多 Agent 系统里,绝大多数 bug 不是模型能力问题,是传过去的东西不对。我把传递原则压成三条,按重要性排序。

只传结论,不传过程。 子 Agent 读了三十个文件,主 Agent 不需要知道它读了哪些,只需要知道「问题在 order_service.py 第 142 行,原因是折扣计算用了浮点累加」。过程和结论一起传,等于把隔离取消掉。结论里要带证据位置,方便主 Agent 需要时回查,但不要带证据内容。

传契约,不传期望。 给子 Agent 的输入输出要写成规范:输入是什么结构、输出必须包含哪些字段、失败怎么表示。契约的好处是主 Agent 不用理解子 Agent 怎么做的,也能消费它的结果,甚至可以程序化校验。用自然语言写「帮我看看这里有没有问题」,子 Agent 会给你一段它认为合适的话,而你不知道该怎么用。

契约具体到什么程度?我的标准是:主 Agent 拿到子 Agent 的返回后,能用一段不依赖自然语言的代码判断它是否可用。比如要求「返回一个 JSON,files 是改动文件列表,tests 是跑过的测试及结果,status 是三态枚举」,主 Agent 就能直接解析、校验、决定下一步,而不需要再读一遍文字理解它到底做了什么。做不到这一点的契约,说明字段还没设计到位。

传路径,不传内容。 需要子 Agent 看某个文件,给它路径和范围,让它自己去读。不要在主 Agent 里读出来再粘贴过去——粘贴等于把同一份内容复制进两个窗口,既浪费 token,又容易不同步:主 Agent 读的是旧版本,子 Agent 拿到的是过期快照。

传递方式 传什么 好处 风险
结论式 一段结论加证据位置 主窗口增量小 丢失推理,主 Agent 难复核
契约式 schema 与字段约束 可程序校验、可并行 设计成本高,容易僵化
路径式 文件路径加读取范围 零复制,内容最新 文件可能被并发修改

这三条背后是同一个判断:跨窗口传递的每一字节都要付两次成本,一次是传输,一次是接收方的注意力。所以能传指针就不传值,能传摘要就不传原文。

四、通信成本与失真

多 Agent 最像人类团队的地方,不是分工,是传话游戏。

原始需求经过三层转述,到最后一层往往只剩一个轮廓。我做过一次粗略统计:一句「不要改动对外接口的返回结构」,经过三个 Agent 转述后,在最后一个 Agent 的上下文里变成了「尽量保持接口兼容」。「不要」变成「尽量」,「结构」变成「兼容」,两个词一换,约束就从硬性变成了建议。

失真有几个稳定的来源,认识它们比事后补救有用。

摘要偏差。 每个 Agent 判断「什么重要」的标准不一样。写代码的 Agent 觉得实现细节重要,做验证的 Agent 觉得边界条件重要,主 Agent 想要的却是「能不能交付」。三层各摘各的,拼起来就缺一块。

措辞漂移。 自然语言转述天然会向「更委婉、更通用」的方向滑。硬约束变软,具体数字变约数,否定句变肯定句。这不是模型不认真,是转述这个动作本身有损。

结论膨胀。 子 Agent 倾向于报告成功。它做了十件事,九件成了,一件没成,汇报时很容易写成「基本完成,剩余 minor issue」。主 Agent 读到「基本完成」,就当成完成了。

否定信息丢失。 「试过 X,不行」是最容易被省略的一类信息,因为它不是产出。但它恰恰是最值钱的——它能防止下一个 Agent 重走一遍。

减少失真的办法不是「让模型转述得更准确」,是换一种传递格式。我现在的做法是强制使用结构化交接单:

1
2
3
4
5
6
7
8
9
10
11
12
13
task_id: T3
status: partial # done | partial | failed | timeout
artifact: src/order/discount.py
evidence:
- discount.py:142 浮点累加导致 0.1+0.2 误差
- tests/test_discount.py 新增 3 例,2 通过 1 失败
not_done:
- 未验证并发场景,缺 fixture
failed_attempts:
- 用 Decimal 全量替换:影响 17 处调用,超出本任务范围
open_questions:
- 是否允许改 calc_total 的签名
next_hint: 先补并发 fixture,再决定是否引入 Decimal

几个字段值得单独说。not_done 强制子 Agent 交代没做什么,堵住「基本完成」的模糊地带。failed_attempts 保存否决理由,防止下一个 Agent 重走。next_hint 是建议不是指令,主 Agent 可以采纳也可以拒绝,但它给了主 Agent 一个起点。

这份交接单还有个副作用:它逼着子 Agent 在结束前做一次自检。写不出 evidence,说明它其实没验证;写不出 not_done,说明它没想过边界。格式本身成了质量检查。

但交接单不能太长。超过一屏,主 Agent 就开始只看前面的字段,后面的 open_questions 会被忽略,而那往往是最需要它决策的部分。我一般的上限是十五行:超过就说明子任务拆得太大,应该继续往下切。换句话说,交接单的长度是任务粒度的一个探针,读起来费劲的单子,背后通常是一个没拆干净的任务。

五、角色分工,还是能力分工

这是我最想劝人改的一点。

角色分工是把人的岗位映射到 Agent:产品经理、架构师、开发、测试、运维。它直觉上很好懂,演示效果也好,但它有个根本问题——Agent 没有岗位背后的东西。产品经理的岗位背后是用户访谈、业务目标和决策权,测试的岗位背后是独立的质量标准和发布否决权。这些都不在 prompt 里,Agent 只能靠措辞扮演,输出的自然是「看起来像产品文档的东西」。

更麻烦的是职责重叠。产品 Agent 写需求,架构 Agent 也写设计,开发 Agent 还要在代码里体现设计,三份文档互相引用又互相矛盾。你花在协调它们上的 token,可能比干活还多。

能力分工是另一种切法:不按「谁」分,按「能做什么」分。

分工方式 例子 优点 问题
角色分工 产品、开发、测试 直觉好懂,汇报好看 容易表演,转述损耗大,职责重叠
能力分工 读代码、写代码、跑验证 边界清晰,可验证,上下文需求明确 需要自己设计编排,不够「像团队」

按能力分,通常只需要三类:读(检索、理解、给结论)、写(按契约实现改动)、验(跑测试、比对产物)。这三类对应三种完全不同的上下文需求:读需要大量材料和检索能力,写需要精确的契约和较小的窗口,验需要确定性的工具和清晰的判定标准。

按能力分还有个直接好处:每一类的产出都能被验证。读的产出是结论加证据位置,写的产出是 diff,验的产出是退出码。角色分工的产出是「一份 PRD」,你没法判断它好不好,只能再找一个人来评审。

六、并行与冲突

代码场景下的并行,问题不在模型,在文件。

两个子 Agent 同时改同一个文件,会发生三件事。轻的是后写覆盖先写,先写的改动凭空消失;中的是各自基于旧版本修改,合并时冲突;重的是语义冲突——两个人改的是不同函数,但一个改了签名,另一个还在按旧签名调用,编译能过,运行时才炸。

我现在的处理顺序是这样的。

派活时就划定所有权:一个文件在同一时间只能有一个 writer。这条规则要在拆任务时就落实,不能等冲突了再协调。拆不出来说明任务粒度不对,应该继续拆到文件级或模块级。

确实需要共享时,用分支或 worktree 做物理隔离。每个子 Agent 在自己的工作副本里改,最后合并。这样即使改同一个文件,冲突也发生在合并阶段,可控、可回滚,而不是在写入时静默覆盖。

worktree 的好处是把「隔离」落到了文件系统一层,而不是靠约定。约定是会失效的:你在 prompt 里写「只改 A 文件」,模型仍然可能因为任务需要去改 B。worktree 让越界变成一个显式的合并动作,你能在合并前看见它到底碰了什么。

合并冲突不要交给模型「看着办」。用三方合并,冲突块保留双方,然后跑测试。测试过了才算解决,测试不过就回到人或者回到主 Agent 决策。让模型凭语义猜「应该保留哪个」,在代码里几乎一定会猜错,因为正确性不由可读性决定。

语义冲突靠集成测试,不靠 diff 审查。两个子 Agent 各自的单元测试都过了,合起来仍然可能是错的,因为单元测试不覆盖它们之间的调用。主 Agent 汇总后必须跑一次全量测试,这一步不能省,也不能信子 Agent 的「我这边测试过了」。

并行的收益也不是线性的。三个子任务里只要有一个是其余两个的前置,整批的墙钟时间就等于「那个前置的时间加其余两个的时间」,并不会比串行快多少。所以并行前先看一眼依赖图,把能真正并起来的放在同一批,剩下的老实排队,比一股脑全派出去更快。

七、失败处理

多 Agent 的失败不是二值的,是连续的:完全成功、部分成功、超时、失败。把这四种混成「成功/失败」,汇总时必然出错。

情况 识别 处理
可重试失败 限流、超时、临时 IO 错误 换参数重派,带上上次的错误
不可重试失败 前提不成立、文件不存在 回到计划层改步骤,不要硬重试
部分成功 有产出但验收不全过 保留可用产物,标记缺口,不整体重派
超时 超过硬时限 收集已有产出,标记未完成,交主 Agent 决策

重派有个细节很容易做错:不带上失败原因的重派,等于让新 Agent 把老路再走一遍。第一次失败可能是因为「这个文件不存在」,你不说,新 Agent 还会去找同一个文件。交接单里的 failed_attempts 就是为这个准备的,重派时原样带上。

部分成功最考验汇总逻辑。子 Agent 交了三个文件,两个对、一个错,整体重派会浪费前两个,只收对的又会留下缺口。我的做法是让主 Agent 做一次「决策」而不是「拼接」:哪些产出可以直接用,哪些需要补,哪些必须弃掉重做。拼接会把矛盾的半成品放在一起,看起来完整,实际不能用。

超时要设硬时限,而且要在派活时就设,不是等它跑。超时之后不要立刻杀掉,先让它把当前状态写成交接单——很多超时的任务其实已经完成了大半,产出是有价值的,只是没来得及收尾。

汇总时还有个优先级:先处理阻塞,再处理缺口,最后处理优化。因为阻塞会让后续所有子任务都跑不动,缺口只是少一块,优化是可选项。很多汇总逻辑写成了「按子任务顺序逐个处理」,结果主 Agent 花大量时间在一个不重要的子任务上打磨,真正的阻塞点一直挂着。

八、什么时候不该用多 Agent

这一节可能比前面所有节都值钱,因为多 Agent 的失败案例,一大半是「不该用的时候用了」。

任务步骤少。 五轮以内能做完的事,编排、派活、汇总的开销比干活还大。一个 Agent 直接做,又快又便宜。

强顺序依赖。 每一步都必须基于上一步的完整结果,拆成多个 Agent 只会退化成串行流水线,还多出两次转述损耗。这种任务适合单 Agent 加计划文件,不适合拆。

需要共享大量隐式上下文。 「按我们的代码风格改」「跟上次那个实现保持一致」,这类要求依赖大量没说出口的约定。隐式上下文没法通过交接单传递,子 Agent 只能猜,猜错的概率很高。

子任务无法独立验证。 隔离的前提是「子 Agent 能在自己的窗口里判断自己做对了没有」。如果它必须看到全局才能判断,那它就不该被隔离。

预算紧。 多 Agent 的 token 消耗是 N 倍起步,再加上编排和汇总。预算不够时,先把单个 Agent 的上下文管好,收益比堆数量高。

判断标准可以简化成一句:如果一个任务是「可以切开、切开后每块能自己验收」,用多 Agent;否则先把单 Agent 做到位。

还有一条更隐蔽的:任务处在探索期时也别急着拆。探索期连目标都还在变,拆出来的子任务是基于一个随时会作废的假设,跑完发现整个方向错了,所有子 Agent 的工作一起作废。探索期先用单 Agent 摸清结构,等目标稳定了再拆,这个顺序反过来做的成本很高。

九、一段 orchestrator 伪代码

主从拓扑的编排逻辑,剥掉业务细节大概是这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def orchestrate(task, workers, budget):
plan = decompose(task) # 子任务 + 依赖关系
results = {}

while plan.pending:
batch = plan.ready(done=results) # 依赖已满足的批次
for st in batch:
results[st.id] = dispatch(st, workers[st.kind], budget.slice())

for st in batch:
r = collect(st, timeout=budget.per_task)
if r.ok and verify(st, r): # 验收不通过不算完成
plan.done(st.id, r.artifact)
elif r.retryable and st.tries < 2:
plan.retry(st.id, note=r.reason)
else:
plan.block(st.id, reason=r.reason)

if plan.blocked_ratio() > 0.3: # 大面积阻塞,回到计划层
plan = replan(plan, reason="too_many_blocked")

return aggregate(plan, results)

四个动作对应四件事。

decompose 产出的是带依赖的子任务图,不是列表。列表没有依赖信息,ready 就只能靠猜。

dispatch 要控制并行度。一次派十个子 Agent,主窗口没爆,账单先爆,而且汇总时你要同时处理十份结论。我一般按依赖层派,一层三到五个。

collect 要带超时和状态,不能只有一个成功/失败的布尔值。部分成功、超时、可重试失败,这三种的处理完全不同。

aggregate 是决策,不是拼接。去重、消解矛盾、标记缺口、给出下一步。这一步最容易被写成「把所有结论贴在一起」,那样交出去的不是结果,是一份会议纪要。

常见的坑

  • 用角色代替能力。 产品、开发、测试三个角色演得很像,产出却没法验收。
  • 把子 Agent 的完整日志塞回主窗口。 隔离省下的空间,汇总时又还回去了。
  • 交接单只写做了什么。 不写没做什么、试过什么不行,下一个 Agent 会重走老路。
  • 无依赖信息就并行。 表面上快,实际在等一个还没产出的输入。
  • 合并冲突让模型判断。 代码正确性靠测试,不靠语义猜测。
  • 重派不带失败原因。 新 Agent 沿着同一条死路再走一遍。
  • 把部分成功当成功汇总。 交付时才发现缺一块。
  • 子 Agent 用同一个 prompt 投票。 错误相关,投票只能降方差,纠不了偏差。

检查清单

  • 能说清这次拆分的收益是隔离还是并行,两者都不是就别拆。
  • 四个拓扑选一个作为主干,混合时说明谁主导。
  • 子任务图带依赖,ready 由依赖决定而不是顺序决定。
  • 交接单包含 status、evidence、not_done、failed_attempts。
  • 跨窗口只传结论、契约或路径,不传原文。
  • 按能力而非角色分工,每类产出都有可验证的形式。
  • 文件所有权在派活时划定,同一文件同一时间只有一个 writer。
  • 汇总后跑一次全量验证,不信子 Agent 的自我报告。
  • 重派必须带上上次的失败原因。
  • 步骤少于五轮、强顺序依赖、隐式上下文多时,退回单 Agent。

多 Agent 这个词很容易让人兴奋,因为它听起来像组织、像协作、像某种更高级的智能形态。但把它拆开看,它解决的仍然是一个很朴素的问题:一个窗口装不下,就分几个窗口装。

真正难的从来不是「开几个 Agent」,是「切开之后怎么不丢信息、不互相踩、不把半成品当成品」。这三件事没有一件能靠增加 Agent 数量解决,只能靠契约、验证和明确的失败处理。

所以我的建议一直是反着来的:先把单 Agent 的循环、计划、验证做扎实,做到它确实撞上上下文的天花板,再考虑拆。拆的时候也别想着复制一个团队,想着怎么把一个大窗口切成几个小的、各自能验收的窗口就够了。

系列大纲与全部篇目见:Agent 原理与开发。

延伸阅读