把 subagent 折叠进主循环:多 agent 架构的一份减法指南

三条保留条件、五种失败模式、四步迁移路径:读 Anthropic Applied AI 的企业部署复盘

Posted by iceyao on Wednesday, November 11, 2026

一、一个反直觉的结论

过去两年,凡是稍微复杂一点的 agent 项目,架构图上几乎都会出现同一种形状:一个 orchestrator 在上面,下面挂着一排专家 subagent——路由、检索、分析、写作,各管一段。

Anthropic 的 Applied AI 团队最近给了一个相反的观察。他们在多个企业的 agent 部署里做了对比,结论写得很直白:

A single agent with skills frequently outperformed both the one-prompt-for-everything design and the subagent design on quality, and often at a lower cost and latency per task.

一个带 skills 的单一 agent,在质量上经常同时胜过「一个大提示包打天下」和「subagent 编排」两种设计,而且单位任务的成本和延迟往往更低。

他们的原话更尖锐一点:这些结构大多在做模型如今已经不需要它代劳的事。

这篇文章基于 Claude 官方文章《Building agents: When to fold subagents into your main agent loop》,以及它配套的迁移工具包 anthropics/single-agent-loop-kit。我不想把它写成一篇翻译,因为原文真正有价值的部分不是结论,而是结论成立的条件——什么时候该拆,什么时候该收,收的时候按什么顺序收,收错了怎么发现。

先说清楚一件事:这不是「多 agent 无用论」。Anthropic 自己的多 agent 研究系统至今仍在用 subagent 做并行检索,也明确承认 subagent 在验证、并行、模块化权限这三件事上不可替代。它要说的是:在企业里,绝大多数被拆出来的 subagent,拆的理由已经过期了。

二、subagent 当年解决了什么问题

要理解「折叠」,得先承认 subagent 不是拍脑袋设计的产物。它当年是三个真实约束的解法:

  1. 上下文隔离。一个负责检索的 agent 会往上下文里灌进几十份文档,如果主 agent 全程带着这些垃圾,推理质量会肉眼可见地下降。把脏活外包给一个用完就扔的上下文窗口,是最直接的解法。
  2. 真并行。三个独立调研同时跑,天然适合各开一个窗口。
  3. 权限与责任的边界。一个只能读工单的 agent 和一个能改生产配置的 agent,应该有不同的工具集、不同的审批链,甚至不同的 owner。

这三件事至今仍然成立,问题在于第四个理由——「模型自己搞不定,得靠架构帮它做决策」。

原文里有一句话点破了这层:很多企业 agent 的演进路径惊人地一致——先加一个意图分类器,再把它拆成固定的多步推理流水线,然后按用户类型分桶,再给每桶挂一个独立的推荐分支,最后在顶上盖一个多 agent orchestrator。

每一层在当时都是合理的补丁。但当模型能力涨上来之后,这些补丁的总和就变成了负债:它们用确定性的代码和固定的拓扑,替代了模型本来可以自己做的判断。

原文给的转折点是 Opus 4.5——从这个版本起,模型能在单一循环里管理的内容,远超多数团队的预期。更细的一个观察是:新模型会在执行过程中自己叙述进度、自己回头检查,于是 harness 里那些「让模型别乱来」的组件开始变得多余。Claude Code 面向更强模型重写系统提示时,删掉了 80% 以上的内容,其中就包括与 skills、tools 渐进式披露相关的一批规则。

这句话值得停下来想一下:删掉的不是功能,是防御性设计。 防御性设计在模型能力不足时是必需的,在能力足够之后就是纯粹的摩擦——它让 agent 变慢、变僵、变得不敢自己判断。

三、什么情况下应该保留 subagent

原文给的不是「感觉」,而是三条可以验证的条件:

该拆还是该收:三条保留条件与三条折叠信号

第一,单一循环出现了可测量的性能退化,且原因是上下文膨胀。

注意两个限定词:「可测量」和「上下文膨胀」。前者排除了体感,后者排除了「模型能力不够」。如果你的 eval 显示分数稳定,只是你觉得它「应该会乱」,那不算。如果你的分数掉了但原因是模型选错了工具,那也不该靠拆 agent 解决,该去改工具描述。

第二,任务确实需要并行,并且任务结束后那段上下文可以丢弃。

这是最干净的一条理由。三路检索、五个文件并行审阅、多语言同时生成——这些场景里,subagent 的价值不是「分工」,而是「用完即抛的临时工作区」。判断标准也很明确:这段上下文在任务结束后,还有没有任何一条信息需要留在主对话里? 如果答案是「有,而且很多」,那拆开就对你不利。

第三,单一 agent 难以选对工具,或者系统提示里已经存在互相冲突的指令。

这条是前两条的兜底。工具太多选不准,或者两套业务规则在一个提示里打架,这时候把冲突的一方隔离到一个独立上下文里,是合理的工程手段。但要注意,这两种情况都有更便宜的解法:工具选不准可以先做工具分组、tool search、deferred loading;指令冲突可以先做提示词的减法,而不是加一个 agent。

反过来,原文列了三条「折叠信号」,我觉得比那三条保留条件更有诊断价值:

  • 结构在替模型做它已经会做的事——意图分类、固定流水线、用户分桶。
  • agent 架构变成了组织架构的复印件。 原文用了康威定律的说法:每个团队各发一个 subagent,最后架构图长得跟汇报线一模一样。
  • 按「问题类型」切分,而不是按「上下文」切分。 原文的比喻很准:这会让 agent 之间玩起传话游戏,每次交接都损耗保真度。

第三条值得展开。按上下文切分的意思是:这个 agent 需要看这批数据,那个不需要。按问题类型切分的意思是:这个是「退款问题专家」,那个是「物流问题专家」。后者的划分依据是人的分工习惯,不是数据的边界——而真实的问题经常横跨两类,于是两个专家互相转交,每转一次丢一层细节。

四、五种失败模式:代价没有消失,只是换了个地方

拆开之后,那些被「架构」吸收掉的复杂度并没有消失。原文列了五种在企业里反复出现的失败模式:

五种失败模式:拆开之后,代价换了个地方出现

上下文管理。 一旦 agent 之间需要交换信息,你就必须回答一个问题:传什么?传多了浪费 token,传少了丢细节。而且这个决策是每次交接都要重做一遍的。单一循环里,这个问题根本不存在——所有东西本来就在同一个窗口里。

子代理泛滥。 每个团队都想给自己的工作流配一个 agent。一年之后,你的系统里有几百个功能重叠的 subagent,没有统一标准,没有明确 owner,谁也不敢删。

Frankenprompt。 系统提示变成了公共黑板:每个团队往上面加一句自己的规则。加到最后,规则之间开始互相打架,语气开始不统一,而没有人有权限删掉别人的那一段。

未经审核的、过度局部的 eval。 每个团队都在给自己那个子任务加评测,分数越刷越高。但没有人对整条链负责,于是领导层拿着被稀释的局部分数做决策——每个格子都是绿的,整体体验是断的。

延迟。 原文给了一个具体的对比数据:某客户把多 agent harness 换成单 agent loop 之后,运行时大约快了 2 倍。原因很朴素——每次调用 subagent 都是一次嵌套的模型循环,而用户是在等整条链跑完。

这五条其实是一个老问题的新版本:分布式系统的复杂度,从来不会因为拆分而消失,只会从「实现」转移到「协调」。 而在 agent 场景里,「协调」的成本格外高,因为交接的介质是自然语言摘要,每一次都是有损压缩。

五、单一循环长什么样

如果折叠,目标形态是什么?原文的描述很克制,但每一句都有信息量:

单一循环的解剖:写计划的模型,就是执行计划的模型

一个模型,一个上下文窗口,跑一个开放式的工具循环。 每一轮,模型发出一批工具调用,harness 并行执行,把原始结果(不是摘要)返回给同一个模型;模型看着这些结果决定下一步——再来一批、向用户提问、或者给出答案。停止条件只有两个:模型给出答案,或者撞上预算。

这里有个容易忽略的细节:结果要原样返回,不做摘要。 摘要是有损的,而写摘要的那个环节往往没有足够的上下文判断什么重要。单一循环之所以在质量上常常更好,很大一部分原因就在这里——模型看到的是原始数据,不是别人嚼过的版本。

限制从提示词搬进了 harness。 轮次预算、成本预算、写操作闸门(write gates),这些是工程师能确定性控制的东西,就不该指望提示词去约束。这是「折叠」这件事里最容易被误解的一点:折叠不是「什么都交给模型」,而是把「判断」交给模型,把「约束」交给代码。

计划由模型自己写,写在一个它自己能改的地方。 原文这句话是整篇的技术核心:

The model that writes the plan is also the one carrying it out, so it can change the plan mid-turn.

写计划的模型,就是执行计划的模型,所以它能在轮次中途改计划。

这是相对「orchestrator + 专家 agent」最本质的差别。在编排架构里,计划是协调者写的,执行者只能照做;发现计划有问题时,唯一的路径是把问题往上抛,等协调者重新规划。而在单循环里,计划就是上下文里的一段文本,模型一边执行一边修订它——规划的频率从「每个任务一次」变成了「每一轮都可能」。

上下文仍然会被加载,但由模型自己决定加载什么。 原文把这件事拆成了三类去处,这个拆分比「用不用 RAG」重要得多:

  • 顺序与领域流程 → skills。 某个团队做事的步骤、判断、取舍,原本写在专家 subagent 的 prompt 里,现在变成一份可以按需加载的 skill。
  • 硬性限制和对话中临时出现的需求 → tools。 校验、审批闸门、memory lookup,这些是「调用时才需要」的东西,做成工具比塞进提示词更可靠——因为工具是确定性的,而且能在工具内部做检查。
  • 代码仍然有用,但只用在两个地方。 一是加载「便宜且几乎总是相关」的内容(比如实体消解),二是在工具内部处理机械部分(构造 payload、解析流、恢复澄清流程)。代码不再负责编排。

我得说,这套划分最有价值的地方,是它给了「这段逻辑该放哪」一个明确的判据。实际项目里最常见的争论是「这个规则写提示词还是写代码」,而原文的回答是:需要模型判断的写提示词(skill),需要确定性保证的写工具,需要在工具调用之间传递状态而且总是要用的,才写代码。

六、四步迁移:一次只改一件事

原文最实用的部分是迁移路径。它反复强调一件事:不要一步到位。

四步迁移:从多 agent 编排走到一个主循环

第 0 步:先建任务完成度 eval

这是整条路径上最难、也最容易被跳过的一步。原文的建议很务实:哪怕只有 10 个 golden examples 也足以起步。

结构上分两层:一个是中央团队拥有的共享端到端 eval 集,另一个是每个 skill 由所属团队自带的小 eval 集。前者保证整体不退步,后者让团队能自己迭代。

指标也要跟着架构演进。还有 orchestrator 的时候,除了看最终答案质量,还要追踪路由准确率——是不是选对了 subagent。折叠之后,这个指标就换成了是不是加载了正确的 skill、调用了正确的 tool。原文还提了一句长期方向:要向 task-completion evals 演进,因为跨架构比较时,只有端到端的完成度是可比的。

内部系统做不到回放、用户交互难以模拟怎么办?原文给了一个很轻的办法:给重要事件打时间戳,之后就能把真实流量回放成定向 eval。

第 1 步:合并领域 agent

第一次合并之前先建一个小 eval。然后按「共享上下文」折叠,从使用量最大的 subagent 开始——这条很关键,因为它同时最大化了收益,也最小化了风险敞口(出问题最容易发现)。

怎么判断谁该跟谁合并?看有没有这三种关系:互相串接输出、访问同一份数据、经常被一起调用。原文给了一个很具体的信号:如果生产流量里有相当比例是「专家 A 之后紧跟专家 B」,那这就是一对紧耦合的专家,是一个领域 agent 的候选。

第 2 步:把 subagent 当成工具调用

如果某个 subagent 满足第三节那三条保留条件、决定先不折叠,那也还有一步可以做:让主 agent 把它当作工具调用,而不是做完全交接。

这一步的价值被严重低估了。因为主 agent 仍然持有与用户的对话,所以你可以:

  • 给所有 subagent 定义共享的 response schema;
  • 让主 agent 用真实数据核验 subagent 的结论;
  • 在最终综合之前裁剪输入。

更好的是,这一步不需要重写 subagent,而且它天然产出了一个 baseline:折叠前和折叠后用同一套 eval 比,谁赢谁留。

原文也很诚实地列了这一步没解决的问题:每个专家仍然各有 prompt、上下文、owner 和 eval;每次调用仍然返回有损摘要;每次调用仍然是嵌套模型循环,延迟照旧。所以它是过渡态,不是终态。

第 3 步:用 skills + tools 折叠

一次折叠一个。 把那个 subagent 的 prompt 变成 skill,把它的 API 调用变成 MCP tool。然后跑同一套 eval,对比折叠前后。

这里有一个我认为整篇文章最值得记住的细节:

Don’t just examine the final score, take a look at which tasks flipped.

别只看最终分数,要看哪些任务发生了翻转。

原文举了一个真实案例:在一个客服 agent 上折叠某个 subagent 之后,总延迟下降了,但一个原本通过的流程坏了——主 agent 手里有订单查询工具,于是它自己去查了订单,直接回答了用户,没有再去问物流专家要配送日期。

这个案例的价值在于它同时说明了两件事:

第一,聚合分数会掩盖结构性问题。 总分可能还是涨的,但某条业务链路已经断了。 第二,这种断法是概率性的。 原文特别注明:这个 break 在两次运行里只出现了一次。

所以原文给了两条硬要求:eval 必须覆盖生产环境中每一个会串起来跑的 agent 链,以及每一条 agent 不得违反的规则;并且每个任务要跑不止一次。跑一次就宣布「折叠无损」,等于在掷硬币。

七、多团队怎么共建一个 agent

折叠之后还有一个组织问题:原来每个团队有自己的 agent,现在只有一个 agent,所有权怎么分?

原文的答案是把 ownership 从「agent」转移到「skills 和 tools」:领域团队继续拥有自己那部分知识,但拥有的是 skill 和 tool,而不是一个独立进程。一个小型中央团队保留系统提示与端到端质量的 ownership,并负责在发布前审核新的 skill、tool 和 eval。

这个安排解决了 Frankenprompt 和子代理泛滥两个问题——因为现在有一个明确的、有权说不的角色。

具体到三类载体,边界是这样切的:

载体 什么时候用 治理要点
MCP tools 需要执行动作、读取实时数据、返回固定形状结果 按用户意图分组而不是一 API 一 tool;工具内部做参数校验和权限检查
Skills agent 需要知道某个团队「是怎么做事的」——步骤、规则、判断 每个团队设 DRI;用工具审计成本与调用频率,删掉死重量
知识库 agent 只需要偶尔用到的参考资料 放在搜索工具后面,别让代码检索完把上下文粘进 prompt

有三个数字值得单独拎出来:

工具定义超过 30–50 个,工具选择能力往往开始退化。 这个阈值比大多数人想象的低。所以「按用户意图分组」不是风格问题,是能力问题——把 40 个细粒度 API 收敛成 5 个意图级工具,通常比任何提示词优化都有效。

权限检查应该放在工具里,而不是放在 agent 里。 原文的建议是每个工具自己检查调用者能看什么、能做什么,返回一段模型能读懂的拒绝信息。这样一个 loop 就能服务不同权限级别的用户,而不必按权限级别各配一个 agent。这条我觉得是整个文档里工程价值最高的一句——它把一个架构问题降级成了一个函数内部的 if。

skill 也会泛滥。 原文的解法是 DRI 加工具:/skill-creator 保证新 skill 起步即规范,并用来审计存量、去重、裁剪;/skill-doctor 用来看每个 skill 的成本和实际使用频率,删掉那些写得很好但从来没人加载的。

八、这套建议没有回答的地方

我认同这篇文档的方向,但它有三处我觉得需要读者自己补上判断。

第一,证据的形态是「跨多个部署的观察」,而不是可复现的基准。 除了「单 loop 大约快 2 倍」这一个延迟数字,质量侧的结论没有公开的分数、数据集和对照条件。这不代表结论不对,但它意味着:你不能直接引用它来说服你的团队,你只能自己测。

第二,它把最难的部分放在了第 0 步,用一句话带过。 「建一个端到端 eval,哪怕 10 个 golden examples」——听起来很轻,实际上这是整件事的门槛。没有可信的 eval,你就无法判断「上下文膨胀是否导致了可测量的退化」,也就无法判断该保留还是该折叠。换句话说,这套方法论的适用前提是:你已经有能力测量你的 agent。 没有这个前提,折叠就是凭感觉重构。

第三,skills 的渐进式披露,本质是把路由从架构层下沉到了注意力层。 这是个很漂亮的想法,但它并没有消除路由问题——它只是把「选哪个 subagent」换成了「模型能不能从 skill 描述里认出该加载哪个 skill」。而 skill 描述写得含糊、名字起得重叠,同样是新的失败点。原文提到的 skill-doctor 和 DRI 治理,正是对这个新失败点的补丁。

那什么情况下应该继续用 subagent?我按原文的三条条件,加上自己踩过的坑,整理成四个「别折叠」的信号:

  • 任务是长时并行的,且每一路的中间过程都不该污染主对话;
  • 需要硬隔离——不同权限、不同计费主体、不同数据边界;
  • 需要异构模型——某一段用便宜模型跑,某一段必须用最强的;
  • 需要干净的验证上下文——让一个没看过推理过程的 agent 去审结果。

这四条都有一个共同点:它们的价值来自「不共享上下文」,而不是来自「分工」。 只要你的拆分理由是「分工」,它大概率应该被折叠。

九、结论:原则比架构长寿

原文的收尾我几乎原样同意:

Any one architecture [is] less important than the principle behind it: measure, change one thing at a time, and keep what holds up.

任何单一架构都不如它背后的原则重要:测量、一次只改一件事、保留经得起验证的部分。

以及那句我觉得可以贴在墙上的操作指南:

Build a small end-to-end eval, fold in one subagent, and keep it as a subagent only if the folded version scores worse, then rinse and repeat.

建一个小型端到端 eval,折叠进一个 subagent;只有当折叠版得分更差时才把它保留为 subagent,然后重复。

如果要把这篇文档压缩成一张检查表,我会这么写:

  1. 你能说清楚当前架构里每一个 subagent 是为了哪条保留条件而存在的吗?说不出来的,就是候选折叠对象。
  2. 你的 eval 能区分**「总分下降」和「某条链路断了」**吗?跑一次还是跑多次?
  3. 折叠的顺序是不是从用量最大的开始、按共享上下文分组?
  4. 硬约束是不是都在 harness 和工具内部,而不是在提示词里?
  5. 工具数量是不是已经超过 30–50 个?权限检查是在工具里还是在 agent 里?
  6. 有没有一个有权说不的中央 owner,负责系统提示和端到端质量?

最后说一句我自己的判断。这篇文章真正在讲的,不是「多 agent 过时了」,而是架构的职责边界应该随模型能力一起移动。当年我们把判断外包给代码,是因为模型做不好;现在模型能做好的部分,就该还回去——留下来的架构,只负责模型确实做不到的事:确定性、隔离、预算和审计。

模型越强、agent 跑得越久,能还回去的东西就越多。但这件事不必一步到位。建一个小 eval,折叠一个,用数据决定去留,然后重复。

「真诚赞赏,手留余香」

爱折腾的工程师

真诚赞赏,手留余香

使用微信扫描二维码完成支付