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 系统也需要一个明确的通信协议,约定任务怎么交出去、结果怎么返回。

可以先定义两种数据结构:任务消息和执行结果。

python
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,只用来展示消息的传递过程。

python
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。

请求模型的消息大致如下:

python
messages = [
    {
        "role": "system",
        "content": (
            "你是一名技术研究员。只研究分配给你的方案。"
            "输出实现方式、适用场景、局限和证据来源。"
            "证据不足时明确说明,不要编造来源。"
        ),
    },
    {
        "role": "user",
        "content": (
            "研究主题:Research Agent 的实现方式\n"
            "你的任务:研究 LangGraph 方案\n"
            "请给出实现方式、适用场景、局限和证据来源。"
        ),
    },
]

上面展示的是发送给模型的消息结构,并没有绑定具体厂商的 API。真实代码还需要调用所选模型接口,并解析、校验返回结果。

4. 共享状态:程序如何掌握全局进度

消息负责把任务交给 Agent、把结果带回来;程序还需要记录整个协作过程。例如哪些任务还没开始、哪些正在执行、哪些成功、哪些失败,以及每个任务的结果是什么。

可以用一个字典实现最小的任务账本:

python
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. 独立任务可以并行执行

三个研究任务相互独立时,可以使用线程池并行执行。下面是核心代码:

python
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 生成最终报告。汇总时应该保留证据来源,不能只把几段没有出处的结论拼在一起。

python
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、三个研究节点、结果检查和报告生成分别建成节点,并根据任务状态决定走向。

python
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 开始,只有当任务确实能够独立拆分、上下文隔离或并行执行带来收益时,再逐步增加协作复杂度。

本文目录