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 end
flowchart LR
    subgraph RT["2. Routing 路由"]
        R{路由 Agent
判断意图} -->|技术问题| A1[技术支持 Agent] R -->|账单问题| A2[账单 Agent] R -->|退款问题| A3[售后 Agent] end
flowchart 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(无论单个还是一群)到底靠不靠谱? 改了个提示词,是变好了还是变差了?换了个模型,准确率是升了还是降了?靠"感觉还行"上线,就是在生产环境裸奔。

下一篇预告——《评测 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