Session 09:Multi-Agent——让多个 Agent 分工协作
前面讨论 Workflow 时,我们用一个 Research Agent 完成研究报告:搜索资料、分析资料、检查证据是否充分,最后生成报告。整个流程由程序控制,LLM 在需要理解语义或作出判断的节点参与决策。
如果研究任务越来越复杂,比如需要分别研究不同技术方案、分析优缺点、核对证据,最后再综合成报告,就可以考虑把任务拆给多个 Agent。每个 Agent 负责一块工作,使用与自身任务相关的上下文,完成后把结果交回统一的协调者。
这就是 Multi-Agent 的一个常见用法。不过,Agent 数量增加之后,系统也多了任务分配、结果传递、状态管理和失败恢复等问题。本文从一个简单的多方案研究任务出发,看看这些机制如何实现。
1. 为什么需要多个 Agent
假设我们要研究三种实现 Research Agent 的方案:纯 Python、自定义 LangGraph、CrewAI。每种方案都需要搜索资料、整理实现方式、分析适用场景和限制。如果让一个 Agent 一直完成所有工作,它的上下文里会不断堆积不同方案的搜索结果、分析过程和中间结论。不同方案之间的信息也可能互相干扰。
可以把三项研究分别交给三个子 Agent,再由主 Agent 负责分配任务、跟踪进度和汇总结论。这样做有几个直接好处:
- 职责更清楚。 每个子 Agent 只负责一个明确目标。
- 上下文可以隔离。 子 Agent 只接收完成当前任务需要的信息,不必读取其他方案的全部研究过程。
- 任务可以并行。 三项研究相互独立时,可以同时执行,减少整体等待时间。
- 结果有统一出口。 主 Agent 可以核对不同子 Agent 的结果,再生成最终报告。
多 Agent 不会自动解决上下文膨胀。真正起作用的是任务隔离和有选择的信息传递。如果主 Agent 把完整聊天记录全部塞给每个子 Agent,系统仍然会产生大量无关上下文。
同时,Agent 越多,协调成本越高。简单任务拆成多个 Agent,可能只是增加模型调用、延迟和故障点。适不适合使用多 Agent,取决于任务是否能自然拆分,以及拆分后的收益能否覆盖协调成本。
2. 谁来分配任务:Supervisor 模式
一种常见设计是由主 Agent 统一分配任务,也叫 Supervisor 模式。主 Agent 了解整体目标和各个子 Agent 的职责,根据任务生成子任务,再把任务交给相应的 Agent。
例如:
python_researcher:研究纯 Python 的实现方式。langgraph_researcher:研究 LangGraph 的实现方式。crewai_researcher:研究 CrewAI 的实现方式。supervisor:分配任务、跟踪结果、检查缺失信息并汇总报告。
主 Agent 可以由 LLM 根据任务动态决定如何拆分,也可以由程序提前定义好任务清单。任务结构稳定、业务边界明确时,程序预先拆分更简单;需要根据研究主题临时决定分工时,再让 LLM 参与规划。
关键是区分“谁决定做什么”和“谁真正执行”。LLM 可以提出任务分配方案,但程序仍然要检查任务是否合法、目标 Agent 是否存在、任务数量是否超限,然后才执行调用。
3. Agent 之间如何传递消息
多个 Agent 不会因为都使用同一个模型,就自动共享对话历史或互相知道对方做了什么。每次调用模型时,程序都要明确构造这次请求需要的消息。多 Agent 系统也需要一个明确的通信协议,约定任务怎么交出去、结果怎么返回。
可以先定义两种数据结构:任务消息和执行结果。
from dataclasses import dataclass, field
from typing import Any, Literal
@dataclass
class TaskMessage:
task_id: str
agent_name: str
goal: str
context: dict[str, Any] = field(default_factory=dict)
@dataclass
class AgentResult:
task_id: str
status: Literal["completed", "failed"]
summary: str = ""
evidence: list[dict[str, str]] = field(default_factory=list)
error: str | None = None
TaskMessage 描述子 Agent 需要完成什么,以及完成任务所需的上下文。AgentResult 描述任务执行结果,包括结论、证据和错误信息。task_id 用于把返回结果对应到原始任务,避免并行执行时把结果放错位置。
下面先用一个函数模拟子 Agent。它暂时没有真正调用 LLM,只用来展示消息的传递过程。
def run_sub_agent(task: TaskMessage) -> AgentResult:
try:
# 实际项目中,这里会根据 task.agent_name 选择对应 Agent,
# 构造 system/user messages,再调用 LLM 或工具。
summary = (
f"围绕 {task.goal} 完成研究;"
f"研究主题是 {task.context.get('topic', '')}。"
)
return AgentResult(
task_id=task.task_id,
status="completed",
summary=summary,
evidence=[],
)
except Exception as exc:
return AgentResult(
task_id=task.task_id,
status="failed",
error=str(exc),
)
真正接入 LLM 时,子 Agent 通常会有自己的 System Prompt。例如,研究员的提示词可以要求它只研究指定方案,输出“实现方式、适用场景、局限、证据来源”这几个字段。程序把任务目标和必要上下文放进 User Message,再将模型返回的结果整理成 AgentResult。
请求模型的消息大致如下:
messages = [
{
"role": "system",
"content": (
"你是一名技术研究员。只研究分配给你的方案。"
"输出实现方式、适用场景、局限和证据来源。"
"证据不足时明确说明,不要编造来源。"
),
},
{
"role": "user",
"content": (
"研究主题:Research Agent 的实现方式\n"
"你的任务:研究 LangGraph 方案\n"
"请给出实现方式、适用场景、局限和证据来源。"
),
},
]
上面展示的是发送给模型的消息结构,并没有绑定具体厂商的 API。真实代码还需要调用所选模型接口,并解析、校验返回结果。
4. 共享状态:程序如何掌握全局进度
消息负责把任务交给 Agent、把结果带回来;程序还需要记录整个协作过程。例如哪些任务还没开始、哪些正在执行、哪些成功、哪些失败,以及每个任务的结果是什么。
可以用一个字典实现最小的任务账本:
tasks = [
TaskMessage("t1", "python_researcher", "研究纯 Python 方案", {"topic": "Research Agent"}),
TaskMessage("t2", "langgraph_researcher", "研究 LangGraph 方案", {"topic": "Research Agent"}),
TaskMessage("t3", "crewai_researcher", "研究 CrewAI 方案", {"topic": "Research Agent"}),
]
state = {
"topic": "Research Agent 的实现方式比较",
"tasks": {
task.task_id: {
"message": task,
"status": "pending",
"result": None,
}
for task in tasks
},
}
for task in tasks:
state["tasks"][task.task_id]["status"] = "running"
result = run_sub_agent(task)
state["tasks"][task.task_id]["status"] = result.status
state["tasks"][task.task_id]["result"] = result
for task_id, item in state["tasks"].items():
print(task_id, item["status"], item["result"])
这里的 state 就是共享状态的最小实现。每个子 Agent 不必直接操作这份全局状态;由调度程序接收结果并更新状态,控制权和数据写入都更清晰。
这个示例的状态只保存在进程内存里,程序一旦退出就会丢失。真实系统如果需要长时间运行、跨进程执行或故障后恢复,通常会把任务状态持久化到数据库或工作流框架的 checkpoint 中。还需要考虑并发更新、任务重复执行和状态写入的一致性。
5. 独立任务可以并行执行
三个研究任务相互独立时,可以使用线程池并行执行。下面是核心代码:
from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=3) as pool:
future_to_task = {
pool.submit(run_sub_agent, task): task
for task in tasks
}
for future in as_completed(future_to_task):
task = future_to_task[future]
result = future.result()
state["tasks"][task.task_id]["status"] = result.status
state["tasks"][task.task_id]["result"] = result
as_completed 会在任务完成时返回对应的 Future,所以结果的返回顺序可能与任务提交顺序不同。程序使用 task_id 找到对应状态,再写入结果。
这段代码适合说明并行调度的基本机制。生产环境还需要设置超时、限制并发量、记录日志、处理 future.result() 抛出的异常,并决定失败任务是否重试。线程池也只适用于当前 Python 进程内的简单并发场景;跨机器调度通常会使用任务队列、工作流引擎或其他分布式执行设施。
6. 主 Agent 如何汇总结果
当子任务完成后,主 Agent 可以读取任务账本,收集成功结果和失败任务,再调用 LLM 生成最终报告。汇总时应该保留证据来源,不能只把几段没有出处的结论拼在一起。
completed_results = []
failed_tasks = []
for task_id, item in state["tasks"].items():
result = item["result"]
if result is None or result.status == "failed":
failed_tasks.append({
"task_id": task_id,
"error": result.error if result else "任务没有返回结果",
})
else:
completed_results.append({
"task_id": task_id,
"summary": result.summary,
"evidence": result.evidence,
})
随后把 completed_results 交给主 Agent,并明确要求它比较各方案、区分事实与推断、引用证据来源。如果有关键任务失败,主 Agent 应当知道哪些信息缺失,不能把缺失的研究内容当作已经完成。
主 Agent 也可以根据结果决定下一步:对缺少证据的方案重新分配任务、让另一个 Agent 复核,或者在失败次数达到上限后标记局限并请求人工介入。这时,多 Agent 协作就不只是并行调用多个模型,还包含了任务状态驱动的流程控制。
7. 多 Agent 协作失败怎么处理
Agent 数量增加后,失败场景也会增加。常见问题可以分开处理。
子 Agent 执行失败
可能是模型接口超时、工具调用失败、输出格式不符合约定,或者研究任务本身没有足够资料。程序可以对临时性错误进行有限重试;如果仍然失败,可以换一个执行方式、缩小任务范围,或者把任务标记为失败交给主 Agent 决策。重试需要有次数上限,避免反复消耗 token 和时间。
任务重复执行
任务队列、网络重试或进程恢复可能导致同一个任务被执行多次。可以使用稳定的 task_id 做幂等控制:如果任务已经成功完成,就优先复用已有结果;对于有副作用的工具操作,还需要额外的幂等键或去重机制。
子 Agent 结果冲突
不同 Agent 可能得出相互矛盾的结论。主 Agent 不应只凭语言流畅程度选择一个结果,而应检查证据来源、时间、适用范围和可信度。重要结论可以触发重新检索或独立复核;涉及高风险决策时则应交给人工确认。
状态不一致或程序中断
例如子 Agent 已完成工作,但主程序还没来得及把结果写入状态;或者任务被重复调度。需要持久化状态、明确任务状态转换,并设计恢复策略。对关键状态更新,数据库事务或条件更新可能比简单地修改 Python 字典更合适。
这些问题与传统分布式系统中的任务调度、消息投递、幂等、重试和恢复非常相似。引入 Multi-Agent 后,LLM 的不确定性会叠加在这些工程问题上,因此需要控制并发、调用预算、任务范围和失败后的退出条件。
8. Multi-Agent 与 Workflow 的关系
Workflow 关注整个任务流程如何推进;Multi-Agent 关注不同职责如何拆分,以及这些执行单元如何协作。两者可以一起使用。
例如,研究报告系统可以有一个外层 Workflow:确定研究问题、分配任务、收集结果、检查证据、生成报告。分配任务阶段由 Supervisor 决定子任务,多个 Research Agent 并行研究;结果不足时进入补充检索或复核分支,最后再生成报告。
这种组合能把控制流程留在程序中,同时让不同 Agent 处理各自擅长的工作。若任务路径固定,程序可以预先定义节点和分支;若需要根据研究过程动态调整任务,则可以让 Supervisor 参与决策,但仍要通过程序限制任务数量、工具权限和执行预算。
9. 业界常见实现方案
常见框架的差别,主要在于如何表达 Agent、任务、状态和控制流。
| 方案 | 核心抽象 | 适合的场景 | 需要关注的地方 |
|---|---|---|---|
| 自定义 Python 编排 | 函数、消息对象、状态字典、线程池 | 理解底层机制、任务结构简单、需要精细控制 | 状态持久化、重试、并发和恢复都要自己维护 |
| LangGraph | Graph、Node、State、条件路由、Checkpoint | 有分支、循环、共享状态和恢复需求的复杂流程 | 需要理解状态更新、节点边和并行结果合并 |
| OpenAI Agents SDK | Agent、Tools、Agent-as-Tool、Handoff | 希望通过较少抽象组织 Agent 调用和控制权切换 | 要分清子 Agent 返回结果与控制权移交的差别,持久化策略也需按应用设计 |
| CrewAI | Agent、Task、Crew、Flow | 希望围绕角色和任务组织协作 | 需要明确任务依赖、共享数据和失败处理策略 |
LangGraph
LangGraph 用图描述执行流程:Node 执行具体逻辑,Edge 决定下一步,State 保存节点之间传递的数据。一个 Research Agent 可以把 Supervisor、三个研究节点、结果检查和报告生成分别建成节点,并根据任务状态决定走向。
from typing import TypedDict, Any
class ResearchState(TypedDict):
topic: str
tasks: dict[str, Any]
results: dict[str, Any]
errors: dict[str, str]
这里的 State 是工作流运行时的数据,不等于发给 LLM 的 messages。某个节点可以从 State 读取研究主题和任务信息,再单独构造该次 LLM 调用的 System/User Message。节点完成后返回需要更新的状态字段。
如果多个节点并行执行并同时更新同一个字段,就需要考虑 reducer 或其他合并规则,避免状态更新冲突。LangGraph 还提供 checkpoint 等机制支持保存和恢复工作流状态。具体是否需要并行、持久化和人工介入,应根据实际业务选择。
OpenAI Agents SDK
常见的两种协作方式是 Agent-as-Tool 和 Handoff。Agent-as-Tool 把专业 Agent 当作主 Agent 可调用的工具,子 Agent 返回结果后由主 Agent继续处理并形成最终回答。Handoff 则把当前控制权交给另一个 Agent,由接手的 Agent 继续处理。
如果研究任务需要主 Agent 比较多个方案并统一写报告,Agent-as-Tool 的思路通常更自然;如果请求需要直接转交给专门负责某类任务的 Agent,Handoff 会更合适。官方指南:https://developers.openai.com/api/docs/guides/agents/orchestration。
CrewAI
CrewAI 以角色、目标和 Task 组织协作。可以为研究员、分析员、审稿员和写作者定义不同职责,再通过 Crew 组织任务;需要更明确的条件分支和状态流转时,可以结合 Flow。它的角色式抽象比较直观,但任务依赖、输出协议和失败恢复仍然需要结合具体应用设计。官方文档:https://docs.crewai.com/core-concepts/Agents。
10. 小结
Multi-Agent 的核心是把复杂任务拆成职责明确的子任务,并建立一套可靠的协作机制。Supervisor 负责分配任务,消息协议负责交接任务和结果,状态负责记录全局进度,调度程序负责并发与失败处理,主 Agent 最后整合结果。
理解这些机制后,再学习 LangGraph 或其他框架会更容易看清它们分别替我们处理了哪些事情。实际项目中应从少量 Agent 开始,只有当任务确实能够独立拆分、上下文隔离或并行执行带来收益时,再逐步增加协作复杂度。