上一讲改完工具层之后,我做了一件现在回头看很蠢的事。
选题助手稳定了一点,我就开始想:既然它现在又能读历史、又能生成、又能保存,那是不是该把它拆成三个角色——一个研究员负责查资料,一个写手负责生成选题,一个审稿的负责挑毛病?听起来特别像团队协作,也特别像各种框架 demo 里的标准姿势。
拆完跑了一次,发生了四件事。
第一件:它变慢了,也变贵了。 原来一三轮就能结束的任务,现在三个角色各跑各的,加上互相交接,一次要十几次调用。
第二件:我那句最关键的要求丢了。 我说的是“给完全没写过代码的人看的入门向”。研究员收到了这句话,转述给写手时变成了“目标读者:技术初学者”。写手看到的是这八个字,不是我那句话。最后产出的五个选题里,有一个叫《Agent 编排模式综述》。
第三件:它们开始互相甩锅。 审稿的说“资料里没有足够的读者画像,我无法判断难度”;写手说“我按研究员给的材料写的”;研究员说“我查了 published 和 notes 两个来源”——它确实查了,但查到的东西里没有一项是关于读者是谁的。
第四件,也是最要命的:我不知道该改哪里。 三个角色各有各的 prompt、各有各的上下文。要让输出变好,我得同时改三份东西,而改完其中一份,另外两份的表现也会跟着变。
最后我把三个角色删了,改成两段固定的阶段。同样的任务,调用次数少了一半,输出反而稳定了。
这一讲要讲的就是这件事:什么时候该拆,什么时候千万别拆。 而且尽量给能判断的依据,不是口号。
先给一句结论,后面所有内容都围着它展开:
多 Agent 不是让系统变聪明,是让每一份上下文变小。
它的推论是:如果你的问题根本不是“上下文装不下”,那拆成多 Agent 就只是把一次调用变成很多次调用——多付钱、多等时间、多几个可以出错的地方,然后得到一个更难调试的系统。
阅读提示:本文是「Agent 工程进阶」系列的第 4 篇,面向已经跑稳一个 Agent、正在考虑要不要把它拆成几个的读者。如果你还没做过第一个 Agent,建议先看新手系列的让 Agent 更像项目:工具、记忆、文件读写和简单界面。如果你想要一张整体地图,可以看第 0 篇从 Demo 到可交付:如何做一个 Agent 项目。
一、先分清:编排、工作流、多 Agent 是三件事
这三个词在中文语境里经常被混着用,但它们说的根本不是同一个层面。混着用的后果是:你以为自己在解决“流程不清晰”,实际动手做的是“多开几个模型”,然后发现两个问题都没解决。
先看一个最小的 Agent 循环:
拿到输入 -> 决定做什么 -> 调工具 -> 看结果 -> 决定下一步 -> ... -> 可以回答了 -> 结束
这里面**「决定下一步」这个环节,就是编排**。
也就是说:编排不是一个可选的高级特性,只要有 Agent 就一定有编排。 区别只在于这个“下一步”是谁决定的、能不能被你看见。
于是有三样东西:
| 名称 | 谁决定下一步 | 一句话定义 |
|---|---|---|
| 编排 | 无所谓 | 「决定下一步」这件事本身。任何 Agent 都有 |
| 工作流 | 代码 | 步骤由你写死,模型只在每个节点里做那一步的事 |
| 多 Agent | 另一个模型 | 把决策权也交出去,由多个角色靠互相交接推进 |
Anthropic 在那篇讲怎么构建有效 Agent 的工程博客里用了很接近的切法:workflow 是“LLM 和工具按预先写好的代码路径编排”,agent 是“LLM 动态决定自己的流程和该用哪些工具”。
关键在于怎么理解这三者的关系。很多人心里有一条默认的升级路径:
单 Agent -> 工作流 -> 多 Agent(越往右越"高级")
这条路径是错的。它们不是先进程度的阶梯,而是自由度的光谱:
可预测 <--------------------------------------------> 自由
工作流 单 Agent 循环 主从式多 Agent 对等协作
越往右,模型能自己决定的事越多,你能提前确定下来的事越少。对一个要交付的系统来说,“能提前确定”是一种资产,不是限制。
所以第一个要建立的判断习惯是:不要问“我该不该上多 Agent”,先问“这件事的下一步,我能不能自己写死”。能写死的部分越多,系统越好预测;只有写不死的部分,才值得交给模型去决定。
二、什么时候千万别拆
先说不拆的,因为绝大多数人踩的坑都在这半边。
下面五条,每条我都尽量给一个可以当场做的判断方法——不是“看情况”“视复杂度而定”这种废话。
判断一:交接能不能无损
这是最根本的一条,也是开头那个事故的直接原因。
拆 Agent 有一个绕不过去的代价:下游拿到的不是你的原话,是上游的转述。
而转述一定会丢东西。丢的不是随机的部分,是上游认为不重要的部分——恰恰经常是你最在意的那部分。我那句“给完全没写过代码的人看”,在研究员眼里显然不如“目标读者:技术初学者”来得专业,于是它被压缩掉了。
怎么判断:
交接损失测试。 在你的原始需求里挑一条最具体、最容易被泛化的约束(比如“不要教程向”“面向完全没写过代码的人”“控制在 800 字以内”)。跑三次完整任务,看最终输出里有没有体现。三次里丢两次,说明你的交接在丢东西。
这个测试之所以有效,是因为它测的不是“结果好不好”这种主观判断,而是“一条具体约束有没有活着走到终点”这种客观事实。
它的推论很硬:如果某句话必须原样到达下游,就不要让它经过一个模型的转述。 要么用代码把它透传过去(第六节会做这件事),要么干脆别拆。
Anthropic 在介绍他们的多 Agent research system 时提过一个细节:子 Agent 不是把完整上下文传回给主 Agent,而是把结果写进外部文件系统、只交回引用。原因就是这个——上下文太大,传不回来;硬要传,就得先压缩,一压缩就丢。
判断二:几步之间要不要来回改
第二条看的是任务结构:这几个步骤是线性的,还是强耦合的?
线性的意思是:上游做完,把产物交给下游,下游不需要回头。强耦合的意思是:做第二步的时候要反复回头看第一步的中间产物,改一点、再看、再改。
写作、改稿、重构代码、调参数——全都是强耦合的。这类任务拆开之后,就变成“你改一点、我改一点”的来回,每来回一次都要重新交接一次上下文,而每交接一次就多一次丢失的机会。
怎么判断:
中间产物测试。 问自己:这一步的中间产物,是不是“只有做完才知道对不对”?如果是,它就是强耦合的,别拆。
我那次事故里最荒唐的一段就在这里:我让审稿的去改写手的东西。两个来回之后,两个角色开始互相说服——写手说“这是风格选择”,审稿说“这不符合定位”。它们不是在协作,是在各自基于不完整的上下文维护自己的立场。
判断三:单 Agent 是不是其实还没到瓶颈
这一条最常被跳过,也最省钱。
很多人想拆 Agent,是因为“它不够好”。但“不够好”的原因有很多种,其中大部分在多 Agent 之外,而且解法便宜得多。拆之前,先按顺序做三轮减法:
第一减:工具是不是太多? 回到第 3 篇——单个 Agent 常开工具超过 12 个,模型就开始挑错。这是我在 Agent 项目里见过最被低估的稳定性变量,而且它跟“要不要拆”完全无关:工具没减下去,拆成三个 Agent 只是把同一个烂工具列表复制三份。
第二减:上下文是不是太脏? 回到第 1 篇——压缩、隔离、缓存、选。很多“它跑着跑着就不行了”其实是上下文污染,不是架构不够复杂。
第三减:任务描述是不是太模糊? 这一条不是工程问题,是需求问题,但极其常见。把“帮我做几个选题”变成“什么样的选题算好:不重复、有明确切入角度、面向某类读者、能拆出三点大纲”,一个 Agent 就能稳很多。
怎么判断:
先跑 20 个真实用例。 记录单 Agent 在哪一步出错。错误集中在“挑错工具” → 第 3 篇的问题;集中在“忘了前面的要求” → 第 1 篇的问题;集中在“输出标准每次都不一样” → 验收标准没写清楚,拆成三个 Agent 只会得到三份不一致。
最后半句值得单独强调。多 Agent 不会消除不一致,它会放大不一致。 一个角色输出不稳定的时候,正确的做法是先把它做稳定,而不是再找两个角色来投票。
判断四:出错了你查得出来吗
这一条是硬门槛,不是优化建议:没有 trace 就不要拆。
具体地说,你要能回答三个问题:这次失败发生在哪一步?那一步的 Agent 当时看到了什么?它当时有哪些工具可选?
一个 Agent 的时候,这已经不容易;三个 Agent 的时候,你要能按步骤回放每一步的完整输入。做不到,你就只能靠猜——而靠猜调 prompt 的结果,通常是把 A 改好、把 B 弄坏。
最低要求是这样的:每一次模型调用记一条结构化日志。
{
"step_id": "run-7f3a/2",
"role": "research",
"input_digest": "goal + constraints + artifacts 的摘要,不是全文",
"tools_available": ["list_topics", "suggest_topics"],
"output": "...",
"tokens": {"in": 1840, "out": 620},
"ms": 3100
}
注意 input_digest 那一项:不要记全文(会膨胀、也可能含敏感内容),但要记到能回答“它当时看到了什么”。
第 5 篇讲评估时会回到这里:编排决定了 trace 的最小单元。 没有阶段划分的系统,一次失败只能打一个总分,你永远不知道是哪一步拖累的。
判断五:成本和延迟你接受吗
最后算一笔账。
成本不是线性翻倍的,是超线性的。 因为每多一个 Agent,不只是多一次采样:它还多一份系统提示词、多一份交接内容,而且交接内容经常要重发好几遍。
粗略的量级感受:
| 结构 | 模型调用次数(一次任务) | 延迟 | 说明 |
|---|---|---|---|
| 单 Agent 循环 | 4 ~ 6 次 | 串行累加 | 上下文复用,缓存命中率高 |
| 三 Agent 串行 | 10 ~ 15 次 | 累加,更长 | 每换一个角色,上下文基本重建 |
| 三 Agent(两个并行) | 10 ~ 15 次 | 略短 | 延迟省一部分,token 一点没省 |
Anthropic 公开介绍他们的 multi-agent research system 时明确提到,这类系统消耗的 token 量级远高于普通对话交互。这不是他们做得不好,是这个结构本身的固有成本。 你要换来的东西(装得下更多材料、能并行调研)必须值这个价。
还有一笔更容易被忽略的账——错误率会沿着步骤叠加:
单步正确率 95%,5 步串行的端到端正确率 = 0.95^5 ≈ 77%
三个角色各跑 3 步(共 9 步) = 0.95^9 ≈ 63%
你没看错:每一个“更聪明”的角色加进来,都在给整条链增加一次出错的机会。 除非并行真的省下了步骤,或者拆分真的提高了单步正确率,否则多 Agent 在数学上是亏的。
五条说完了。如果这五条里你有两条以上答不上来或答得不好,我的建议很直接:先别拆,回到判断三去做那三轮减法。
三、什么时候真的该拆
说完别拆的,再说该拆的。四条信号,基本就是上面五条的反面。
信号一:上下文确实装不下。 不是“感觉有点多”,是用第 1 篇那张上下文账单算出来装不下。典型场景:要处理的材料本身就有几万甚至十万 token,而且各块之间互不相干。这时候拆不是为了分工,是为了让每个上下文都还装得进去。
信号二:子任务真的可以并行,而且写的东西不冲突。 判断标准是:两个子任务会不会写同一个东西? 会写同一个东西就不要并行。正面例子:同时调研 5 个方向,各自产出独立的小结,最后统一汇总——这种是真并行,收益也是真的。
信号三:需要不同的权限边界。 这是最正当、却最少被提到的理由。让“能读生产库”的角色和“能写文件”的角色不在同一个上下文里,是安全上的硬需求,不是性能优化。第 7 篇讲权限分级时会展开,这里只要记住:权限隔离是拆分的正当理由,而且几乎无法通过调 prompt 来替代。
信号四:需要不同的模型或不同的判准。 生成要发散,审查要严格。同一个上下文里跑两种温度,是互相拖累。这一条也解释了为什么“生成 + 审查”是少数真的成立的两 Agent 结构——但必须接上判断二:审查只判断,不改写。 一旦让审查去改,它就变成第二个写手,两个角色开始互相说服。
一句话收口:
命中两条以上再拆。只命中一条,先用更便宜的方式解决。
比如只命中信号四(想加个审查环节),那根本不需要第二个 Agent——在同一个流程里换一次温度、换一套提示词跑一遍,就是“审查阶段”,成本只有多一次调用。
四、五种形态,怎么选
把常见的编排形态排成一列,方便对号入座:
| 形态 | 谁决定下一步 | 什么时候用 | 主要代价 |
|---|---|---|---|
| ① 单 Agent 循环 | 模型 | 默认起点,覆盖大多数场景 | 步数不可控,可能绕圈 |
| ② 固定流水线(提示链) | 代码 | 步骤确定、中间产物有明确结构 | 灵活性低,改流程要改代码 |
| ③ 路由分发 | 模型(只做一次分类) | 输入类型分明、各类型处理路径差异大 | 分类错了全错,必须给兜底路径 |
| ④ 主从(编排者 + 子 Agent) | 主 Agent | 真并行,或上下文确实装不下 | 交接损失、成本高、归因难 |
| ⑤ 对等协作(角色互相讨论) | 大家一起 | 基本不建议 | 收敛不了,出错无法归因 |
几条我自己的经验:
形态 ② 是性价比最高的一次升级。 把“一条大 prompt 干到底”改成“两段固定阶段”,不用动架构,只动 prompt 和代码边界,就能解决大部分“输出不稳定”。第六节做的就是这件事。
形态 ④ 是唯一值得真的上多 Agent 的地方,前提很明确:子任务写的东西不冲突,而且主 Agent 只负责分发和汇总,不参与子任务的具体推理。
形态 ③ 的关键在兜底。 分类器的准确率永远不是 100%,永远要有一条“分不出来的时候走哪”的路径——通常是转给人,或者退回一个保守的通用路径。
形态 ⑤,我的建议是别用。 除非你在做仿真、辩论这类研究性实验。Cognition 那篇《Don’t build multi-agents》把这个结构的问题说得最狠:多个 Agent 各自基于部分上下文做决定,做出的决定互相冲突,而且没有任何一方掌握足够信息来解决冲突。“让几个模型自己讨论出结论”听起来很美,实际是让冲突隐藏起来,直到它变成最终输出里的一句胡话。
五、如果真的拆了,靠什么不出事
这一节是给已经决定要拆的人的。六条机制,按重要性排序。
1. 交接用结构化 state,不用自然语言转述
这是最重要的一条,直接对冲判断一的风险。
# src/state.py
@dataclass
class State:
goal: str # 用户原话:初始化时写入,此后只读,任何阶段不得改写
constraints: list[str] # 原始约束列表:同样只读
artifacts: dict # 各阶段的产物,key 是阶段名
feedback: list[str] # 上一步被 gate 打回的原因(结构化,不是"你再想想")
step: str
step_id: int
budget: dict # 剩余步数 / 剩余 token
关键是前两项:goal 和 constraints 由代码搬运,不由模型生成。 每个阶段的提示词都用代码把这两个字段原样拼进去,模型可以读,不可以改。
就这么一个小动作,开头那个事故里“入门向”被压缩成“技术初学者”的问题就消失了——因为那句话根本没经过任何模型的转述。
反面做法长这样:
research -> "我查到了这些资料,总结一下:目标读者是技术初学者……" -> write
中间那段人话,就是信息丢失发生的地方。
2. 单点写入
只有一个角色持有写工具。 其他角色要么只读,要么只能提建议。
这是第 3 篇分层装载在多 Agent 层的升级版:那里是“写工具平时不可见”,这里是“写工具只属于某一个角色”。
好处不只是安全。更重要的是归因:一旦有东西被写坏了,你知道只可能是那一个角色干的。
3. 每个子 Agent 只看自己需要的字段
第 1 篇讲的「隔」,在多 Agent 层的落地形态就是这个。
不要图省事把整个 state 序列化了塞给每个子 Agent。子 Agent 的上下文应该只包含:它的任务、它需要的那几个 artifact、以及不可改的 goal 和 constraints。
塞多了有两个后果:一是上下文干扰(第 1 篇),二是它开始对不属于自己的部分发表意见——这就是形态 ⑤ 崩溃的起点。
4. 有一个收敛点
不要对等协商。 所有子结果交给一个角色汇总或裁决,这个角色是唯一的收敛点。
而且这个裁决者看到的应该是:
原始 goal + 原始 constraints + 子结果列表(结构化)
而不是所有子 Agent 的完整对话历史。后者既大又互相干扰。
一句话:多个 Agent 可以并行发散,但只能有一个地方收敛。
5. 每一步可重放
配合第 3 篇的幂等:每个阶段有 step_id,输入确定、输出可复现,失败只重跑这一步,不重跑整条链。
这一条的实际价值在于:多 Agent 系统里,重跑整条链的成本高到你会开始不愿意做回归测试。而不做回归测试的多 Agent 系统,会在你没注意的时候悄悄退化。
6. 全局预算和 gate
两件东西:
gate 是阶段之间的确定性校验——schema 校验、数量检查、去重、必填字段——不通过就把结构化错误回传,最多重试 N 次。
# src/gates.py
def check_candidates(cands: list[dict], constraints: list[str]) -> list[str]:
errs = []
if len(cands) < 5:
errs.append(f"候选数量不足:要求 5 个,实到 {len(cands)} 个")
for c in cands:
if not c.get("angle"):
errs.append(f"《{c.get('title')}》缺少 angle(切入角度)")
if len(c.get("outline", [])) < 3:
errs.append(f"《{c.get('title')}》大纲少于 3 条")
if constraints and not any(
kw in json.dumps(cands, ensure_ascii=False) for kw in constraints
):
errs.append(f"没有任何候选体现约束:{constraints}")
return errs
gate 是编排层最便宜的保险。 它是确定性代码,不消耗一次模型采样,却能拦掉一大半“生成到最后才发现不对”的情况。而且它给模型的反馈是具体的(“《X》缺少 angle”),不是“你再想想”。
预算 是全局的步数上限和 token 上限。超了就停下来,把当前 state 交给人,而不是硬着头皮继续跑。重试策略、降级和模型路由会更细地归到第 6 篇,这里只要先把“必须有上限”这件事立住。
六、动手改一遍:把一条大 prompt 拆成两阶段
现在动手改选题助手。注意:我要拆的是阶段,不是角色。
改之前
新手系列第 5 篇做完之后,主体长这样:
# src/main.py —— 改之前
SYSTEM = """
你是博客选题助手。
请先读历史选题去重,再生成 5 个选题,自己检查一遍质量,最后保存到 outputs/。
"""
def run(user_input: str):
messages = [
{"role": "system", "content": SYSTEM},
{"role": "user", "content": user_input},
]
while True:
resp = llm.chat(messages, tools=active_tools()) # 全部工具常开
if not resp.tool_calls:
return resp.content
messages += dispatch(resp.tool_calls) # 出错就往上抛
四件事挤在一个上下文里:读历史、生成、自检、保存。问题很具体:
- 自检是自己查自己——写完之后让自己检查自己写的东西,几乎查不出问题。
- 写工具全程可见——它在思考选题的时候,旁边就摆着「保存」。
- 失败无法定位——一轮对话里混了四种意图,出错了只能通读。
- 约束靠模型自己记住——第 8 轮它还记不记得你第 1 轮说的“入门向”,全看运气。
然后是我试过的那个错法:拆成三个角色。这一列留着当对照组。
改之后:目录
src/
main.py
pipeline.py # 编排:阶段顺序 + 重试 + 预算
state.py # 交接契约(上一节的 State)
gates.py # 确定性校验
trace.py # step 日志
stages/
research.py # 阶段一:只读工具,产出候选
write.py # 阶段二:只写工具,产出 md
tools/ # 第 3 篇改造后的工具层
registry.py
topics.py
suggest.py
save.py
第一步:把「原始需求」变成代码搬运的东西
# src/state.py
def init_state(user_input: str) -> State:
return State(
goal=user_input,
constraints=extract_constraints(user_input), # 一次抽取,此后全程只读
artifacts={},
feedback=[],
step="research",
step_id=0,
budget={"max_steps": 8, "max_tokens": 60_000},
)
extract_constraints 可以是一次轻量调用,也可以是一组规则。它只在最开始跑一次,之后 constraints 这个字段任何阶段都不许改。
这一条是整个改造的核心。之前那句“给完全没写过代码的人看”之所以会丢,是因为它只是一段对话历史里的一句话;现在它是 state 里的一个字段,由代码原样拼进每个阶段的提示词。
第二步:阶段只做一件事,工具列表各不相同
# src/stages/research.py
SYSTEM = """
你是选题研究员。你的唯一产出是一组候选选题,结构如下:
[{"title": str, "angle": str, "outline": [str, str, str], "tags": [str]}]
规则:
- 只在需要查重时调用 list_topics。
- 不要调用任何写工具,你没有写权限。
- 下面两段是系统透传,不要改写、不要总结:
<goal>{goal}</goal>
<constraints>{constraints}</constraints>
"""
# src/stages/write.py
SYSTEM = """
你是选题整理者。输入是一组已通过校验的候选,你的任务是排版并保存。
不要新增选题,不要修改 angle 和 outline,只做整理。
<goal>{goal}</goal>
<constraints>{constraints}</constraints>
"""
注意两件事:每个阶段的工具列表不同(第 3 篇的分层装载),以及 goal / constraints 是代码拼进去的、不是模型复述的。
第三步:编排层负责顺序、重试和放弃
# src/pipeline.py
def run_pipeline(user_input: str):
st = init_state(user_input)
log = []
# ── 阶段一:research(只读工具) ──
for attempt in range(3):
out = research.run(st, tools=registry.active_tools("read"))
trace.log_step(st, role="research", tools=["list_topics", "suggest_topics"],
output=out, tokens=out.tokens, ms=out.ms)
errs = gates.check_candidates(out.candidates, st.constraints)
if not errs:
st.artifacts["candidates"] = out.candidates
st.step, st.step_id = "write", st.step_id + 1
break
st.feedback = errs # 结构化错误,不是"再想想"
st.budget["max_steps"] -= 1
else:
return handoff_to_human(st, "候选连续三次未通过校验")
# ── 阶段二:write(只写工具) ──
result = write.run(st, tools=registry.active_tools("write"))
trace.log_step(st, role="write", tools=["save_topics"],
output=result, tokens=result.tokens, ms=result.ms)
if not gates.check_saved(result):
return handoff_to_human(st, "保存结果校验失败")
return result
这段代码里有四件同时落地的事:
- 工具分层:research 阶段根本看不到写工具(第 3 篇)。
- 失败只重跑一步:而且重跑时带的是结构化错误,不是一句“你再想想”(第 3 篇的错误语义)。
- 三次不达标就交给人:不硬着头皮继续跑(第 7 篇的人机边界会展开)。
- 每步写 trace:满足判断四的最低要求。
第四步:改完之后的对比
| 改之前(一条大 prompt) | 三个角色(我试过的错法) | 改之后(两阶段 + gate) | |
|---|---|---|---|
| 一次任务的模型调用 | 4 ~ 6 次 | 10 ~ 15 次 | 5 ~ 7 次 |
| 原始约束到达最终输出 | 靠模型自己记住 | 靠研究员转述(会丢) | 代码透传(不丢) |
| 出错时怎么定位 | 通读一段对话 | 翻三份对话 | 按 step_id 定位 |
| 质量检查 | 自己查自己 | 互相甩锅 | 确定性 gate |
| 写工具可见范围 | 全程可见 | 各角色自定 | 只在 write 阶段可见 |
| 失败之后 | 整段重来 | 整条链重来 | 只重跑这一步 |
| 加一条新要求 | 改 prompt 祈祷 | 改三份 prompt | 改 gate 或单个阶段 |
请特别看中间那一列。
它比不拆还要差。 更多调用、更贵、更难查、更容易丢约束——换来的是“看起来像个团队”。这就是第 0 篇里那句“过早多 Agent 化”的实际代价,现在有账可算了。
而第三列几乎没增加架构复杂度,只是把“一条 prompt 干四件事”变成了“两个阶段各干一件事,中间用代码校验”。
拆的单位应该是阶段,不是角色。阶段之间传的是数据,角色之间传的是理解——数据不会丢,理解会。
七、一份可以直接照着自查的清单
决定要不要拆、或者已经拆完之后,对着过一遍:
- 这几个步骤之间,是不是要反复回头看上一步的中间产物?(是就别拆)
- 拆开之后,用户那句最关键的要求,是代码透传的还是模型转述的?
- 做一次交接损失测试:挑一条最具体的约束,跑三次,看它有没有活着走到最后。
- 单 Agent 时,工具超过 12 个了吗?先减工具,别急着拆。
- 用 20 个真实用例跑过吗?错误集中在哪一步——那一步对应的是第 1 篇、第 3 篇,还是你的需求没写清楚?
- 每一次模型调用有没有结构化 trace?能不能按 step_id 回放任意一步的完整输入?
- 有副作用的工具,是不是只属于一个角色?
- 阶段之间有没有确定性 gate?失败最多重试几次?超了之后是交给人的还是继续跑?
- 整条链的总步数是多少?按单步正确率估算一下端到端正确率,你能接受吗?
- 上一次“多 Agent 系统跑出了奇怪结果”,你是怎么发现、怎么定位的?
最后一条最容易被答不上来,也最重要。拆得越多,可观测性越不是可选项。
常见误区
误区一:多 Agent = 更聪明。 不是。它是更多次采样,而每一次采样都是一次新的出错机会。单步 95% 正确,5 步串行只剩 77%,9 步只剩 63%。拆分只有在真正提高单步正确率(比如上下文变小了、工具变少了)或者真正省下步骤(并行)的时候才是划算的。
误区二:角色越多越像团队协作。 人和模型有个根本区别:人接下一个角色之后,会产生“这块我负责”的承诺感,会主动对齐。模型没有。它每次只看到当前上下文,然后根据当前上下文做最合理的下一步。 给它一个“你是严谨的审稿人”的身份,它得到的是一段文本,不是一个承诺。
误区三:让两个 Agent 自由对话来达成共识。 这条最诱人也最危险。没有收敛点的协商不会收敛,只会互相强化。要协作,就给一个明确的收敛者,让它看“原始目标 + 结构化子结果”,而不是看其他 Agent 的聊天记录。
误区四:先拆,跑不通再合并。 合不回来的。因为拆了之后你不知道哪些上下文在交接过程中丢了、哪些决定是基于不完整信息做出的。拆之前先留 trace,就是为了让你还有合并回去的可能。
编排在整套系统里的位置
编排是唯一一个和后面三篇都直接咬合的层:
- 评估体系(第 5 篇):编排决定了 trace 的最小单元。没有阶段划分,评估只能给整次任务打一个总分,你永远不知道是哪一步拖累了它。
- 可靠性与成本(第 6 篇):重试、降级、预算控制、模型路由,全都挂在编排层——因为只有编排层知道“现在执行到哪一步、还剩多少预算”。
- 人机边界(第 7 篇):人工确认点就是编排里的 gate,权限分级就是给不同阶段配不同的工具集。
回到开头那次事故。
改成两阶段之后,同样的任务是这样跑的:research 阶段拿到我那句原话(代码透传,一个字没改),产出五个带 angle 和 outline 的候选;gate 发现其中一个大纲只有两条,带着这条具体错误打回重跑一次;通过之后进 write 阶段,这时候才第一次出现「保存」这个选项。
调用更少,输出更稳,出错了知道改哪里。
多 Agent 从来不是让系统变聪明的手段。它只是在上下文真的装不下、或者权限真的要隔离时,你付出去的那笔成本。
在那之前,先把阶段理清楚——这一步几乎不花钱,而且往往是真正有效的那一步。
本系列目录
这是「Agent 工程进阶」系列的第 4 篇。
- 第 0 篇(地图):从 Demo 到可交付:如何做一个 Agent 项目
- 第 1 篇:上下文工程:为什么你的 Agent 越聊越笨
- 第 2 篇:记忆系统:Agent 怎么记住该记的,忘掉该忘的
- 第 3 篇:工具设计深水区:粒度、错误语义、幂等与 MCP
- 第 4 篇:编排与多 Agent:什么时候该拆,什么时候千万别拆(当前篇)
- 第 5 篇:评估体系:怎么知道你的 Agent 变差了
- 第 6 篇:可靠性与成本:什么时候该重试,什么时候该放弃
- 第 7 篇:人机边界:什么时候该问人,什么时候该放心让它做
新手系列入口(偏入门,建议先跑通第一个 Agent):先听懂:AI、LLM、Prompt、Agent、RAG、Tool、Memory 到底是什么
