别再让 Agent 互相传话:多 Agent 协作的 3 个致命错误(附 120 行可运行代码)
导语:单体 Agent 跑到第十五次工具调用就开始胡说八道,拆成多 Agent 之后又开始互相甩锅。很多人以为是模型不行,其实问题出在你让它们“怎么说话”。
一、为什么你的多 Agent 越拆越乱
一个真实的排查现场:订单接口要补空值保护,需求拆给三个 Agent —— 需求分析、写代码、代码审查。流程看着很标准,跑出来的结果却是:
- 分析 Agent 说“已识别 2 条验收标准”,但审查 Agent 收到的只有一句“请检查代码质量”;
- 写代码 Agent 改完之后,审查提了 3 个问题,其中 1 个已经被改过;
- 修改和复审来回 7 轮,第 8 轮还在重复第 3 轮的动作,Token 账单翻了三倍。
这不是模型能力问题,是架构问题。LangGraph 团队曾公开过一组基准:同样是 supervisor 架构,初版比优化版差了约 50%,原因被总结成“电话游戏(telephone game)”——Supervisor 把子 Agent 的结果用自己的话转述给下一个 Agent,信息在每一次转述里掉一层。
下面这三个坑,几乎每个多 Agent 项目都会踩。
二、坑一:Supervisor 转述,而不是直传产物
最典型的写法长这样:
# 反例:Supervisor 把结果“翻译”成自然语言再往下传
spec_text = analyst_agent.run(requirement) # 返回一大段 JSON
patch = coder_agent.run(f"需求分析结果是:{spec_text[:300]}……") # 截断 + 转述
问题有三个,而且都很致命:
- 截断即丢证据:
[:300]之后,验收标准里的“异常文案要带字段名”直接消失; - 转述即失真:LLM 复述 JSON 时极易改字段名、改层级,下游解析必挂;
- 无法审计:出了问题时,你手上只有 Supervisor 的“转述稿”,没有原始产物,根本对不上账。
修法:建一个产物库(artifact store),Agent 之间只传 id,不传文本。
const store = new Map();
const put = (owner, content) => {
const id = `art-${store.size + 1}`;
store.set(id, { owner, content }); // 原文落库,谁都能查
return id;
};
// Supervisor 只负责编排:dispatch('reviewer', '审查补丁', [patchId])
这样下游拿到的是原文对象,Supervisor 的上下文里只留 id 和一句任务描述。顺带解决另一个隐性问题:主管的上下文不再被所有子 Agent 的长输出撑爆。
三、坑二:共享上下文,而不是隔离上下文
第二个常见错误,是把整段对话历史塞给每个子 Agent,理由是“信息越全越好”。实际效果是:
- 写代码的 Agent 开始模仿分析 Agent 的口吻,输出一堆“我认为……”;
- 上一个子任务的失败尝试被带进下一个子任务,模型反复自我怀疑;
- 上下文越长,注意力越散,工具调用越容易选错。
多 Agent 架构真正的价值,不是“人多力量大”,而是上下文隔离:每个子 Agent 应该在一个干净的窗口里,只看到「自己的任务 + 上游产物的原文」,看不到别人的对话。
我在示例里把这条约束写成硬规则:
async dispatch(workerName, goal, inputs = []) {
const worker = this.workers[workerName];
const artifacts = inputs.map(id => store.get(id)); // 只有产物原文
const output = await worker.run(goal, artifacts); // 没有 history,没有别人的聊天记录
return put(workerName, output);
}
经验值:子 Agent 的输入里,任务描述 + 结构化产物就够了。真要共享背景,也应该沉淀成一份“项目约定”产物,而不是把聊天记录整个复制过去。
四、坑三:没有预算、没有熔断、没有死循环闸门
第三个坑最费钱:多 Agent 的循环是隐性的。单 Agent 你还能看到它在转圈,多 Agent 之间互相调用时,日志里只是一串正常请求。
线上最常见的三种失控:
| 失控类型 | 表现 | 代价 |
|---|---|---|
| 死循环 | 修改 → 审查不通过 → 修改,动作完全重复 | Token 线性燃烧 |
| 预算失控 | 每个子 Agent 都“再查一次资料” | 单次任务成本不可预估 |
| 静默降级 | 子 Agent 失败,Supervisor 用兜底文案继续跑 | 结果错误但看起来成功 |
对应的三道闸门,建议直接做成 Supervisor 的内置能力:
- 步数闸门:一次任务最多 N 次 dispatch;
- 预算闸门:按 Agent 预设成本扣减,余额不足直接抛错;
- 重复动作闸门:窗口内出现相同的 (worker, goal),判定为死循环。
关键是第三点:失败必须显式抛出,不许静默回落。一个报错的任务,远比一个“看起来成功但其实没改对”的任务便宜。
五、120 行最小实现:离线可跑,替换一下就是生产骨架
下面这份代码不依赖任何框架和 API Key,node supervisor-demo.mjs 直接跑通。三个 worker 目前是确定性的“假模型”,把 run() 里换成真实 LLM 调用即可。
// supervisor-demo.mjs —— 零依赖、离线可跑
const store = new Map(); // 产物库:Agent 之间只传 id,不传 Supervisor 的转述
let seq = 0;
const put = (owner, content) => {
const id = `art-${++seq}`;
store.set(id, { owner, content });
return id;
};
const makeBudget = (tokens = 3000, maxSteps = 10) => ({ tokens, steps: 0, maxSteps });
class Supervisor {
constructor({ workers, budget, guardWindow = 2 }) {
this.workers = workers;
this.budget = budget;
this.recent = [];
this.guardWindow = guardWindow;
this.trace = [];
}
charge(cost) {
this.budget.steps += 1;
this.budget.tokens -= cost;
if (this.budget.steps > this.budget.maxSteps) throw new Error('[熔断] 步数超限');
if (this.budget.tokens <= 0) throw new Error('[熔断] Token 预算耗尽');
}
// 死循环闸门:同样的 (worker, goal) 在窗口内重复出现就停
isLooping(worker, goal) {
const key = `${worker}::${goal}`;
this.recent.push(key);
if (this.recent.length > this.guardWindow) this.recent.shift();
return this.recent.filter(k => k === key).length > 1;
}
async dispatch(workerName, goal, inputs = []) {
if (this.isLooping(workerName, goal)) throw new Error(`[熔断] ${workerName} 重复执行同一任务:${goal}`);
const worker = this.workers[workerName];
if (!worker) throw new Error(`未知 worker: ${workerName}`);
this.charge(worker.cost);
// 关键:worker 只拿到上游产物的原文,不拿任何历史对话
const artifacts = inputs.map(id => store.get(id));
const output = await worker.run(goal, artifacts);
const id = put(workerName, output);
this.trace.push({ worker: workerName, goal, inputs, output: id, tokens: this.budget.tokens });
return id;
}
}
// ---- 三个“假模型” worker,替换成真实 LLM 调用即可 ----
const analyst = {
cost: 400,
async run(goal, [req]) {
const lines = req.content.split('\n').filter(l => l.includes('要求'));
return JSON.stringify({
goal,
criteria: lines.map(l => l.replace(/^.*要求[::]\s*/, '').trim()),
outOfScope: ['前端联调'],
}, null, 2);
},
};
const coder = {
cost: 600,
async run(goal, [spec, review]) {
const patch = ['--- a/OrderService.java', '+++ b/OrderService.java', '+ // 按 spec 改造:先落结构,空值校验稍后补'];
if (review) {
patch.push('+ if (order == null) throw new IllegalArgumentException("order 不能为空");');
}
return patch.join('\n');
},
};
const reviewer = {
cost: 350,
async run(goal, [patch]) {
const issues = [];
if (!patch.content.includes('order == null')) {
issues.push({ level: 'P1', desc: 'order 未做空值校验', fix: '补 if (order == null) 前置校验' });
}
return JSON.stringify({ passed: issues.length === 0, issues }, null, 2);
},
};
async function main() {
const sup = new Supervisor({
workers: { analyst, coder, reviewer },
budget: makeBudget(2600, 6),
});
const req = put('user', '给订单查询接口补空值保护\n要求:order 为空时抛 IllegalArgumentException\n要求:异常文案带字段名');
const spec = await sup.dispatch('analyst', '拆解验收标准', [req]);
let patch = await sup.dispatch('coder', '按验收标准改代码', [spec]);
let review = await sup.dispatch('reviewer', '审查补丁', [patch]);
if (!JSON.parse(store.get(review).content).passed) {
patch = await sup.dispatch('coder', '根据审查意见修复', [spec, review]);
review = await sup.dispatch('reviewer', '复审补丁', [patch]);
}
console.log('最终补丁:\n' + store.get(patch).content);
console.log('复审结果: ' + store.get(review).content);
console.log('调用轨迹:', sup.trace.map(t => `${t.worker}(${t.inputs.length}个入参)→${t.output}`).join(' | '));
console.log('剩余 Token:', sup.budget.tokens);
// 演示熔断:预算给不够时,直接报错而不是静默降级
const poor = new Supervisor({ workers: { analyst, coder, reviewer }, budget: makeBudget(900, 6) });
try {
await poor.dispatch('analyst', '拆解验收标准', [req]);
await poor.dispatch('coder', '按验收标准改代码', [spec]);
} catch (e) {
console.log('预算不足场景:', e.message);
}
}
main().catch(e => { console.error(e.message); process.exit(1); });
真实输出(Node 24 实测):
最终补丁:
--- a/OrderService.java
+++ b/OrderService.java
+ // 按 spec 改造:先落结构,空值校验稍后补
+ if (order == null) throw new IllegalArgumentException("order 不能为空");
复审结果: {
"passed": true,
"issues": []
}
调用轨迹: analyst(1个入参)→art-2 | coder(1个入参)→art-3 | reviewer(1个入参)→art-4 | coder(2个入参)→art-5 | reviewer(1个入参)→art-6
剩余 Token: 300
预算不足场景: [熔断] Token 预算耗尽
从轨迹里能直接读出三件事:每一跳都只带 1~2 个产物入参、审查发现的 P1 问题被真实修复、预算耗尽时是抛错而不是假装成功。这份 trace 本身也是最好的排障入口——线上出问题时,先看轨迹里哪个 (worker, goal) 开始重复。
六、什么时候不该上多 Agent
多 Agent 不是银弹,这几种情况反而更糟:
- 任务链路短、工具不超过 3 个:单 Agent + 好用的工具定义,稳定性更高;
- 强依赖完整上下文的推理:拆开之后,子 Agent 谁都看不到全貌;
- 没有可验证的中间产物:审查 Agent 没有 diff、没有测试结果,只能输出“看起来还行”。
判断标准很朴素:你的任务能不能切成若干段,每段都有明确、可校验的输入输出? 能,才值得拆。
七、总结
把三个坑收成一句话:多 Agent 的关键不在“多”,而在于每次交接都必须是结构化、可追溯、有预算的。
- 交接传产物原文,别传 Supervisor 的转述;
- 每个子 Agent 用干净上下文,只拿自己的任务和上游产物;
- 步数、Token、重复动作三道闸门内置,失败必须显式暴露。
本文代码可直接作为骨架,把 worker 里的 run() 换成真实模型调用就能进项目。建议第一版先把 trace 打全,等轨迹稳定了再谈优化——能看见的多 Agent,才是能维护的多 Agent。