Agent开发完全实战指南(七)多Agent协作
前六篇,我们把单个 Agent 打磨得很能打了:会循环、会用工具、会管上下文、有记忆、能查知识库。但你很快会撞上天花板。
想象一个场景:老板扔来一句"帮我调研三家云厂商的 Serverless 方案,对比价格、冷启动、生态,出个选型报告"。你让单个 Agent 硬扛——它得先查 A 家、再查 B 家、再查 C 家,工具越挂越多,上下文越滚越长,最后要么超预算,要么把三家信息搅成一锅粥。
一个 Agent 的问题:工具太多它选择困难,上下文太杂它注意力涣散,任务能并行它却只能串行干等。
多 Agent 协作的一句话概括:把一个大任务拆给多个各司其职的 Agent,每个 Agent 上下文干净、工具聚焦,能并行的并行跑——这是第 04 篇「Isolate(隔离)」那一板斧真正的落地。
一、什么时候该上多 Agent(先泼盆冷水)
多 Agent 不是越多越花哨越好。它引入了协调成本、上下文传递损耗、调试难度,很多时候单 Agent + 好工具就够了。
先记住这个判断标准:
| 信号 | 说明 | 该不该拆 |
|---|---|---|
| 子任务天然独立、可并行 | 调研三家厂商互不依赖 | 该拆,并行提速明显 |
| 需要不同「专业角色」 | 一个写代码、一个审安全 | 该拆,各用各的提示词 |
| 单 Agent 工具超过 15-20 个 | 模型选工具开始出错 | 考虑拆,按领域分组 |
| 上下文互相污染 | A 任务的噪声干扰 B 任务 | 该拆,隔离上下文 |
| 任务简单、线性 | 就是查个天气发个邮件 | 别拆,单 Agent 足够 |
| 子任务间强依赖、要频繁来回 | 拆了反而增加通信开销 | 别拆,或用 workflow |
关键洞察:多 Agent 的核心收益是「上下文隔离」和「并行」,不是「智能叠加」。如果你的任务无法从这两点获益,多 Agent 只会增加复杂度和成本。
二、三种主流协作模式
业界跑通的多 Agent 模式,归纳起来主要是三种。理解它们的区别,你才知道自己的场景该套哪个。
flowchart TD
subgraph OW["1. Orchestrator-Worker 编排-执行"]
O[主 Agent
拆任务/汇总] --> W1[子 Agent A]
O --> W2[子 Agent B]
O --> W3[子 Agent C]
W1 --> O
W2 --> O
W3 --> O
endflowchart LR
subgraph RT["2. Routing 路由"]
R{路由 Agent
判断意图} -->|技术问题| A1[技术支持 Agent]
R -->|账单问题| A2[账单 Agent]
R -->|退款问题| A3[售后 Agent]
endflowchart LR
subgraph HO["3. Handoff 交接"]
H1[分诊 Agent] -->|接不住,交给| H2[专家 Agent]
H2 -->|处理完,交回| H1
end三种模式对比:
| 模式 | 谁做决策 | 典型场景 | 类比 |
|---|---|---|---|
| Orchestrator-Worker | 主 Agent 拆分 + 汇总 | 复杂调研、多源信息聚合 | 项目经理派活给组员 |
| Routing | 路由 Agent 分类分发 | 客服分流、意图识别 | 前台转接不同部门 |
| Handoff | Agent 之间对等交接 | 分诊→专家、多轮升级 | 全科医生转专科 |
最常用、最值得先掌握的是 Orchestrator-Worker——因为它直接对应"拆分-并行-汇总"这个最普遍的提效诉求。下面动手实现它。
三、动手:Orchestrator-Worker 并行系统
我们做一个"主 Agent 把大任务拆成若干子任务,派多个子 Agent 并行执行,再把结果汇总"的系统。这正是第 05 篇 code/05-memory、第 06 篇 RAG 之后,把单 Agent 扩展成 Agent 团队的关键一步。
3.1 子 Agent:一个聚焦的最小执行单元
子 Agent 本质就是前几篇那个 Agent 循环,只是上下文干净、只干一件事。为了聚焦并行编排的骨架,这里把子 Agent 的"执行"抽象成一个函数:
// SubAgent 一个聚焦的子 Agent:只负责一个子任务
type SubAgent struct {
Name string // 角色名,如 "云厂商A调研员"
}
// Run 执行子任务。真实实现里这里是一整个 Agent 循环(见第 02-03 篇),
// 会调用 LLM、用工具、查知识库。这里用一个可跑的桩来演示编排骨架。
func (a *SubAgent) Run(subTask string) string {
// 模拟一次有耗时的独立工作(真实场景是 callLLM + 工具调用)
time.Sleep(300 * time.Millisecond)
return fmt.Sprintf("[%s] 关于「%s」的调研结论:……(此处为该子 Agent 独立产出)", a.Name, subTask)
}
把子 Agent 的循环换成第 02/03 篇的
runAgent(subTask)就是生产版本。这里的重点是编排结构,不是重复贴 Agent 循环。
3.2 主 Agent:拆分 → 并行派发 → 汇总
编排的精髓在这三步。并行用 Go 最擅长的 goroutine + channel 实现:
// Orchestrator 主 Agent:负责拆任务、并行派发、汇总
type Orchestrator struct{}
// Plan 把大任务拆成子任务。真实实现里这一步是让 LLM 输出结构化子任务列表,
// 这里为了聚焦并行骨架,用固定拆分演示。
func (o *Orchestrator) Plan(task string) []string {
return []string{
"云厂商 A 的 Serverless 价格与冷启动",
"云厂商 B 的 Serverless 价格与冷启动",
"云厂商 C 的 Serverless 价格与冷启动",
}
}
// Run 并行派发子任务给子 Agent,收集所有结果后汇总
func (o *Orchestrator) Run(task string) string {
subTasks := o.Plan(task)
results := make([]string, len(subTasks))
var wg sync.WaitGroup
for i, st := range subTasks {
wg.Add(1)
// 每个子任务一个独立 goroutine,并行执行
go func(idx int, subTask string) {
defer wg.Done()
agent := &SubAgent{Name: fmt.Sprintf("子Agent-%d", idx+1)}
results[idx] = agent.Run(subTask) // 写各自的槽位,无需加锁
}(i, st)
}
wg.Wait() // 等所有子 Agent 都完成
// 汇总:真实实现里这里再调一次 LLM 把碎片综合成报告
return o.Aggregate(task, results)
}
// Aggregate 把子 Agent 的产出综合成最终答案
func (o *Orchestrator) Aggregate(task string, results []string) string {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("任务「%s」的综合报告:\n", task))
for _, r := range results {
sb.WriteString(" - " + r + "\n")
}
sb.WriteString("(主 Agent 已将以上碎片综合成结论)")
return sb.String()
}
关键洞察:并行的正确姿势是「每个子 Agent 写自己的结果槽位(results[idx]),最后用 wg.Wait() 汇合」。这样天然无数据竞争,不用加锁。这是 Go 做 fan-out/fan-in 的标准套路。
3.3 跑起来看并行效果
func main() {
orch := &Orchestrator{}
task := "调研三家云厂商的 Serverless 方案并给出选型建议"
start := time.Now()
report := orch.Run(task)
elapsed := time.Since(start)
fmt.Println(report)
fmt.Printf("\n耗时:%v(3 个子任务并行,而非 3×300ms 串行)\n", elapsed)
}
预期输出:三条子结论被汇总成一份报告,总耗时约 300ms 而不是 900ms——因为三个子 Agent 是并行跑的。任务越多、单个越耗时,并行的收益越大。
完整代码见 code/07-multi-agent/,离线可跑(子 Agent 用桩模拟,聚焦编排骨架)。
四、多 Agent 的隐藏成本与坑
多 Agent 好用,但它是把双刃剑。Anthropic 在其多 Agent 研究系统的复盘里明确指出:多 Agent 系统的 token 消耗可能是单 Agent 的 15 倍——因为每个子 Agent 都有自己的上下文和多轮对话。
| 坑 | 后果 | 正确做法 |
|---|---|---|
| 无脑拆成一堆 Agent | token 成本爆炸、协调混乱 | 只在能并行/需隔离时拆 |
| 子任务拆得有依赖还硬并行 | 结果互相矛盾、需重跑 | 有依赖的走串行或 workflow |
| 子 Agent 上下文没隔离干净 | 隔离的意义丧失 | 每个子 Agent 全新上下文,只传必要输入 |
| 汇总时把所有原始输出全塞回主 Agent | 主 Agent 上下文又爆了 | 子 Agent 先自己压缩,只回传结论 |
| 子 Agent 失败没兜底 | 一个挂了整个任务失败 | 单个失败降级/重试,不阻塞其他 |
| 并行数无上限 | 打爆 API 限流、内存 | 用带缓冲的信号量限制并发数 |
关键洞察:多 Agent 最容易犯的错是「为了用而用」。先问自己——这个任务用单 Agent 加好工具能不能解决?不能,再上多 Agent。能并行、能隔离,才是它的主场。
限制并发数的补充
生产环境别让 goroutine 无限开。用一个带缓冲 channel 当信号量:
sem := make(chan struct{}, 3) // 最多 3 个并发
for i, st := range subTasks {
wg.Add(1)
go func(idx int, subTask string) {
defer wg.Done()
sem <- struct{}{} // 获取令牌,满了就阻塞等待
defer func() { <-sem }() // 用完归还
results[idx] = (&SubAgent{Name: fmt.Sprintf("子Agent-%d", idx+1)}).Run(subTask)
}(i, st)
}
wg.Wait()
五、决策指南:三种模式怎么选
| 你的处境 | 建议 |
|---|---|
| 子任务独立、想并行提速 | Orchestrator-Worker |
| 入口要按意图分流到不同专家 | Routing |
| 需要分诊 + 专家逐级升级 | Handoff |
| 任务线性、简单 | 别上多 Agent,单 Agent 足够 |
| 子任务强依赖、要频繁交互 | 用 workflow(第 01 篇)而非多 Agent |
| 成本敏感 | 先算 token 账,多 Agent 可能贵 10 倍以上 |
六、常见坑速查
| 坑 | 后果 | 正确做法 |
|---|---|---|
| 为了用而用多 Agent | 复杂度和成本双爆 | 先确认能并行或需隔离 |
| 子 Agent 之间共享可变状态 | 数据竞争、结果错乱 | 各写各的槽位,用 channel 通信 |
| 汇总全量回传 | 主 Agent 上下文爆炸 | 子 Agent 回传压缩后的结论 |
| 并发不设上限 | API 限流、OOM | 信号量限制并发数 |
| 子 Agent 失败无隔离 | 一损俱损 | 单点失败降级,不阻塞全局 |
七、小结与下一篇
- 单 Agent 的天花板是工具过多、上下文过杂、只能串行。
- 多 Agent 三模式:Orchestrator-Worker(拆分并行汇总)、Routing(分流)、Handoff(交接),优先掌握第一种。
- 并行用 goroutine + channel + WaitGroup,各写各的结果槽位,天然无锁。
- 多 Agent 的收益是隔离与并行,代价是成本可能 10 倍以上——别为了用而用。
我们现在能造 Agent 团队了。但一个扎心的问题浮出水面:你怎么知道你的 Agent(无论单个还是一群)到底靠不靠谱? 改了个提示词,是变好了还是变差了?换了个模型,准确率是升了还是降了?靠"感觉还行"上线,就是在生产环境裸奔。
下一篇预告——《评测 Eval:给 Agent 建一套「考试系统」》:我们会讲透怎么构建 golden set(标准答案集)、怎么用 LLM-as-judge(让模型当裁判)、怎么做回归测试防止越改越烂。这是把 Agent 从"玩具 demo"推向"生产可信"的必经之路,也是前面 RAG、记忆那些"检索准不准"最终的验收关卡。
参考资料
| 资料 | 来源 |
|---|---|
| Building effective agents(Anthropic,含 Orchestrator-Workers 等模式) | anthropic.com/research/building-effective-agents |
| How we built our multi-agent research system(Anthropic 多 Agent 复盘) | anthropic.com/engineering/built-multi-agent-research-system |
| OpenAI Agents SDK(handoffs / routing 官方实现) | openai.github.io/openai-agents-python |
| LangGraph Multi-Agent(多 Agent 编排概念) | langchain-ai.github.io/langgraph/concepts/multi_agent |