返回专栏
· 31 分钟阅读

Agent 协作模式与编排策略


一、什么是 Agent 协作与编排

在单 Agent 系统中,一个智能体通常独立完成任务,包括理解需求、规划步骤、调用工具和生成结果。

但在复杂任务中,单个 Agent 往往面临以下限制:

  • 能力边界明显:一个 Agent 很难同时精通代码开发、数据分析、法律审查和业务决策。
  • 上下文负担过重:任务越复杂,需要处理的信息越多,容易超出上下文窗口或降低推理质量。
  • 执行过程难以并行:多个相互独立的子任务如果由一个 Agent 顺序执行,会浪费计算资源和时间。
  • 缺少独立验证机制:同一个 Agent 既负责生成结果,又负责判断结果是否正确,容易产生自我验证偏差。
  • 任务状态难以管理:长流程任务需要持续追踪进度、依赖关系和执行结果。

多 Agent 协作通过多个具有不同职责和能力的 Agent 共同完成任务。

其中需要区分两个核心概念:

概念 核心职责 关注重点
Agent 协作模式 定义 Agent 之间如何合作 角色、通信、分工、信息共享
Agent 编排策略 决定任务如何组织和执行 调度、依赖、并发、控制流、异常处理

可以将二者理解为:

  • 协作模式解决谁与谁合作、如何合作。
  • 编排策略解决任务由谁执行、何时执行、如何衔接。

二、Agent 协作的基本架构

一个典型的多 Agent 协作系统通常包含任务入口、编排器、多个专业 Agent、共享上下文和结果汇总模块。

1. 核心组件

组件 主要职责
User Interface 接收用户请求并展示结果
Orchestrator 负责任务拆解、调度和流程控制
Planner Agent 分析目标并制定执行计划
Worker Agent 执行具体任务
Specialist Agent 提供专业领域能力
Reviewer Agent 检查结果质量和正确性
Shared Context 保存共享任务信息和中间结果
State Manager 管理任务状态、执行状态和恢复信息
Result Aggregator 汇总多个 Agent 的执行结果

2. 基本架构图

flowchart TD
    A["用户请求"] --> B["Orchestrator 编排器"]
    B --> C["Planner Agent 任务规划"]

    C --> D["任务分解与依赖分析"]
    D --> E["Agent 调度器"]

    E --> F["Research Agent"]
    E --> G["Analysis Agent"]
    E --> H["Execution Agent"]

    F --> I["Shared Context"]
    G --> I
    H --> I

    I --> J["Reviewer Agent"]
    J --> K{"结果是否通过"}

    K -->|"否"| E
    K -->|"是"| L["Result Aggregator"]
    L --> M["返回最终结果"]

    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

实际系统中,Orchestrator 不一定是一个独立的 LLM Agent,也可以是由普通程序实现的工作流引擎。将确定性控制逻辑交给程序处理,通常更容易实现可靠的任务调度。

三、常见 Agent 协作模式

不同协作模式对应不同的任务结构。选择合适的模式,比单纯增加 Agent 数量更重要。

1. 顺序协作模式(Sequential)

顺序协作是最简单的多 Agent 模式。

多个 Agent 按照预先定义的顺序依次执行,后一个 Agent 使用前一个 Agent 的输出作为输入。

例如,生成一份技术方案:

  • Research Agent:收集技术资料。
  • Analysis Agent:分析技术选型。
  • Writer Agent:编写技术方案。
  • Reviewer Agent:检查内容和技术准确性。
flowchart TD
    A["开始任务"] --> B["Research Agent"]
    B --> C["Analysis Agent"]
    C --> D["Writer Agent"]
    D --> E["Reviewer Agent"]
    E --> F["输出最终结果"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 流程简单,容易实现。
  • Agent 职责明确。
  • 中间结果容易追踪。
  • 适合具有明确前后依赖关系的任务。

缺点:

  • 整体执行时间受所有步骤累计耗时影响。
  • 前一个 Agent 出错可能影响后续所有步骤。
  • 不适合大量相互独立的任务。

适用场景:内容生产、代码审查流水线、文档处理、数据处理流程。

2. 并行协作模式(Parallel)

并行协作适合多个任务之间没有强依赖关系的场景。

Orchestrator 将一个复杂任务拆分为多个独立子任务,并发分配给不同 Agent。

例如,研究一个技术主题时,可以同时安排:

  • Research Agent:搜索技术资料。
  • Architecture Agent:分析系统架构。
  • Security Agent:评估安全风险。
  • Performance Agent:分析性能问题。

所有 Agent 完成后,再由汇总 Agent 合并结果。

flowchart TD
    A["接收任务"] --> B["Orchestrator"]
    B --> C["任务拆分"]

    C --> D["Research Agent"]
    C --> E["Architecture Agent"]
    C --> F["Security Agent"]
    C --> G["Performance Agent"]

    D --> H["结果汇总"]
    E --> H
    F --> H
    G --> H

    H --> I["生成综合报告"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 能够缩短总体执行时间。
  • 可以利用多个 Agent 的专业能力。
  • 子任务之间具有较好的隔离性。

缺点:

  • 需要处理并发调度和资源竞争。
  • 多个 Agent 可能产生重复或矛盾的结果。
  • 汇总阶段需要解决结果冲突。
  • 并行数量过多会增加模型调用成本。

并行模式需要重点关注任务之间是否真正独立。如果多个 Agent 同时修改同一份共享数据,就可能出现写入冲突。

适用场景:多角度研究、并行数据分析、多模块代码审查、方案评估。

3. 层级协作模式(Hierarchical)

层级协作采用管理者与执行者的结构。

上层 Agent 负责规划和分配任务,下层 Agent 负责执行具体工作。复杂任务还可以继续向下分解,形成多层级结构。

例如:

  • Manager Agent:负责整个项目。
  • Backend Agent:负责后端开发。
  • Frontend Agent:负责前端开发。
  • Test Agent:负责测试。
  • Security Agent:负责安全检查。
flowchart TD
    A["Manager Agent"] --> B["Backend Agent"]
    A --> C["Frontend Agent"]
    A --> D["Test Agent"]

    B --> E["API 开发"]
    B --> F["数据库开发"]

    C --> G["页面开发"]
    C --> H["交互开发"]

    D --> I["单元测试"]
    D --> J["集成测试"]

    E --> K["执行结果"]
    F --> K
    G --> K
    H --> K
    I --> K
    J --> K

    K --> L["Manager 汇总"]

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

优点:

  • 适合复杂任务分解。
  • 职责边界清晰。
  • 支持多层级的任务管理。
  • 便于统一控制执行进度。

缺点:

  • 上层 Agent 可能成为性能瓶颈。
  • 层级过深会增加通信和协调成本。
  • 上层规划错误可能向下传递。
  • 子 Agent 的自主性受到管理者约束。

适用场景:复杂项目执行、企业级自动化、软件研发流程、跨领域任务管理。

4. 对等协作模式(Peer-to-Peer)

对等协作中,Agent 之间没有固定的上下级关系。

每个 Agent 都可以根据自身能力与任务需要,与其他 Agent 交换信息、请求帮助或提供服务。

例如,一个技术决策系统中:

  • Architecture Agent 提出架构方案。
  • Security Agent 评估安全性。
  • Performance Agent 评估性能。
  • Cost Agent 评估资源成本。

各 Agent 相互讨论,最终形成共同决策。

flowchart TD
    A["Architecture Agent"] <--> B["Security Agent"]
    A <--> C["Performance Agent"]
    A <--> D["Cost Agent"]
    B <--> C
    B <--> D
    C <--> D

    E["Consensus Agent"] --> A
    E --> B
    E --> C
    E --> D

    E --> F["形成最终决策"]

    style A fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • Agent 之间具有较高自主性。
  • 能够从不同角度讨论复杂问题。
  • 不依赖单一中心节点进行所有决策。

缺点:

  • 通信关系复杂。
  • 容易产生重复讨论。
  • 可能出现意见分歧和循环协商。
  • 需要额外的共识机制。

适用场景:多专家协商、复杂决策、开放式问题研究。

需要注意,对等协作不代表完全没有协调机制。实际系统仍然需要定义消息格式、协商规则、终止条件和冲突解决策略。

5. 竞争协作模式(Competitive)

竞争模式让多个 Agent 独立完成相同任务,再通过评分、评审或投票机制选出更好的结果。

例如,让三个 Agent 分别生成代码实现,再由 Reviewer Agent 评估代码质量。

flowchart TD
    A["接收任务"] --> B["并发生成方案"]

    B --> C["Agent A"]
    B --> D["Agent B"]
    B --> E["Agent C"]

    C --> F["方案评估"]
    D --> F
    E --> F

    F --> G["评分与排序"]
    G --> H{"是否存在合格方案"}

    H -->|"是"| I["选择最佳方案"]
    H -->|"否"| J["重新生成或调整任务"]

    I --> K["输出结果"]
    J --> B

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    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
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 能够获得多个独立方案。
  • 降低单次生成结果不理想的风险。
  • 适合需要比较和择优的任务。

缺点:

  • 多次调用模型会增加成本。
  • 评估器可能存在偏差。
  • 多个 Agent 可能产生相似结果,无法带来真正的多样性。

适用场景:代码生成、方案比较、内容创作、复杂问题求解。

6. 混合协作模式(Hybrid)

实际工程中,单一协作模式通常无法覆盖复杂业务需求。

混合模式将顺序、并行、层级、竞争等模式组合起来,根据任务结构选择不同的执行方式。

例如,一个自动化软件开发系统可以采用:

  1. Planner Agent 负责整体任务规划。
  2. 多个开发 Agent 并行开发不同模块。
  3. 集成 Agent 按顺序完成模块整合。
  4. 多个测试 Agent 并行执行测试。
  5. Reviewer Agent 进行最终审核。
flowchart TD
    A["用户需求"] --> B["Planner Agent"]
    B --> C["任务分解"]

    C --> D["Backend Agent"]
    C --> E["Frontend Agent"]
    C --> F["Database Agent"]

    D --> G["Integration Agent"]
    E --> G
    F --> G

    G --> H["并行测试"]

    H --> I["Unit Test Agent"]
    H --> J["Security Test Agent"]
    H --> K["Performance Test Agent"]

    I --> L["Reviewer Agent"]
    J --> L
    K --> L

    L --> M{"是否通过"}
    M -->|"否"| B
    M -->|"是"| N["交付结果"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F

混合模式具有更强的表达能力,但也会增加系统设计复杂度。应当优先保证每个阶段的边界清晰,再考虑组合更多协作模式。

四、Agent 编排的核心策略

协作模式定义了合作关系,而编排策略决定系统如何实际运行。

1. 静态编排(Static Orchestration)

静态编排是在系统设计阶段就确定任务执行顺序和调用关系。

例如:

flowchart TD
    A["任务开始"] --> B["Agent A"]
    B --> C["Agent B"]
    C --> D["Agent C"]
    D --> E["任务结束"]

    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:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F

特点:

  • 执行路径固定。
  • 流程容易预测。
  • 调试和测试相对简单。
  • 适合稳定、标准化的业务。

缺点是灵活性较低。如果运行过程中出现新任务,通常需要预先设计相应分支。

2. 动态编排(Dynamic Orchestration)

动态编排根据当前任务状态、执行结果和 Agent 能力,实时决定下一步执行动作。

例如,Planner Agent 可以根据用户需求动态选择专业 Agent。

flowchart TD
    A["接收任务"] --> B["分析任务类型"]
    B --> C["选择执行 Agent"]

    C --> D{"任务类型"}

    D -->|"技术研究"| E["Research Agent"]
    D -->|"数据分析"| F["Analysis Agent"]
    D -->|"代码开发"| G["Coding Agent"]

    E --> H["检查执行结果"]
    F --> H
    G --> H

    H --> I{"是否需要继续执行"}

    I -->|"是"| B
    I -->|"否"| J["完成任务"]

    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

特点:

  • 可以根据上下文动态选择 Agent。
  • 适应复杂和不确定的任务。
  • 支持动态增加或调整执行步骤。

缺点是执行路径不固定,系统测试、成本估算和异常恢复更加困难。

3. 基于 DAG 的任务编排

对于复杂任务,使用有向无环图(Directed Acyclic Graph,DAG)描述任务依赖关系,是一种非常实用的工程方案。

DAG 中:

  • 节点表示一个任务或 Agent 执行单元。
  • 有向边表示任务之间的依赖关系。
  • 无环约束保证任务依赖不存在循环。
  • 没有未完成前置依赖的节点可以进入可执行状态。

例如,构建一个技术报告:

  • 任务 A:收集技术资料。
  • 任务 B:收集行业数据。
  • 任务 C:分析技术架构,依赖 A。
  • 任务 D:分析市场趋势,依赖 B。
  • 任务 E:生成综合报告,依赖 C 和 D。
flowchart TD
    A["收集技术资料"] --> C["分析技术架构"]
    B["收集行业数据"] --> D["分析市场趋势"]

    C --> E["生成综合报告"]
    D --> E

    E --> F["质量审核"]

    style A fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    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:#DCEFE5,stroke:#4F8B70,color:#24563F

DAG 编排的执行过程:

flowchart TD
    A["加载任务 DAG"] --> B["检查任务依赖"]
    B --> C["查找可执行节点"]
    C --> D{"是否存在可执行任务"}

    D -->|"是"| E["提交任务调度器"]
    E --> F["并发执行任务"]
    F --> G["记录执行结果"]
    G --> H["更新依赖状态"]
    H --> C

    D -->|"否"| I{"所有任务是否完成"}
    I -->|"是"| J["汇总结果"]
    I -->|"否"| K["检测阻塞或失败任务"]

    K --> L["重试、跳过或终止"]
    L --> C

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    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

DAG 编排特别适合:

  • 大规模数据处理。
  • 多阶段文档分析。
  • 软件开发和测试。
  • 多 Agent 并行研究。
  • 具有复杂依赖关系的自动化任务。

需要注意: DAG 适合描述有明确依赖关系的任务,但不适合直接表达任意循环和持续对话。对于需要循环推理的 Agent 系统,可以将循环封装在单个任务节点内部,或者使用支持状态转换的工作流引擎。

4. 基于事件的编排(Event-Driven Orchestration)

事件驱动编排不要求所有 Agent 严格按照固定顺序执行,而是根据事件触发后续任务。

例如:

  • 任务完成事件触发结果汇总。
  • 审核失败事件触发重新执行。
  • 用户补充信息事件触发重新规划。
  • 超时事件触发故障恢复。
flowchart TD
    A["任务执行"] --> B["产生事件"]
    B --> C["事件总线"]

    C --> D["任务完成事件"]
    C --> E["审核失败事件"]
    C --> F["执行超时事件"]

    D --> G["结果汇总"]
    E --> H["重新执行任务"]
    F --> I["超时恢复处理"]

    H --> J["更新任务状态"]
    I --> J
    J --> K["继续编排"]

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

事件驱动模式适合异步任务、长时间运行任务以及多个独立服务之间的协作。

但它需要可靠的事件传递机制,并处理重复事件、事件乱序、消息丢失和消费者故障等问题。

5. 基于黑板的协作编排(Blackboard)

黑板模式通过一个共享的信息空间,让多个 Agent 读取和更新任务状态。

每个 Agent 不必直接与所有其他 Agent 通信,而是通过共享黑板交换信息。

例如:

  • Research Agent 写入研究资料。
  • Analysis Agent 读取资料并写入分析结论。
  • Reviewer Agent 读取分析结论并写入审查意见。
  • Orchestrator 根据黑板中的状态决定下一步执行动作。
flowchart TD
    A["Research Agent"] --> B["Shared Blackboard"]
    C["Analysis Agent"] <--> B
    D["Reviewer Agent"] <--> B
    E["Orchestrator"] <--> B
    F["Execution Agent"] <--> B

    B --> G["共享任务状态与中间结果"]

    style A fill:#EAF3EC,stroke:#83A995,color:#315D49
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

优点:

  • 降低 Agent 之间的直接通信耦合。
  • 便于保存中间结果。
  • 支持不同 Agent 在不同时间执行。
  • 方便系统恢复和状态追踪。

缺点:

  • 共享状态可能产生并发写入冲突。
  • 黑板可能成为性能瓶颈。
  • 需要设计数据版本、权限和一致性机制。

五、Agent 任务拆解与调度策略

编排的核心不是简单地调用多个 Agent,而是将复杂目标转换成可执行、可追踪、可恢复的任务。

1. 任务拆解策略

一个好的任务拆解结果应当满足:

  • 每个子任务有明确目标。
  • 每个子任务有可验证的输出。
  • 每个子任务有清晰的输入。
  • 每个子任务有明确的执行责任。
  • 子任务之间的依赖关系可以被描述。

例如,用户要求开发一个博客系统。

Planner Agent 可以拆解为:

任务 ID 子任务 执行 Agent 依赖
T1 需求分析 Planning Agent 无
T2 数据库设计 Backend Agent T1
T3 API 设计 Backend Agent T1
T4 前端页面设计 Frontend Agent T1
T5 后端开发 Backend Agent T2、T3
T6 前端开发 Frontend Agent T4、T3
T7 集成测试 Test Agent T5、T6
T8 安全审查 Security Agent T5、T6
T9 交付审核 Reviewer Agent T7、T8

拆解完成后,Orchestrator 根据依赖关系组织任务执行。

2. 基于能力的 Agent 路由

系统通常拥有多个 Agent,但不同 Agent 的能力和成本并不相同。

因此,需要建立 Agent 能力注册表。

例如:

Agent 能力 适用任务
Research Agent 信息检索、资料整理 技术调研
Coding Agent 代码生成、代码修改 软件开发
SQL Agent SQL 编写、数据库分析 数据查询
Security Agent 漏洞分析、安全审查 安全任务
Reviewer Agent 质量评估、结果验证 结果审核

路由过程:

flowchart TD
    A["接收子任务"] --> B["提取任务能力需求"]
    B --> C["查询 Agent 能力注册表"]
    C --> D["过滤不满足能力的 Agent"]
    D --> E["评估候选 Agent"]

    E --> F["综合能力、成本、负载和延迟"]
    F --> G{"是否存在可用 Agent"}

    G -->|"是"| H["选择最优 Agent"]
    G -->|"否"| I["降级、排队或返回失败"]

    H --> J["提交任务执行"]

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

Agent 选择不应只看能力匹配,还应考虑:

  • 模型推理能力。
  • 工具访问权限。
  • 当前并发负载。
  • 平均响应时间。
  • 调用成本。
  • 历史任务成功率。
  • 数据安全等级。

对于涉及权限或安全边界的任务,权限过滤应当先于成本和性能评分。

3. 任务优先级调度

当系统同时存在大量任务时,需要确定执行顺序。

常见调度策略包括:

策略 调度依据 适用场景
FIFO 先提交先执行 简单任务队列
Priority 优先级高的任务先执行 重要任务优先
Round Robin 轮流分配执行资源 多租户系统
Shortest Job First 预计耗时较短的任务优先 降低平均等待时间
Deadline 最接近截止时间的任务优先 有时限要求的任务
Weighted Fair Queueing 按权重分配资源 多业务资源隔离

生产系统通常不会只采用一种策略,而是组合优先级、截止时间、租户配额和资源限制。

4. 并发控制与资源管理

并行执行可以提升效率,但并发数量并不是越多越好。

需要控制:

  • 同时运行的 Agent 数量。
  • 模型 API 并发请求数。
  • 工具调用并发数。
  • 单任务最大 Token 消耗。
  • 每个用户的资源配额。
  • 共享数据的并发访问。

常见控制方式:

  • Semaphore:限制同时执行的任务数量。
  • Rate Limiter:控制请求速率。
  • Queue:缓冲待执行任务。
  • Worker Pool:复用执行工作线程或进程。
  • Timeout:限制单个任务的执行时间。

例如,设置最大并发数为 5,即使系统收到 100 个任务,也只允许其中 5 个同时执行,其余任务进入等待队列。

六、Agent 编排中的状态管理

多 Agent 系统往往需要执行多个步骤,甚至持续运行数分钟或数小时。只依靠内存中的变量保存状态,难以支持故障恢复和长期任务管理。

1. 任务状态设计

可以为任务定义以下状态:

状态 含义
PENDING 等待执行
READY 满足执行条件
RUNNING 正在执行
WAITING 等待其他任务或外部事件
SUCCEEDED 执行成功
FAILED 执行失败
RETRYING 正在重试
CANCELLED 已取消
SKIPPED 已跳过

任务状态转换: