返回专栏
· 34 分钟阅读

多智能体系统(Multi-Agent):架构、协作机制与工程实践


一、什么是多智能体系统

Multi-Agent System(多智能体系统,简称 MAS)是由多个 Agent 组成的协作系统。每个 Agent 可以拥有独立的角色定义、任务目标、上下文、工具权限和决策能力,并通过通信与协调机制共同完成复杂任务。

传统单 Agent 系统通常由一个 Agent 负责理解任务、制定计划、调用工具和生成结果。

当任务复杂度提高时,单 Agent 容易面临以下问题:

  • 上下文过长,难以管理大量任务信息。
  • 一个 Agent 同时承担多个角色,容易产生职责混乱。
  • 多个任务无法充分并行执行。
  • 缺少独立审查机制,容易出现自我评估偏差。
  • 单个 Agent 的工具和专业能力存在边界。
  • 长任务执行过程复杂,状态管理困难。

多智能体系统通过职责拆分和协作机制,将复杂任务分配给多个专门的 Agent。

例如,开发一个完整的软件系统,可以设置:

Agent 职责
Coordinator Agent 负责整体任务协调
Planner Agent 负责需求分析和任务规划
Architect Agent 负责系统架构设计
Developer Agent 负责代码实现
Tester Agent 负责测试和质量验证
Reviewer Agent 负责代码审查
Documentation Agent 负责技术文档编写

每个 Agent 只需要重点处理自己负责的任务,通过协作完成整个项目。

1.1 Agent 与 Multi-Agent 的区别

维度 Single-Agent Multi-Agent
执行主体 一个 Agent 多个 Agent
任务分配 一个 Agent 自行处理 由协调机制分配
专业分工 依靠单 Agent 的上下文和提示词 不同 Agent 承担不同角色
并行能力 有限 支持任务并行
上下文管理 集中在一个执行主体 可以按角色隔离
协作方式 内部推理与工具调用 Agent 间通信与协作
质量控制 主要依赖自身验证 可以引入独立审查者
系统复杂度 相对较低 较高
运行成本 通常较低 通常较高

需要注意:多智能体不意味着一定比单智能体更强。

如果任务本身简单,多个 Agent 之间的通信、协调和结果整合可能带来额外成本。

多智能体真正适合的是具有明确分工、复杂依赖、并行空间或独立审查需求的任务。

1.2 Multi-Agent 的核心特征

1. 自主性(Autonomy)

每个 Agent 可以根据自身目标和上下文进行独立决策。

2. 专业分工(Specialization)

不同 Agent 可以承担不同领域的任务,例如研究、编程、测试和审查。

3. 协作性(Collaboration)

Agent 通过消息、共享状态或任务交接完成协作。

4. 并行性(Parallelism)

相互独立的子任务可以同时执行,提高整体效率。

5. 分布式决策(Distributed Decision-Making)

系统可以由多个 Agent 分别完成局部决策,再通过协调机制形成整体方案。

6. 可扩展性(Scalability)

可以根据业务需要增加新的 Agent、工具和专业能力。


二、多智能体系统的整体架构

多智能体系统不是简单地创建多个 LLM 实例,而是需要建立一套完整的协作基础设施。

2.1 核心架构

典型的 Multi-Agent 系统可以分为六个层次:

层次 核心模块 主要职责
任务入口层 Task Interface 接收用户任务和约束
协调控制层 Coordinator、Orchestrator 任务分解、分配、调度和终止
Agent 执行层 Specialized Agents 独立完成专业任务
通信协作层 Message Bus、Protocol Agent 间消息传递
共享状态层 Shared State、Memory 管理任务状态和共享信息
基础设施层 LLM、Tools、Storage 提供模型、工具和持久化能力

整体架构:

flowchart TB
    A["用户任务"] --> B["任务入口层"]
    B --> C["协调控制层"]
    C --> D["Agent 执行层"]
    D --> E["通信协作层"]
    E --> D
    D --> F["共享状态与记忆层"]
    F --> D
    D --> G["基础设施层"]
    G --> D
    C --> H["结果汇总与质量控制"]
    H --> I["最终结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2.2 Coordinator:协调器

Coordinator 是多智能体系统的核心控制角色,负责管理 Agent 之间的任务协作。

主要职责:

  • 接收和理解用户任务。
  • 将复杂任务拆分为多个子任务。
  • 选择适合的 Agent。
  • 分配执行顺序和依赖关系。
  • 管理 Agent 的执行状态。
  • 收集和整合执行结果。
  • 处理失败、超时和重试。
  • 判断任务是否完成。

Coordinator 可以由 LLM 驱动,也可以由传统程序控制。

两种实现方式:

LLM 驱动协调器

通过模型理解任务、选择 Agent 和动态调整执行计划。

优势是灵活,适合复杂和不确定的任务。

缺点是决策结果具有一定随机性,执行成本也相对较高。

规则驱动协调器

通过预定义流程、状态机和条件判断控制 Agent。

优势是可预测、易调试、执行成本低。

缺点是灵活性有限,需要提前设计任务流程。

生产环境通常采用混合架构:

  • LLM 负责复杂任务理解和动态决策。
  • 程序负责状态管理、权限控制和流程执行。
  • 规则负责关键条件判断和安全约束。

2.3 Specialized Agent:专业 Agent

每个 Agent 应该有明确的职责边界。

一个 Agent 通常包含以下组成部分:

组成 作用
Role 定义 Agent 的身份和职责
Goal 定义需要完成的目标
System Prompt 约束行为和输出要求
LLM 提供推理和生成能力
Tools 提供外部操作能力
Memory 保存当前或历史上下文
State 维护当前任务状态
Output Schema 规范输出格式

例如,一个 Research Agent:

角色:
    你是一名技术研究 Agent。

目标:
    收集指定技术领域的可靠资料。

职责:
    1. 搜索相关技术文档。
    2. 比较不同技术方案。
    3. 核验重要事实。
    4. 整理关键结论。
    5. 提供来源和证据。

约束:
    1. 不得编造来源。
    2. 不确定的信息必须明确标记。
    3. 不负责最终报告的整体决策。
    4. 输出必须符合约定的数据结构。

Agent 的职责越明确,协作时越容易控制任务边界。


三、多智能体的角色设计与组织模式

多智能体系统的设计首先需要明确:Agent 如何组织、谁负责协调、任务如何分配。

3.1 Manager-Worker 模式

Manager-Worker 是最常见的多智能体组织方式。

一个 Manager 负责任务规划和分配,多个 Worker 分别执行子任务。

例如,技术研究任务:

  • Manager:拆分研究主题。
  • Researcher A:研究技术原理。
  • Researcher B:研究架构设计。
  • Researcher C:研究工程实践。
  • Reviewer:审查研究结果。

执行流程:

flowchart TD
    A["用户研究任务"] --> B["Manager Agent"]
    B --> C["任务拆分"]
    C --> D["Researcher A"]
    C --> E["Researcher B"]
    C --> F["Researcher C"]
    D --> G["结果汇总"]
    E --> G
    F --> G
    G --> H["Reviewer Agent"]
    H --> I["最终研究报告"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 组织结构清晰。
  • 任务分配集中。
  • 容易监控整体进度。
  • 适合复杂任务拆分和并行处理。

缺点:

  • Manager 容易成为性能瓶颈。
  • Manager 决策错误可能影响所有 Worker。
  • Worker 之间通常缺少直接协作能力。

适用场景:研究分析、内容生成、软件开发、数据处理。

3.2 Hierarchical:层级式协作

层级式结构通常具有多个管理层次。

例如:

  • 总协调 Agent 负责整体目标。
  • 技术负责人 Agent 负责技术任务。
  • 产品负责人 Agent 负责需求任务。
  • 具体执行 Agent 负责实际工作。
flowchart TD
    A["Master Coordinator"] --> B["技术负责人 Agent"]
    A --> C["产品负责人 Agent"]
    A --> D["质量负责人 Agent"]
    B --> E["开发 Agent"]
    B --> F["架构 Agent"]
    C --> G["需求分析 Agent"]
    C --> H["文档 Agent"]
    D --> I["测试 Agent"]
    D --> J["审查 Agent"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D

优点:

  • 适合大型复杂任务。
  • 能够分层管理职责。
  • 支持不同领域独立规划。
  • 降低单一协调器的管理负担。

缺点:

  • 层级较多,通信成本较高。
  • 上下层之间可能出现信息损失。
  • 故障定位和状态管理更复杂。

3.3 Peer-to-Peer:对等协作

Peer-to-Peer 模式中,Agent 之间没有固定的中心管理者,可以直接交换信息和协商。

例如,多个研究 Agent 分别分析一个技术方案:

  • Agent A 负责性能。
  • Agent B 负责安全。
  • Agent C 负责成本。
  • Agent D 负责兼容性。

它们可以相互讨论,交换证据,形成共同结论。

flowchart TD
    A["Agent A 性能分析"] <--> B["Agent B 安全分析"]
    B <--> C["Agent C 成本分析"]
    C <--> D["Agent D 兼容性分析"]
    D <--> A
    A <--> C
    B <--> D
    A --> E["共同决策"]
    B --> E
    C --> E
    D --> E

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 没有单一协调器瓶颈。
  • Agent 可以直接交换专业信息。
  • 适合需要多方协商的问题。

缺点:

  • 消息数量可能快速增长。
  • 容易产生意见冲突。
  • 需要设计共识和终止机制。
  • 难以统一控制执行状态。

如果有 N 个 Agent,采用完全连接的通信方式,潜在的双向连接数量为:

E = \frac{N(N-1)}{2}

因此,Agent 数量增加时,通信和协调成本可能迅速上升。

3.4 Pipeline:流水线协作

Pipeline 模式将复杂任务拆分为一系列有先后依赖关系的处理阶段。

每个 Agent 负责其中一个阶段,前一个 Agent 的输出成为下一个 Agent 的输入。

例如内容生产:

  1. Research Agent 收集资料。
  2. Analyst Agent 分析资料。
  3. Writer Agent 撰写文章。
  4. Reviewer Agent 审核内容。
  5. Editor Agent 完成修改。
flowchart LR
    A["Research Agent"] --> B["Analyst Agent"]
    B --> C["Writer Agent"]
    C --> D["Reviewer Agent"]
    D --> E["Editor Agent"]
    E --> F["最终文章"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 任务阶段清晰。
  • 容易追踪执行状态。
  • 每个阶段可以独立测试。
  • 适合标准化处理流程。

缺点:

  • 前后阶段存在依赖。
  • 上游错误可能向下游传播。
  • 某个阶段阻塞会影响整个流水线。

3.5 Debate:辩论协作

Debate 模式让多个 Agent 从不同立场分析同一个问题,再通过交叉审查和仲裁形成结论。

例如技术选型:

  • Agent A 支持微服务架构。
  • Agent B 支持模块化单体架构。
  • Agent C 负责审查双方证据。
  • Judge Agent 负责最终决策。
flowchart TD
    A["输入技术决策问题"] --> B["正方 Agent"]
    A --> C["反方 Agent"]
    B --> D["交叉质询"]
    C --> D
    D --> E["Reviewer Agent"]
    E --> F["Judge Agent"]
    F --> G["最终决策"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 可以发现单一视角容易遗漏的问题。
  • 支持多方案比较。
  • 适合复杂决策和风险评估。

缺点:

  • 多轮讨论成本较高。
  • Agent 可能只是重复表达不同观点。
  • 多数意见不一定代表正确结论。
  • Judge 仍然可能出现判断偏差。

因此,辩论机制应该要求各 Agent 提供证据、约束条件和可验证的论据,而不是只比较表达能力。

3.6 混合协作模式

实际生产系统通常不会只采用一种固定拓扑。

例如,一个软件研发系统可以采用:

  • 顶层 Manager-Worker 负责整体任务分配。
  • 开发团队内部采用 Pipeline。
  • 技术方案采用 Debate。
  • 测试与开发采用并行协作。
  • Reviewer 独立审查最终结果。

混合模式能够根据任务特征选择合适的协作结构,但也需要更复杂的协调和状态管理。


四、多智能体的任务分解与调度

任务分解是多智能体系统最重要的基础能力之一。

如果任务拆分不合理,即使每个 Agent 都具备较强能力,也可能无法获得良好的整体结果。

4.1 任务分解

Coordinator 首先需要理解用户目标,再将其转换为多个可执行的子任务。

一个合格的子任务应尽可能满足:

  • 目标明确。
  • 输入信息完整。
  • 输出结果可验证。
  • 执行职责清晰。
  • 依赖关系明确。
  • 具有合理的工作量。

例如,用户要求:

设计一个在线商城系统,包括:
1. 用户管理。
2. 商品管理。
3. 订单管理。
4. 支付系统。
5. 数据库设计。
6. 系统测试。

可以拆分为:

子任务 负责 Agent 依赖关系
用户管理设计 User Agent 基础需求
商品管理设计 Product Agent 基础需求
订单管理设计 Order Agent 用户、商品设计
支付系统设计 Payment Agent 订单设计
数据库设计 Database Agent 领域模型
系统测试 Tester Agent 各模块接口

任务拆分不能只按照数量平均分配,还需要考虑依赖关系和工作量。

4.2 DAG 任务依赖

复杂任务通常存在依赖关系,可以使用有向无环图(DAG)表示。

例如:

flowchart TD
    A["需求分析"] --> B["用户模块设计"]
    A --> C["商品模块设计"]
    B --> D["订单模块设计"]
    C --> D
    D --> E["支付模块设计"]
    B --> F["数据库设计"]
    C --> F
    D --> F
    E --> G["系统集成"]
    F --> G
    G --> H["系统测试"]
    H --> I["最终交付"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

DAG 中:

  • 节点表示任务。
  • 有向边表示任务依赖。
  • 没有依赖关系的任务可以并行执行。
  • 所有前置任务完成后,后续任务才能启动。

使用 DAG 可以进行拓扑排序,得到合法执行顺序。

4.3 并行任务调度

如果多个任务互相独立,可以同时分配给不同 Agent。

例如:

flowchart TD
    A["任务规划"] --> B["任务 A"]
    A --> C["任务 B"]
    A --> D["任务 C"]
    B --> E["等待结果汇总"]
    C --> E
    D --> E
    E --> F["执行下一阶段"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

并行执行能够缩短总耗时,但并不意味着 Agent 越多越好。

需要考虑:

  • 可并行任务数量。
  • Agent 启动和调度成本。
  • LLM API 并发限制。
  • 工具和数据库连接限制。
  • 结果汇总成本。
  • 共享资源竞争。

4.4 任务调度策略

常见调度方式:

调度策略 原理 适用场景
Round Robin 轮询分配任务 Agent 能力相近
Least Loaded 分配给负载最低的 Agent 工作量不均衡
Capability Based 根据能力匹配 Agent 专业角色明确
Priority Based 优先处理高优先级任务 任务有优先级
Dependency Based 根据依赖关系调度 DAG 工作流
Dynamic Scheduling 根据执行反馈动态调整 不确定性较高的任务

生产系统通常需要综合任务能力、优先级、负载、资源预算和依赖关系进行调度。


五、多智能体通信机制

多个 Agent 需要通过通信交换任务、信息和执行结果。

通信机制决定了多智能体系统的协作效率、可扩展性和可靠性。

5.1 通信的基本类型

1. Direct Message:直接消息

一个 Agent 将消息发送给指定 Agent。

适合明确的任务交接和定向协作。

2. Broadcast:广播消息

一个 Agent 将消息发送给多个 Agent。

适合发布公共任务信息、状态变化和共享约束。

3. Publish-Subscribe:发布订阅

Agent 发布事件,订阅相关事件的 Agent 接收消息。

适合异步解耦和事件驱动架构。

4. Shared State:共享状态

多个 Agent 通过统一状态存储交换任务信息。

适合需要共享任务进度、结果和协作上下文的系统。

5.2 消息传递架构

flowchart TD
    A["Agent A"] --> B["Message Bus"]
    C["Agent B"] --> B
    D["Agent C"] --> B
    B --> E["Agent Router"]
    E --> F["Agent D"]
    E --> G["Agent E"]
    E --> H["Agent F"]
    F --> I["共享状态存储"]
    G --> I
    H --> I

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

5.3 Agent 消息结构

生产环境不应该只传递一段普通文本,而应使用结构化消息。

例如:

{
  "message_id": "msg_001",
  "task_id": "task_001",
  "sender": "planner_agent",
  "receiver": "developer_agent",
  "message_type": "task_assignment",
  "correlation_id": "corr_001",
  "payload": {
    "task": "实现用户查询接口",
    "requirements": [
      "支持用户 ID 查询",
      "处理用户不存在情况",
      "返回统一 JSON 格式"
    ]
  },
  "priority": "high",
  "created_at": "2026-11-20T10:00:00Z",
  "deadline": "2026-11-20T10:10:00Z"
}

重要字段:

字段 作用
message_id 消息唯一标识
task_id 所属任务
sender 消息发送者
receiver 消息接收者
message_type 消息类型
correlation_id 关联请求和响应
payload 实际消息内容
priority 消息优先级
created_at 创建时间
deadline 任务截止时间

还可以增加:

  • trace_id:跨 Agent 链路追踪。
  • schema_version:消息结构版本。
  • reply_to:回复关联消息。
  • idempotency_key:幂等处理标识。
  • metadata:模型、工具和执行环境信息。

5.4 通信协议与消息语义

多 Agent 通信不仅需要解决消息如何发送,还需要明确消息代表什么操作。

常见消息类型:

类型 含义
task_assignment 分配任务
task_acceptance 接受任务
task_rejection 拒绝任务
task_progress 汇报进度
task_result 返回执行结果
clarification 请求补充信息
error 报告执行错误
cancellation 请求取消任务
handoff 交接控制权
approval_request 请求审批

还需要定义消息状态:

  • 已创建。
  • 已发送。
  • 已接收。
  • 已确认。
  • 已处理。
  • 已失败。
  • 已过期。

消息被成功发送,并不意味着接收方已经完成处理。

因此,需要区分消息投递状态和任务执行状态。


六、多智能体的共享状态与记忆管理

多个 Agent 通常需要共享部分信息,但并不意味着所有 Agent 应该访问完全相同的上下文。

合理的状态和记忆设计,是避免信息混乱和上下文污染的关键。

6.1 共享状态与私有状态

多智能体系统通常同时存在两种状态。

私有状态(Private State)

由单个 Agent 独立维护。

例如:

  • 当前 Agent 的推理上下文。
  • 当前 Agent 的执行计划。
  • Agent 的临时观察结果。
  • 当前 Agent 的工具调用状态。

共享状态(Shared State)

多个 Agent 可以读取或按照权限修改。

例如:

  • 整体任务目标。
  • 子任务分配情况。
  • 公共需求和约束。
  • 已完成任务结果。
  • 共享领域模型。
  • 全局执行进度。
数据类型 推荐存储方式 访问范围
Agent 私有上下文 Agent Context 单个 Agent
当前任务状态 Task State Store 相关 Agent
公共执行结果 Shared State 授权 Agent
历史经验 Long-term Memory 按需检索
消息记录 Message Store 通信系统
执行轨迹 Trace Store 监控与审计

6.2 共享状态的更新冲突

假设两个 Agent 同时修改订单状态:

  • Agent A 将订单标记为已支付。
  • Agent B 将订单标记为已取消。

如果没有并发控制,可能产生状态覆盖和业务不一致。

常见解决方案:

1. 单写者原则

一个共享状态只允许指定的 Agent 或服务负责写入。

2. 乐观锁

通过版本号检测并发修改。

3. 事务控制

将相关更新放入事务,保证原子性。

4. 事件溯源

保存状态变化事件,根据事件重建当前状态。

5. 状态机约束

只允许合法的状态转换。

例如订单状态:

stateDiagram-v2
    [*] --> Pending
    Pending --> Paid
    Pending --> Cancelled
    Paid --> Shipped
    Shipped --> Completed
    Paid --> Refunding
    Refunding --> Refunded
    Cancelled --> [*]
    Completed --> [*]
    Refunded --> [*]

该图展示订单状态之间的合法转换关系。对于涉及资金和库存的状态更新,还需要使用数据库事务、幂等键和业务补偿机制。

6.3 多 Agent Memory

多智能体系统可以采用分层记忆结构:

记忆层 内容 主要用途
Agent Short-term Memory 当前 Agent 的临时上下文 单 Agent 执行
Task Memory 当前任务的共享信息 多 Agent 协作
Episodic Memory 历史任务执行经历 复用历史经验
Semantic Memory 稳定知识和事实 专业知识检索
Procedural Memory 流程和执行经验 复用任务方法

记忆管理需要明确:

  • 谁可以读取。
  • 谁可以写入。
  • 哪些信息允许共享。
  • 信息是否经过验证。
  • 信息的有效期。
  • 冲突如何解决。
  • 敏感数据如何隔离。

特别需要避免将一个 Agent 的未经验证结论直接当成全局事实传播给其他 Agent。


七、多智能体的协作控制与任务交接

Agent 之间的协作不能仅依赖自然语言对话,还需要明确控制权和任务状态。

7.1 Handoff:任务交接

Handoff 是指一个 Agent 将当前任务或控制权交给另一个 Agent。

例如:

  • Planner 将代码实现任务交给 Developer。
  • Developer 将代码审查任务交给 Reviewer。
  • Reviewer 发现问题后将修改任务交回 Developer。

一个完整的 Handoff 应包含:

  1. 当前任务目标。
  2. 已完成工作。
  3. 当前执行状态。
  4. 相关上下文。
  5. 剩余任务。
  6. 交接原因。
  7. 接收方预期动作。

交接流程:

flowchart TD
    A["Agent A 执行任务"] --> B["判断是否需要交接"]
    B --> C{"是否需要其他 Agent"}
    C -->|"否"| D["继续当前任务"]
    C -->|"是"| E["构建交接上下文"]
    E --> F["发送 Handoff 消息"]
    F --> G["Agent B 接收任务"]
    G --> H["确认任务与上下文"]
    H --> I{"是否接受任务"}
    I -->|"是"| J["Agent B 开始执行"]
    I -->|"否"| K["返回拒绝原因"]
    K --> L["协调器重新分配"]

    style A fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

7.2 Agent 协作状态机

一个任务在多智能体系统中可能经历多个状态。

状态 含义
CREATED 任务已创建
ASSIGNED 已分配 Agent
ACCEPTED Agent 已接受
RUNNING 正在执行
WAITING 等待依赖或外部事件
REVIEWING 正在审查
COMPLETED 执行完成
FAILED 执行失败
CANCELLED 已取消
EXPIRED 已过期

任务状态应由协调器或任务管理服务统一维护,避免多个 Agent 随意修改同一任务的生命周期。

7.3 超时、取消与重试

生产环境中,Agent 可能出现:

  • 模型调用超时。
  • 工具调用失败。
  • Agent 无响应。
  • 输出格式错误。
  • 执行时间超过截止时间。
  • 任务依赖长期未完成。

需要设计统一的执行控制:

flowchart TD
    A["任务分配"] --> B["Agent 开始执行"]
    B --> C["监控执行状态"]
    C --> D{"是否按时完成"}
    D -->|"是"| E["接收任务结果"]
    D -->|"否"| F["触发超时处理"]
    F --> G{"是否允许重试"}
    G -->|"是"| H["检查幂等性与重试预算"]
    H --> I{"是否允许再次执行"}
    I -->|"是"| J["重新执行或重新分配"]
    I -->|"否"| K["任务失败"]
    G -->|"否"| K
    E --> L["结果校验"]
    J --> C

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

特别注意:任务超时并不代表原 Agent 已经停止执行。

如果直接将任务分配给另一个 Agent,可能出现两个 Agent 同时执行同一任务。

对于有副作用的操作,必须使用幂等键、执行租约或资源锁,防止重复执行。


八、多智能体的结果整合与质量控制

多个 Agent 分别完成子任务后,还需要将结果整合成一致的最终输出。

这一步经常被低估。

不同 Agent 可能:

  • 使用不同的数据来源。
  • 得出互相矛盾的结论。
  • 采用不同的术语和数据格式。
  • 对同一问题作出不同假设。
  • 忽略其他 Agent 的约束。

因此,结果整合不能简单地拼接多个 Agent 的输出。

8.1 结果整合机制

典型流程:

flowchart TD
    A["收集各 Agent 结果"] --> B["结构化结果解析"]
    B --> C["检查任务完整性"]
    C --> D["检查事实与证据"]
    D --> E["识别结果冲突"]
    E --> F{"是否存在冲突"}
    F -->|"否"| G["统一结果格式"]
    F -->|"是"| H["冲突分析与协调"]
    H --> I["补充验证或重新分配任务"]
    I --> D
    G --> J["Reviewer 最终审查"]
    J --> K{"是否通过验收"}
    K -->|"是"| L["生成最终结果"]
    K -->|"否"| M["返回修正任务"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#F7EAE7,stroke:#C98D7C,color:#754438

8.2 结果冲突处理

当多个 Agent 的结果存在冲突时,可以采用以下策略:

策略 原理 适用场景
Evidence Based 根据证据质量决定 研究和事实核验
Rule Based 按预定义规则裁决 业务约束明确
Expert Review 由专业 Agent 复核 专业技术问题
Majority Voting 根据多数意见决定 多个独立判断
Re-execution 重新执行验证 结果存在疑问
Human Review 人工最终裁决 高风险决策

多数投票并不总是可靠。

如果多个 Agent 使用相同模型、相同资料和相似提示词,它们可能产生高度相关的错误。

因此,结果整合应优先关注证据、独立性和可验证性,而不是单纯统计支持人数。

8.3 多 Agent 质量评估

可以从以下维度评估系统:

  • 子任务完成率。
  • 任务依赖满足率。
  • 结果一致性。
  • 事实准确性。
  • 证据完整性。
  • 最终任务成功率。
  • 失败恢复能力。

对于关键输出,可以要求每个 Agent 提供结构化结果:

{
  "agent_id": "research_agent_01",
  "task_id": "research_001",
  "status": "completed",
  "summary": "研究结论摘要",
  "findings": [
    {
      "claim": "技术方案支持水平扩展",
      "evidence": "官方技术文档中的相关说明",
      "confidence": 0.92
    }
  ],
  "limitations": [
    "缺少特定版本的性能测试数据"
  ],
  "recommended_next_steps": [
    "补充实际负载测试"
  ]
}

九、多智能体系统的工程实现

下面通过 Python 构建一个简化的 Multi-Agent 系统,理解任务分配、Agent 执行和结果汇总的核心逻辑。

9.1 定义 Agent

from dataclasses import dataclass, field
from typing import Callable, Any


@dataclass
class Agent:
    name: str
    role: str
    handler: Callable[[dict], Any]

    def run(self, task: dict):
        return self.handler(task)

每个 Agent 包含:

  • name:Agent 名称。
  • role:Agent 职责。
  • handler:具体执行逻辑。

9.2 定义任务

@dataclass
class Task:
    task_id: str
    description: str
    assigned_agent: str
    dependencies: list[str] = field(
        default_factory=list
    )
    status: str = "pending"
    result: Any = None

任务包含唯一标识、任务描述、执行者、依赖关系、执行状态和结果。

9.3 创建专业 Agent

def research_handler(task):
    return {
        "topic": task["description"],
        "result": "完成技术资料收集",
        "status": "success"
    }


def analysis_handler(task):
    return {
        "topic": task["description"],
        "result": "完成技术分析",
        "status": "success"
    }


def review_handler(task):
    return {
        "result": "审查通过",
        "status": "success"
    }


research_agent = Agent(
    name="research_agent",
    role="技术研究",
    handler=research_handler
)

analysis_agent = Agent(
    name="analysis_agent",
    role="技术分析",
    handler=analysis_handler
)

review_agent = Agent(
    name="review_agent",
    role="质量审查",
    handler=review_handler
)