目录
摘要
随着 AI 应用场景的日益复杂化，单一代理已难以满足企业级业务需求。多代理协作编排成为解决复杂任务的关键技术路径。OpenClaw 作为新一代 AI Agent 框架，创新性地提出了多代理协作编排架构，通过任务分解策略、代理间通信机制、结果聚合与整合、工作流编排、状态管理等核心技术，实现了多个 AI 代理的高效协同工作。本文将深入剖析 OpenClaw 多代理协作的设计哲学、技术实现与最佳实践，帮助开发者构建企业级智能协作网络。读者将掌握多代理协作模式、任务分解策略、代理通信协议、工作流编排引擎等核心技能，为复杂业务场景的 AI 落地提供技术支撑。
1. 引言：多代理协作的时代命题
1.1 单代理的局限性
在 AI Agent 发展的早期阶段，单一代理架构占据主导地位。一个 AI 代理负责处理所有用户请求，从理解意图到执行任务再到生成回复，全部由一个模型完成。这种架构简单直观，但随着应用场景的复杂化，其局限性日益凸显：
能力瓶颈：单一代理难以同时精通多个领域。一个代理可能擅长代码生成，但在数据分析方面表现平平；或者擅长自然语言处理，但在图像理解方面力不从心。用户期望的"全能助手"在技术上难以实现。
上下文过载：复杂任务需要大量上下文信息，单一代理的上下文窗口有限，难以同时处理多个子任务的状态和中间结果。当任务链过长时，早期信息容易被遗忘或稀释。
可靠性问题：单一代理是系统的单点故障。一旦代理出现问题（模型超时、API 限流、逻辑错误），整个任务链就会中断。缺乏冗余和容错机制。
效率瓶颈：串行处理模式导致任务执行效率低下。一个复杂任务可能包含多个可并行的子任务，但单一代理只能逐个处理，无法充分利用并行计算能力。
1.2 多代理协作的价值
多代理协作架构通过"分而治之"的策略，有效解决了单一代理的局限性：
专业化分工：每个代理专注于特定领域，成为该领域的专家。代码代理专注于编程任务，数据代理专注于分析任务，文档代理专注于写作任务。专业化的代理在各自领域表现更出色。
并行处理：多个代理可以同时处理不同的子任务，大幅提升任务执行效率。一个复杂的数据分析任务可以分解为数据获取、数据清洗、数据分析、报告生成四个并行子任务。
容错机制：多代理系统天然具备容错能力。某个代理失败时，可以由其他代理接管或重试，不会导致整个系统瘫痪。主备代理机制确保高可用性。
可扩展性：新增能力只需添加新的代理，无需修改现有系统。业务扩展时，可以快速集成新的专业化代理，实现系统的弹性扩展。
1.3 OpenClaw 的解决方案
OpenClaw 从架构层面原生支持多代理协作，而非事后补丁式的功能叠加。其设计理念是"编排即代码"，通过声明式配置定义代理协作流程，让开发者专注于业务逻辑而非底层通信细节。
2. 多代理协作模式详解
2.1 协作模式分类
OpenClaw 支持多种多代理协作模式，每种模式适用于不同的业务场景：
| 协作模式 | 描述 | 适用场景 | 复杂度 |
|---|---|---|---|
| 主从模式 | 主代理协调多个从代理执行任务 | 结构化任务、明确分工 | ⭐⭐ |
| 对等模式 | 代理之间平等协作，无主从关系 | 创意协作、头脑风暴 | ⭐⭐⭐ |
| 流水线模式 | 任务按顺序在代理间流转 | 数据处理、内容生产 | ⭐⭐ |
| 层级模式 | 多级代理树状结构 | 大型企业、复杂组织 | ⭐⭐⭐⭐ |
| 混合模式 | 多种模式组合使用 | 复杂业务场景 | ⭐⭐⭐⭐⭐ |
2.2 主从协作模式
主从模式是最常见的多代理协作模式。主代理（Coordinator）负责任务分解、代理调度、结果整合，从代理（Worker）负责执行具体的子任务。
主从模式的核心优势在于清晰的职责划分和可控的执行流程。主代理作为"大脑"，统筹全局；从代理作为"手脚"，各司其职。这种模式特别适合结构化任务，如数据分析、报告生成、代码审查等。
主代理职责：
- 接收用户请求，理解任务意图
- 将复杂任务分解为子任务
- 选择合适的从代理执行子任务
- 监控子任务执行状态
- 整合子任务结果，生成最终输出
从代理职责：
- 接收主代理分配的子任务
- 执行专业化任务处理
- 返回子任务执行结果
- 报告执行状态和异常
2.3 对等协作模式
对等模式中，所有代理地位平等，通过协商和投票机制达成共识。这种模式适合需要多角度思考的创意任务，如产品设计、方案评审、创意写作等。
对等模式的关键挑战在于如何高效达成共识。OpenClaw 提供了多种共识机制：
投票机制：每个代理提出方案，通过多数投票决定最终结果。适用于有明确评判标准的场景。
加权共识：根据代理的专业领域和置信度，给予不同的投票权重。技术问题由技术代理权重更高，商业问题由商业代理权重更高。
迭代协商：代理之间多轮讨论，逐步收敛到共识方案。适用于复杂决策场景。
2.4 流水线协作模式
流水线模式将任务分解为一系列有序的处理阶段，每个阶段由专门的代理负责。数据在各阶段间流转，最终产出完整结果。
流水线模式的核心优势在于高效的数据流转和清晰的阶段划分。每个代理只需关注自己的处理逻辑，无需了解上下游细节。这种模式特别适合数据处理管道、内容生产流水线等场景。
流水线设计要点：
- 阶段划分：合理划分处理阶段，确保每个阶段职责单一
- 数据格式：定义阶段间的数据交换格式，确保兼容性
- 错误处理：设计错误传播和恢复机制，避免流水线中断
- 性能优化：识别瓶颈阶段，进行针对性优化
2.5 层级协作模式
层级模式适用于大型企业或复杂组织结构。代理按照组织架构形成树状结构，上级代理管理下级代理，实现分层治理。
层级模式的关键设计考量：
权限控制：上级代理可以委派任务给下级代理，但下级代理不能越级上报。确保组织架构的规范性。
信息聚合：下级代理的结果需要逐级汇总，上级代理看到的是聚合后的信息，而非原始数据。
异常上报：下级代理遇到无法处理的问题时，向上级代理上报，由上级代理决策处理方案。
3. 任务分解策略
3.1 任务分解原则
任务分解是多代理协作的核心环节。好的任务分解能够最大化并行度、最小化依赖关系、优化资源利用。OpenClaw 遵循以下任务分解原则：
独立性原则：分解后的子任务应尽量独立，减少子任务之间的依赖关系。独立的子任务可以并行执行，提升整体效率。
原子性原则：每个子任务应该是不可再分的原子任务，具有明确的输入输出和完成标准。避免模糊不清的任务边界。
均衡性原则：子任务的工作量应尽量均衡，避免某些代理过载而其他代理空闲。负载均衡是提升系统吞吐量的关键。
层次性原则：复杂任务可以分层分解，先分解为一级子任务，再分解为二级子任务，直到达到可执行的粒度。
3.2 任务分解方法
OpenClaw 提供了多种任务分解方法，根据任务特性自动选择最优策略：
功能分解法：按功能模块分解任务。例如，“开发一个用户管理系统"可以分解为"用户注册模块”、“用户登录模块”、"用户权限模块"等。
数据分解法：按数据维度分解任务。例如，“分析全国销售数据"可以分解为"分析华东区数据”、“分析华南区数据”、"分析华北区数据"等。
流程分解法：按处理流程分解任务。例如，“生成月度报告"可以分解为"数据采集”、“数据清洗”、“数据分析”、"报告撰写"等阶段。
时间分解法：按时间维度分解任务。例如，“年度总结"可以分解为"Q1总结”、“Q2总结”、“Q3总结”、“Q4总结”。
3.3 任务分解器实现
以下是 OpenClaw 任务分解器的核心实现：
from dataclasses import dataclass
from typing import List, Optional, Dict, Any
from enum import Enum
import asyncio
class TaskType(Enum):
"""任务类型枚举"""
ANALYSIS = "analysis" # 分析类任务
CODING = "coding" # 编码类任务
WRITING = "writing" # 写作类任务
SEARCH = "search" # 搜索类任务
COMPUTATION = "computation" # 计算类任务
INTEGRATION = "integration" # 整合类任务
@dataclass
class SubTask:
"""子任务定义"""
task_id: str
task_type: TaskType
description: str
input_data: Dict[str, Any]
output_schema: Dict[str, Any]
dependencies: List[str] # 依赖的子任务ID列表
assigned_agent: Optional[str] = None
status: str = "pending"
result: Optional[Dict[str, Any]] = None
class TaskDecomposer:
"""任务分解器：将复杂任务分解为可执行的子任务"""
def __init__(self, llm_client, agent_registry):
self.llm = llm_client
self.agents = agent_registry
self.decomposition_strategies = {
"functional": self._functional_decompose,
"data": self._data_decompose,
"process": self._process_decompose,
"time": self._time_decompose,
}
async def decompose(self, task_description: str,
context: Dict[str, Any] = None) -> List[SubTask]:
"""
主分解方法：根据任务描述生成子任务列表
Args:
task_description: 任务描述文本
context: 任务上下文信息
Returns:
子任务列表，包含依赖关系和分配建议
"""
# 第一步：分析任务特性，选择分解策略
task_analysis = await self._analyze_task(task_description)
# 第二步：根据任务特性选择最优分解策略
strategy = self._select_strategy(task_analysis)
# 第三步：执行分解
subtasks = await self.decomposition_strategies[strategy](
task_description, task_analysis, context
)
# 第四步：优化子任务分配
subtasks = await self._optimize_allocation(subtasks)
return subtasks
async def _analyze_task(self, description: str) -> Dict[str, Any]:
"""使用 LLM 分析任务特性"""
prompt = f"""
分析以下任务，识别其关键特性：
任务描述：{description}
请返回 JSON 格式的分析结果，包含：
- task_type: 任务类型（analysis/coding/writing/search/computation/integration）
- complexity: 复杂度（1-10）
- parallelizable: 是否可并行（true/false）
- domains: 涉及的领域列表
- estimated_steps: 预估步骤数
"""
response = await self.llm.generate(prompt)
return self._parse_analysis(response)
def _select_strategy(self, analysis: Dict) -> str:
"""根据任务分析结果选择分解策略"""
if analysis.get("parallelizable", False):
if len(analysis.get("domains", [])) > 2:
return "functional"
return "data"
else:
return "process"
async def _functional_decompose(self, description: str,
analysis: Dict,
context: Dict) -> List[SubTask]:
"""功能分解：按功能模块拆分任务"""
prompt = f"""
将以下任务按功能模块分解为独立的子任务：
任务：{description}
涉及领域：{analysis.get('domains', [])}
返回 JSON 数组，每个子任务包含：
- task_id: 唯一标识
- task_type: 任务类型
- description: 子任务描述
- dependencies: 依赖的子任务ID列表
"""
response = await self.llm.generate(prompt)
return self._parse_subtasks(response)
async def _optimize_allocation(self, subtasks: List[SubTask]) -> List[SubTask]:
"""优化子任务到代理的分配"""
available_agents = await self.agents.get_available()
for subtask in subtasks:
# 根据任务类型匹配最合适的代理
best_agent = self._match_agent(subtask, available_agents)
subtask.assigned_agent = best_agent
return subtasks
def _match_agent(self, subtask: SubTask, agents: List) -> str:
"""根据子任务特性匹配最佳代理"""
agent_scores = {}
for agent in agents:
score = self._calculate_match_score(subtask, agent)
agent_scores[agent.id] = score
return max(agent_scores, key=agent_scores.get)
def _calculate_match_score(self, subtask: SubTask, agent) -> float:
"""计算任务与代理的匹配分数"""
score = 0.0
# 任务类型匹配
if subtask.task_type.value in agent.capabilities:
score += 0.4
# 负载均衡
score += 0.3 * (1 - agent.current_load)
# 历史成功率
score += 0.3 * agent.success_rate
return score
上述代码展示了 OpenClaw 任务分解器的核心实现。TaskDecomposer 类负责将复杂任务分解为可执行的子任务列表。首先通过 _analyze_task 方法使用 LLM 分析任务特性，包括任务类型、复杂度、是否可并行等；然后根据分析结果选择最优的分解策略（功能分解、数据分解、流程分解或时间分解）；最后通过 _optimize_allocation 方法将子任务分配给最合适的代理，考虑因素包括任务类型匹配度、代理当前负载、历史成功率等。这种设计确保了任务分解的智能性和分配的合理性。
3.4 任务依赖图
任务分解后，需要构建任务依赖图来管理执行顺序：
任务依赖图清晰地展示了子任务之间的依赖关系。T1 和 T2 可以并行执行，T3 依赖 T1，T4 依赖 T2，以此类推。OpenClaw 的调度引擎会根据依赖图自动识别可并行执行的任务，最大化执行效率。
4. 代理间通信机制
4.1 通信协议设计
代理间通信是多代理协作的基础设施。OpenClaw 设计了一套统一的代理通信协议（Agent Communication Protocol，ACP），确保不同代理之间能够高效、可靠地交换信息。
协议设计原则：
标准化：所有代理遵循统一的通信协议，无论代理内部实现如何，对外接口保持一致。
异步优先：默认采用异步通信模式，避免阻塞等待，提升系统吞吐量。
可追溯：每条消息都有唯一标识和时间戳，支持消息追踪和审计。
安全可控：支持消息加密和权限验证，确保通信安全。
4.2 消息类型定义
OpenClaw 定义了丰富的消息类型，覆盖代理协作的各种场景：
| 消息类型 | 方向 | 用途 | 示例 |
|---|---|---|---|
| TASK_ASSIGN | 主→从 | 任务分配 | “请分析这份销售数据” |
| TASK_ACCEPT | 从→主 | 接受任务 | “任务已接受，预计5分钟完成” |
| TASK_REJECT | 从→主 | 拒绝任务 | “任务超出能力范围” |
| PROGRESS_UPDATE | 从→主 | 进度更新 | “已完成30%” |
| RESULT_SUBMIT | 从→主 | 结果提交 | “分析结果已生成” |
| HELP_REQUEST | 从→其他 | 请求协助 | “需要数据代理协助” |
| HELP_RESPONSE | 其他→从 | 协助响应 | “已发送所需数据” |
| ERROR_REPORT | 从→主 | 错误报告 | “数据格式错误” |
| HEARTBEAT | 双向 | 心跳检测 | “代理存活” |
4.3 通信中间件实现
以下是 OpenClaw 代理通信中间件的核心实现：
import asyncio
from dataclasses import dataclass, field
from typing import Dict, Any, Optional, Callable, Set
from datetime import datetime
import json
import uuid
from enum import Enum
class MessageType(Enum):
"""消息类型枚举"""
TASK_ASSIGN = "task_assign"
TASK_ACCEPT = "task_accept"
TASK_REJECT = "task_reject"
PROGRESS_UPDATE = "progress_update"
RESULT_SUBMIT = "result_submit"
HELP_REQUEST = "help_request"
HELP_RESPONSE = "help_response"
ERROR_REPORT = "error_report"
HEARTBEAT = "heartbeat"
@dataclass
class AgentMessage:
"""代理消息结构"""
message_id: str = field(default_factory=lambda: str(uuid.uuid4()))
message_type: MessageType = MessageType.HEARTBEAT
sender_id: str = ""
receiver_id: str = "" # 空表示广播
task_id: Optional[str] = None
payload: Dict[str, Any] = field(default_factory=dict)
timestamp: datetime = field(default_factory=datetime.now)
correlation_id: Optional[str] = None # 关联消息ID，用于请求-响应模式
def to_json(self) -> str:
"""序列化为 JSON"""
return json.dumps({
"message_id": self.message_id,
"message_type": self.message_type.value,
"sender_id": self.sender_id,
"receiver_id": self.receiver_id,
"task_id": self.task_id,
"payload": self.payload,
"timestamp": self.timestamp.isoformat(),
"correlation_id": self.correlation_id
})
@classmethod
def from_json(cls, json_str: str) -> 'AgentMessage':
"""从 JSON 反序列化"""
data = json.loads(json_str)
return cls(
message_id=data["message_id"],
message_type=MessageType(data["message_type"]),
sender_id=data["sender_id"],
receiver_id=data["receiver_id"],
task_id=data.get("task_id"),
payload=data["payload"],
timestamp=datetime.fromisoformat(data["timestamp"]),
correlation_id=data.get("correlation_id")
)
class MessageBroker:
"""消息代理：负责代理间的消息路由和投递"""
def __init__(self):
self._subscribers: Dict[str, Set[Callable]] = {}
self._message_queue: asyncio.Queue = asyncio.Queue()
self._agent_status: Dict[str, datetime] = {}
self._running = False
async def start(self):
"""启动消息代理"""
self._running = True
asyncio.create_task(self._process_messages())
async def stop(self):
"""停止消息代理"""
self._running = False
def subscribe(self, agent_id: str, callback: Callable[[AgentMessage], None]):
"""代理订阅消息"""
if agent_id not in self._subscribers:
self._subscribers[agent_id] = set()
self._subscribers[agent_id].add(callback)
def unsubscribe(self, agent_id: str, callback: Callable):
"""代理取消订阅"""
if agent_id in self._subscribers:
self._subscribers[agent_id].discard(callback)
async def publish(self, message: AgentMessage):
"""发布消息到队列"""
await self._message_queue.put(message)
async def send_direct(self, message: AgentMessage) -> bool:
"""直接发送消息给指定代理"""
if message.receiver_id not in self._subscribers:
return False
for callback in self._subscribers[message.receiver_id]:
try:
if asyncio.iscoroutinefunction(callback):
await callback(message)
else:
callback(message)
except Exception as e:
print(f"消息投递失败: {e}")
return True
async def broadcast(self, message: AgentMessage):
"""广播消息给所有代理"""
for agent_id, callbacks in self._subscribers.items():
if agent_id != message.sender_id: # 不发给自己
for callback in callbacks:
try:
if asyncio.iscoroutinefunction(callback):
await callback(message)
else:
callback(message)
except Exception as e:
print(f"广播消息失败: {e}")
async def _process_messages(self):
"""消息处理循环"""
while self._running:
try:
message = await asyncio.wait_for(
self._message_queue.get(),
timeout=1.0
)
# 更新发送者状态
self._agent_status[message.sender_id] = datetime.now()
# 路由消息
if message.receiver_id:
# 点对点消息
await self.send_direct(message)
else:
# 广播消息
await self.broadcast(message)
except asyncio.TimeoutError:
continue
except Exception as e:
print(f"消息处理错误: {e}")
def get_agent_status(self, agent_id: str) -> Optional[datetime]:
"""获取代理最后活跃时间"""
return self._agent_status.get(agent_id)
class CommunicationMiddleware:
"""通信中间件：提供高级通信能力"""
def __init__(self, broker: MessageBroker, agent_id: str):
self.broker = broker
self.agent_id = agent_id
self._pending_responses: Dict[str, asyncio.Future] = {}
async def send_task(self, receiver_id: str, task_id: str,
task_description: str) -> str:
"""发送任务给其他代理"""
message = AgentMessage(
message_type=MessageType.TASK_ASSIGN,
sender_id=self.agent_id,
receiver_id=receiver_id,
task_id=task_id,
payload={"description": task_description}
)
await self.broker.publish(message)
return message.message_id
async def request_help(self, helper_agent: str,
help_description: str,
timeout: float = 30.0) -> Dict[str, Any]:
"""请求其他代理协助（同步等待响应）"""
correlation_id = str(uuid.uuid4())
future = asyncio.Future()
self._pending_responses[correlation_id] = future
message = AgentMessage(
message_type=MessageType.HELP_REQUEST,
sender_id=self.agent_id,
receiver_id=helper_agent,
payload={"description": help_description},
correlation_id=correlation_id
)
await self.broker.publish(message)
try:
return await asyncio.wait_for(future, timeout=timeout)
except asyncio.TimeoutError:
return {"error": "请求超时"}
finally:
self._pending_responses.pop(correlation_id, None)
async def respond_help(self, original_message: AgentMessage,
response_data: Dict[str, Any]):
"""响应协助请求"""
message = AgentMessage(
message_type=MessageType.HELP_RESPONSE,
sender_id=self.agent_id,
receiver_id=original_message.sender_id,
task_id=original_message.task_id,
payload=response_data,
correlation_id=original_message.correlation_id
)
await self.broker.publish(message)
def handle_response(self, message: AgentMessage):
"""处理响应消息"""
if message.correlation_id in self._pending_responses:
future = self._pending_responses[message.correlation_id]
if not future.done():
future.set_result(message.payload)
上述代码实现了 OpenClaw 代理通信的核心组件。AgentMessage 定义了统一的消息结构，包含消息 ID、类型、发送者、接收者、任务 ID、负载等字段，支持 JSON 序列化和反序列化。MessageBroker 是消息代理的核心实现，负责消息的路由和投递，支持点对点发送和广播两种模式，内部使用异步队列实现消息缓冲。CommunicationMiddleware 提供了高级通信能力，如任务发送、协助请求等，其中 request_help 方法实现了同步等待响应的模式，通过 asyncio.Future 机制等待对方代理的响应。这种设计确保了代理间通信的可靠性和灵活性。
4.4 通信拓扑结构
OpenClaw 支持多种通信拓扑结构，适应不同的协作场景：
星型拓扑：所有代理通过中心节点（主代理）通信，适合主从协作模式。
网状拓扑：所有代理之间可以直接通信，适合对等协作模式。
树型拓扑：代理按层级组织，适合层级协作模式。
混合拓扑：多种拓扑组合，适合复杂场景。
5. 结果聚合与整合
5.1 聚合策略设计
当多个代理完成各自的子任务后，需要将结果聚合整合为最终输出。OpenClaw 提供了多种聚合策略：
| 聚合策略 | 描述 | 适用场景 |
|---|---|---|
| 顺序合并 | 按子任务顺序拼接结果 | 流水线模式 |
| 投票选择 | 多代理投票选择最佳结果 | 对等模式 |
| 加权融合 | 根据置信度加权融合结果 | 不确定场景 |
| 层级汇总 | 逐级汇总下层结果 | 层级模式 |
| 智能整合 | 使用 LLM 整合结果 | 复杂场景 |
5.2 结果聚合器实现
以下是 OpenClaw 结果聚合器的核心实现：
from dataclasses import dataclass
from typing import List, Dict, Any, Optional
from enum import Enum
import asyncio
class AggregationStrategy(Enum):
"""聚合策略枚举"""
SEQUENTIAL = "sequential" # 顺序合并
VOTING = "voting" # 投票选择
WEIGHTED = "weighted" # 加权融合
HIERARCHICAL = "hierarchical" # 层级汇总
INTELLIGENT = "intelligent" # 智能整合
@dataclass
class SubTaskResult:
"""子任务结果"""
task_id: str
agent_id: str
result_data: Dict[str, Any]
confidence: float = 1.0
metadata: Dict[str, Any] = None
status: str = "success"
class ResultAggregator:
"""结果聚合器：整合多个子任务的结果"""
def __init__(self, llm_client=None):
self.llm = llm_client
self.aggregation_handlers = {
AggregationStrategy.SEQUENTIAL: self._sequential_aggregate,
AggregationStrategy.VOTING: self._voting_aggregate,
AggregationStrategy.WEIGHTED: self._weighted_aggregate,
AggregationStrategy.HIERARCHICAL: self._hierarchical_aggregate,
AggregationStrategy.INTELLIGENT: self._intelligent_aggregate,
}
async def aggregate(self, results: List[SubTaskResult],
strategy: AggregationStrategy,
context: Dict[str, Any] = None) -> Dict[str, Any]:
"""
聚合子任务结果
Args:
results: 子任务结果列表
strategy: 聚合策略
context: 聚合上下文
Returns:
聚合后的最终结果
"""
if not results:
return {"error": "无结果可聚合"}
# 过滤失败的结果
successful_results = [r for r in results if r.status == "success"]
if not successful_results:
return {"error": "所有子任务均失败"}
# 执行聚合
handler = self.aggregation_handlers[strategy]
return await handler(successful_results, context or {})
async def _sequential_aggregate(self, results: List[SubTaskResult],
context: Dict) -> Dict[str, Any]:
"""顺序合并：按任务顺序拼接结果"""
# 按任务ID排序
sorted_results = sorted(results, key=lambda r: r.task_id)
aggregated = {
"type": "sequential",
"sections": [],
"total_confidence": 0.0
}
for result in sorted_results:
aggregated["sections"].append({
"task_id": result.task_id,
"agent_id": result.agent_id,
"content": result.result_data
})
aggregated["total_confidence"] += result.confidence
# 平均置信度
aggregated["total_confidence"] /= len(sorted_results)
return aggregated
async def _voting_aggregate(self, results: List[SubTaskResult],
context: Dict) -> Dict[str, Any]:
"""投票选择：多代理投票选择最佳结果"""
# 统计每个结果的得票
votes: Dict[str, List[str]] = {}
for result in results:
# 每个代理对其他结果投票
for other in results:
if other.task_id not in votes:
votes[other.task_id] = []
# 简单投票逻辑：置信度高的得票
if other.confidence >= 0.8:
votes[other.task_id].append(result.agent_id)
# 找出得票最多的结果
winner_task_id = max(votes, key=lambda k: len(votes[k]))
winner_result = next(r for r in results if r.task_id == winner_task_id)
return {
"type": "voting",
"winner": winner_result.result_data,
"votes": {k: len(v) for k, v in votes.items()},
"confidence": winner_result.confidence
}
async def _weighted_aggregate(self, results: List[SubTaskResult],
context: Dict) -> Dict[str, Any]:
"""加权融合：根据置信度加权融合结果"""
total_weight = sum(r.confidence for r in results)
if total_weight == 0:
return {"error": "所有结果置信度为零"}
# 数值型字段的加权平均
aggregated = {"type": "weighted", "components": []}
for result in results:
weight = result.confidence / total_weight
aggregated["components"].append({
"task_id": result.task_id,
"weight": weight,
"content": result.result_data
})
return aggregated
async def _hierarchical_aggregate(self, results: List[SubTaskResult],
context: Dict) -> Dict[str, Any]:
"""层级汇总：按代理层级逐级汇总"""
# 获取代理层级关系
hierarchy = context.get("hierarchy", {})
# 按层级分组结果
level_results: Dict[int, List[SubTaskResult]] = {}
for result in results:
level = hierarchy.get(result.agent_id, 0)
if level not in level_results:
level_results[level] = []
level_results[level].append(result)
# 从底层向上汇总
current_level_results = results
for level in sorted(level_results.keys(), reverse=True):
if level == 0:
continue # 顶层不再汇总
# 汇总当前层级
level_aggregated = await self._sequential_aggregate(
level_results[level], context
)
# 将汇总结果添加到上一层
# ... 层级汇总逻辑
return {
"type": "hierarchical",
"levels": len(level_results),
"aggregated": current_level_results
}
async def _intelligent_aggregate(self, results: List[SubTaskResult],
context: Dict) -> Dict[str, Any]:
"""智能整合：使用 LLM 整合多个结果"""
if not self.llm:
# 降级为顺序合并
return await self._sequential_aggregate(results, context)
# 构建整合提示
prompt = self._build_aggregation_prompt(results, context)
# 调用 LLM 整合
integrated = await self.llm.generate(prompt)
return {
"type": "intelligent",
"integrated_content": integrated,
"source_count": len(results),
"avg_confidence": sum(r.confidence for r in results) / len(results)
}
def _build_aggregation_prompt(self, results: List[SubTaskResult],
context: Dict) -> str:
"""构建整合提示"""
task_description = context.get("task_description", "未知任务")
prompt = f"""
请整合以下子任务结果，生成连贯的最终输出：
原始任务：{task_description}
子任务结果：
"""
for i, result in enumerate(results, 1):
prompt += f"""
--- 结果 {i} (来源: {result.agent_id}, 置信度: {result.confidence:.2f}) ---
{result.result_data}
"""
prompt += """
请生成整合后的结果，要求：
1. 保持逻辑连贯性
2. 消除重复内容
3. 突出关键信息
4. 标注信息来源
"""
return prompt
上述代码展示了 OpenClaw 结果聚合器的完整实现。ResultAggregator 类支持五种聚合策略：顺序合并按任务顺序拼接结果，适用于流水线模式；投票选择让多个代理投票选出最佳结果，适用于对等协作；加权融合根据置信度加权平均，适用于数值型结果；层级汇总按代理层级逐级汇总，适用于层级模式；智能整合使用 LLM 整合多个结果，适用于复杂场景。聚合器会自动过滤失败的子任务，确保最终结果的可靠性。_intelligent_aggregate 方法展示了如何使用 LLM 进行智能整合，通过构建包含所有子任务结果的提示，让 LLM 生成连贯的最终输出。
6. 工作流编排引擎
6.1 工作流定义
工作流是多代理协作的执行蓝图，定义了任务分解、代理分配、执行顺序、结果聚合等完整流程。OpenClaw 采用声明式工作流定义，让开发者专注于"做什么"而非"怎么做"。
# 工作流定义示例：技术报告生成
workflow:
name: "技术报告生成流水线"
version: "1.0"
# 触发条件
triggers:
- type: "user_request"
pattern: "生成.*报告"
- type: "schedule"
cron: "0 9 * * 1" # 每周一早9点
# 代理池定义
agents:
- id: "coordinator"
type: "main"
model: "claude-opus-4"
- id: "data_collector"
type: "worker"
capabilities: ["web_search", "file_read", "api_call"]
- id: "analyst"
type: "worker"
capabilities: ["data_analysis", "visualization"]
- id: "writer"
type: "worker"
capabilities: ["writing", "formatting"]
- id: "reviewer"
type: "worker"
capabilities: ["review", "quality_check"]
# 任务流程定义
tasks:
- id: "collect_data"
agent: "data_collector"
description: "收集相关数据"
timeout: 300
retry: 3
- id: "analyze_data"
agent: "analyst"
description: "分析数据并生成图表"
depends_on: ["collect_data"]
timeout: 600
- id: "write_report"
agent: "writer"
description: "撰写报告内容"
depends_on: ["analyze_data"]
timeout: 900
- id: "review_report"
agent: "reviewer"
description: "审核报告质量"
depends_on: ["write_report"]
timeout: 300
# 聚合配置
aggregation:
strategy: "sequential"
final_agent: "coordinator"
# 异常处理
error_handling:
on_failure: "notify_admin"
retry_policy:
max_retries: 3
backoff: "exponential"
6.2 编排引擎架构
OpenClaw 的编排引擎采用事件驱动架构，支持动态任务调度和实时状态监控：
6.3 状态机管理
工作流执行过程中的状态管理至关重要。OpenClaw 使用有限状态机（FSM）管理工作流状态：
状态转换规则：
- Created → Scheduled：工作流定义验证通过，进入调度队列
- Scheduled → Running：调度器分配资源，开始执行
- Running → Paused：用户暂停或系统触发暂停条件
- Running → Completed：所有任务成功完成
- Running → PartialSuccess：部分任务失败但核心任务完成
- Running → Failed：关键任务失败，工作流终止
7. 状态管理机制
7.1 状态存储设计
多代理协作涉及大量的状态数据，包括工作流状态、任务状态、代理状态、会话状态等。OpenClaw 采用分层状态存储架构：
| 状态类型 | 存储介质 | 生命周期 | 访问频率 |
|---|---|---|---|
| 会话状态 | 内存 + Redis | 会话期间 | 极高 |
| 任务状态 | Redis + 数据库 | 任务执行期间 | 高 |
| 工作流状态 | 数据库 | 永久 | 中 |
| 代理状态 | 内存 | 代理在线期间 | 高 |
| 历史记录 | 数据库 + 对象存储 | 永久 | 低 |
7.2 状态同步机制
在分布式环境下，状态同步是多代理协作的关键挑战。OpenClaw 采用以下机制确保状态一致性：
乐观锁机制：使用版本号实现乐观锁，避免并发更新冲突。每次更新状态时检查版本号，版本不匹配则重试。
事件溯源：所有状态变更记录为事件日志，支持状态回放和审计追溯。即使系统崩溃，也可以通过事件日志恢复状态。
最终一致性：对于非关键状态，采用最终一致性模型，允许短暂的不一致状态，通过后台同步任务最终达成一致。
7.3 状态管理器实现
以下是 OpenClaw 状态管理器的核心实现：
from dataclasses import dataclass, field
from typing import Dict, Any, Optional, List
from datetime import datetime
import json
import redis
import asyncio
from enum import Enum
class StateType(Enum):
"""状态类型枚举"""
WORKFLOW = "workflow"
TASK = "task"
AGENT = "agent"
SESSION = "session"
@dataclass
class StateSnapshot:
"""状态快照"""
state_id: str
state_type: StateType
data: Dict[str, Any]
version: int = 1
created_at: datetime = field(default_factory=datetime.now)
updated_at: datetime = field(default_factory=datetime.now)
def to_dict(self) -> Dict[str, Any]:
return {
"state_id": self.state_id,
"state_type": self.state_type.value,
"data": self.data,
"version": self.version,
"created_at": self.created_at.isoformat(),
"updated_at": self.updated_at.isoformat()
}
class StateManager:
"""状态管理器：统一管理多代理协作的状态"""
def __init__(self, redis_client: redis.Redis, db_client):
self.redis = redis_client
self.db = db_client
self._local_cache: Dict[str, StateSnapshot] = {}
self._lock = asyncio.Lock()
async def get_state(self, state_id: str,
state_type: StateType) -> Optional[StateSnapshot]:
"""
获取状态
优先级：本地缓存 > Redis > 数据库
"""
# 检查本地缓存
if state_id in self._local_cache:
return self._local_cache[state_id]
# 检查 Redis
redis_key = self._get_redis_key(state_id, state_type)
redis_data = self.redis.get(redis_key)
if redis_data:
snapshot = self._deserialize_snapshot(redis_data)
self._local_cache[state_id] = snapshot
return snapshot
# 检查数据库
db_data = await self._get_from_db(state_id, state_type)
if db_data:
snapshot = StateSnapshot(**db_data)
# 回填 Redis 和本地缓存
self.redis.set(redis_key, self._serialize_snapshot(snapshot))
self._local_cache[state_id] = snapshot
return snapshot
return None
async def update_state(self, state_id: str, state_type: StateType,
updates: Dict[str, Any]) -> bool:
"""
更新状态（使用乐观锁）
"""
async with self._lock:
# 获取当前状态
current = await self.get_state(state_id, state_type)
if not current:
# 创建新状态
new_snapshot = StateSnapshot(
state_id=state_id,
state_type=state_type,
data=updates,
version=1
)
else:
# 检查版本（乐观锁）
redis_key = self._get_redis_key(state_id, state_type)
current_version = self.redis.get(f"{redis_key}:version")
if current_version and int(current_version) != current.version:
# 版本冲突，需要重试
return False
# 更新状态
new_data = {**current.data, **updates}
new_snapshot = StateSnapshot(
state_id=state_id,
state_type=state_type,
data=new_data,
version=current.version + 1,
created_at=current.created_at
)
# 持久化到 Redis
redis_key = self._get_redis_key(state_id, state_type)
self.redis.set(redis_key, self._serialize_snapshot(new_snapshot))
self.redis.set(f"{redis_key}:version", new_snapshot.version)
# 异步持久化到数据库
asyncio.create_task(
self._persist_to_db(new_snapshot)
)
# 更新本地缓存
self._local_cache[state_id] = new_snapshot
return True
async def watch_state(self, state_id: str,
callback: callable,
poll_interval: float = 1.0):
"""
监听状态变化
"""
last_version = None
while True:
snapshot = await self.get_state(state_id, StateType.WORKFLOW)
if snapshot and snapshot.version != last_version:
await callback(snapshot)
last_version = snapshot.version
await asyncio.sleep(poll_interval)
async def get_workflow_status(self, workflow_id: str) -> Dict[str, Any]:
"""获取工作流完整状态"""
workflow_state = await self.get_state(workflow_id, StateType.WORKFLOW)
if not workflow_state:
return {"error": "工作流不存在"}
# 获取所有任务状态
task_ids = workflow_state.data.get("task_ids", [])
task_states = []
for task_id in task_ids:
task_state = await self.get_state(task_id, StateType.TASK)
if task_state:
task_states.append(task_state.to_dict())
return {
"workflow": workflow_state.to_dict(),
"tasks": task_states,
"summary": self._generate_summary(workflow_state, task_states)
}
def _generate_summary(self, workflow_state: StateSnapshot,
task_states: List[Dict]) -> Dict[str, Any]:
"""生成工作流摘要"""
total_tasks = len(task_states)
completed_tasks = sum(1 for t in task_states if t["data"].get("status") == "completed")
failed_tasks = sum(1 for t in task_states if t["data"].get("status") == "failed")
return {
"total_tasks": total_tasks,
"completed": completed_tasks,
"failed": failed_tasks,
"progress": completed_tasks / total_tasks if total_tasks > 0 else 0,
"status": workflow_state.data.get("status")
}
def _get_redis_key(self, state_id: str, state_type: StateType) -> str:
return f"openclaw:state:{state_type.value}:{state_id}"
def _serialize_snapshot(self, snapshot: StateSnapshot) -> str:
return json.dumps(snapshot.to_dict())
def _deserialize_snapshot(self, data: bytes) -> StateSnapshot:
parsed = json.loads(data)
return StateSnapshot(
state_id=parsed["state_id"],
state_type=StateType(parsed["state_type"]),
data=parsed["data"],
version=parsed["version"],
created_at=datetime.fromisoformat(parsed["created_at"]),
updated_at=datetime.fromisoformat(parsed["updated_at"])
)
async def _get_from_db(self, state_id: str,
state_type: StateType) -> Optional[Dict]:
"""从数据库获取状态"""
# 实现数据库查询逻辑
pass
async def _persist_to_db(self, snapshot: StateSnapshot):
"""持久化状态到数据库"""
# 实现数据库持久化逻辑
pass
上述代码展示了 OpenClaw 状态管理器的核心实现。StateManager 类采用三级缓存架构：本地内存缓存提供最快的访问速度，Redis 作为分布式缓存支持跨进程共享，数据库作为持久化存储确保数据安全。update_state 方法使用乐观锁机制，通过版本号检测并发冲突，避免数据覆盖问题。watch_state 方法实现了状态监听功能，支持客户端实时感知状态变化。get_workflow_status 方法聚合工作流及其所有任务的状态，生成完整的执行摘要。这种分层存储和乐观锁的设计，既保证了状态访问的高效性，又确保了分布式环境下的一致性。
8. 实战案例：复杂任务处理
8.1 场景描述
让我们通过一个实际案例来演示 OpenClaw 多代理协作的完整流程。假设用户提出以下请求：
“帮我分析公司上季度的销售数据，生成一份包含数据洞察、可视化图表和行动建议的技术报告，并发送给相关团队成员。”
这是一个典型的复杂任务，涉及数据获取、数据分析、可视化、报告撰写、消息发送等多个环节，非常适合使用多代理协作来处理。
8.2 任务分解
主代理首先分析任务，将其分解为以下子任务：
8.3 代理分配
根据子任务的特性，主代理将任务分配给合适的专业代理：
| 子任务 | 分配代理 | 代理能力 | 预估时间 |
|---|---|---|---|
| 数据获取 | 数据代理 | 数据库查询、API调用 | 2分钟 |
| 数据清洗 | 数据代理 | 数据处理、格式转换 | 3分钟 |
| 数据分析 | 分析代理 | 统计分析、机器学习 | 5分钟 |
| 可视化生成 | 分析代理 | 图表生成、可视化 | 3分钟 |
| 洞察提取 | 分析代理 | 趋势识别、异常检测 | 2分钟 |
| 报告撰写 | 写作代理 | 文档生成、格式化 | 5分钟 |
| 质量审核 | 审核代理 | 内容检查、质量评估 | 2分钟 |
| 消息发送 | 通信代理 | 飞书/邮件发送 | 1分钟 |
8.4 执行流程
以下是完整的执行流程时序图：
8.5 实际代码示例
以下是使用 OpenClaw 实现上述场景的完整代码：
import asyncio
from openclaw import Workflow, Agent, Task, Orchestrator
from openclaw.agents import DataAgent, AnalystAgent, WriterAgent
from openclaw.channels import FeishuChannel
# 定义代理池
agents = {
"main": Agent(
id="coordinator",
type="main",
model="claude-opus-4",
capabilities=["coordination", "task_decomposition"]
),
"data": DataAgent(
id="data_agent",
capabilities=["database_query", "api_call", "data_cleaning"]
),
"analyst": AnalystAgent(
id="analyst_agent",
capabilities=["statistical_analysis", "visualization", "insight_extraction"]
),
"writer": WriterAgent(
id="writer_agent",
capabilities=["report_writing", "formatting", "document_generation"]
),
"reviewer": Agent(
id="reviewer_agent",
capabilities=["quality_check", "content_review"]
),
"communicator": Agent(
id="comm_agent",
capabilities=["message_sending", "notification"]
)
}
# 定义工作流
sales_report_workflow = Workflow(
name="销售数据分析报告",
agents=agents,
tasks=[
Task(
id="fetch_sales_data",
agent="data",
description="从数据库获取上季度销售数据",
inputs={
"query": "SELECT * FROM sales WHERE quarter = 'Q4' AND year = 2025",
"database": "sales_db"
},
outputs=["raw_data"]
),
Task(
id="fetch_team_info",
agent="data",
description="获取相关团队成员信息",
inputs={
"query": "SELECT * FROM team_members WHERE department = 'sales'",
"database": "hr_db"
},
outputs=["team_members"]
),
Task(
id="clean_data",
agent="data",
description="清洗和预处理销售数据",
depends_on=["fetch_sales_data"],
inputs={
"raw_data": "${fetch_sales_data.raw_data}"
},
outputs=["cleaned_data"]
),
Task(
id="analyze_data",
agent="analyst",
description="执行销售数据分析",
depends_on=["clean_data"],
inputs={
"data": "${clean_data.cleaned_data}"
},
outputs=["analysis_results"]
),
Task(
id="generate_visualizations",
agent="analyst",
description="生成数据可视化图表",
depends_on=["analyze_data"],
inputs={
"analysis": "${analyze_data.analysis_results}"
},
outputs=["charts"]
),
Task(
id="extract_insights",
agent="analyst",
description="提取关键数据洞察",
depends_on=["analyze_data"],
inputs={
"analysis": "${analyze_data.analysis_results}"
},
outputs=["insights"]
),
Task(
id="write_report",
agent="writer",
description="撰写完整分析报告",
depends_on=["generate_visualizations", "extract_insights"],
inputs={
"charts": "${generate_visualizations.charts}",
"insights": "${extract_insights.insights}",
"template": "sales_report_template.md"
},
outputs=["report_document"]
),
Task(
id="review_report",
agent="reviewer",
description="审核报告质量",
depends_on=["write_report"],
inputs={
"report": "${write_report.report_document}"
},
outputs=["review_result"]
),
Task(
id="send_report",
agent="communicator",
description="发送报告给团队成员",
depends_on=["review_report", "fetch_team_info"],
inputs={
"report": "${write_report.report_document}",
"recipients": "${fetch_team_info.team_members}",
"channel": "feishu"
},
outputs=["send_result"]
)
],
aggregation={
"strategy": "sequential",
"final_output": "${send_report.send_result}"
}
)
# 执行工作流
async def main():
# 初始化编排器
orchestrator = Orchestrator(
workflow=sales_report_workflow,
channels={"feishu": FeishuChannel()}
)
# 执行工作流
result = await orchestrator.execute(
trigger="user_request",
user_input="分析公司上季度的销售数据，生成报告并发送给团队"
)
print(f"工作流执行完成: {result.status}")
print(f"报告已发送给 {result.output['recipients_count']} 位团队成员")
if __name__ == "__main__":
asyncio.run(main())
上述代码展示了使用 OpenClaw 实现复杂多代理协作任务的完整流程。首先定义了六个专业化代理，每个代理具有特定的能力集。然后通过 Workflow 类定义工作流，包含九个有序任务，任务之间通过 depends_on 字段建立依赖关系，通过 ${task_id.output} 语法引用上游任务的输出。Orchestrator 编排器负责执行工作流，自动处理任务调度、状态管理、结果聚合等复杂逻辑。这种声明式的工作流定义方式，让开发者可以清晰地描述业务流程，而无需关心底层执行细节。
9. 最佳实践与注意事项
9.1 设计原则
在设计和实现多代理协作系统时，应遵循以下原则：
单一职责原则：每个代理应该专注于一个明确的职责领域。避免创建"全能代理"，这会导致代理边界模糊、难以维护。
最小依赖原则：子任务之间的依赖关系应尽量减少。高内聚、低耦合的任务设计可以最大化并行度，提升执行效率。
幂等性原则：任务执行应该是幂等的，即多次执行同一任务产生相同的结果。这对于失败重试和状态恢复至关重要。
可观测性原则：每个代理的执行过程应该是可观测的，包括输入输出、执行时间、资源消耗等。这有助于问题排查和性能优化。
9.2 性能优化
多代理协作系统的性能优化应关注以下几个方面：
| 优化维度 | 优化策略 | 预期收益 |
|---|---|---|
| 并行度 | 识别无依赖任务，并行执行 | 执行时间降低 30-50% |
| 缓存 | 缓存中间结果，避免重复计算 | 计算资源节省 20-40% |
| 批处理 | 合并相似任务，批量处理 | API 调用减少 50-70% |
| 预加载 | 预加载常用数据和模型 | 响应延迟降低 40-60% |
| 资源池 | 代理连接池、数据库连接池 | 资源利用率提升 20-30% |
9.3 错误处理
多代理协作系统需要健壮的错误处理机制：
重试机制：对于可恢复的错误（网络超时、临时不可用），自动重试。采用指数退避策略，避免雪崩效应。
降级策略：当某个代理不可用时，降级到备用代理或简化处理流程。确保系统在部分故障时仍能提供服务。
超时控制：为每个任务设置合理的超时时间，避免某个任务阻塞整个工作流。超时后自动取消并触发重试或降级。
死信队列：对于多次重试仍失败的任务，放入死信队列，由人工介入处理。避免失败任务无限重试消耗资源。
9.4 安全考量
多代理协作涉及敏感数据和关键操作，需要严格的安全控制：
权限隔离：不同代理具有不同的权限级别。数据代理可以访问数据库，但不能发送外部消息；通信代理可以发送消息，但不能访问敏感数据。
数据脱敏：在代理间传递敏感数据时，进行脱敏处理。日志中不记录敏感信息。
审计追踪：所有代理操作记录审计日志，支持事后追溯。包括操作时间、操作者、操作内容、操作结果。
加密传输：代理间通信使用加密通道，防止数据泄露。
10. 总结
本文深入探讨了 OpenClaw 多代理协作编排的设计理念、技术实现与最佳实践。从单代理的局限性出发，我们分析了多代理协作的核心价值，并详细介绍了 OpenClaw 的解决方案。
核心要点回顾：
多代理协作模式：OpenClaw 支持主从模式、对等模式、流水线模式、层级模式和混合模式五种协作模式，每种模式适用于不同的业务场景。主从模式适合结构化任务，对等模式适合创意协作，流水线模式适合数据处理，层级模式适合大型组织。
任务分解策略：好的任务分解是高效协作的基础。OpenClaw 遵循独立性、原子性、均衡性、层次性四大原则，提供功能分解、数据分解、流程分解、时间分解四种方法，并使用任务依赖图管理执行顺序。
代理间通信机制：统一的通信协议（ACP）确保不同代理之间能够高效、可靠地交换信息。消息代理支持点对点发送和广播两种模式，通信中间件提供任务发送、协助请求等高级能力。
结果聚合与整合：五种聚合策略（顺序合并、投票选择、加权融合、层级汇总、智能整合）满足不同场景的结果整合需求。智能整合使用 LLM 将多个子任务结果整合为连贯的最终输出。
工作流编排引擎：声明式工作流定义让开发者专注于业务逻辑，事件驱动架构支持动态任务调度和实时状态监控，有限状态机确保工作流状态的正确转换。
状态管理机制：三级缓存架构（本地内存、Redis、数据库）平衡了访问速度和数据安全，乐观锁机制确保分布式环境下的一致性，事件溯源支持状态回放和审计追溯。
实战案例：通过销售数据分析报告的完整案例，演示了从任务分解、代理分配、执行流程到结果输出的全过程，展示了 OpenClaw 多代理协作的实际应用价值。
思考题：
- 在你的业务场景中，哪些任务适合使用多代理协作？如何划分代理职责边界？
- 如何平衡多代理协作带来的灵活性与系统复杂度？什么情况下应该选择单代理方案？
- 如果要为 OpenClaw 开发一个新的协作模式，你会选择什么模式？解决什么问题？
OpenClaw 多代理协作编排为企业级 AI 应用提供了强大的技术支撑。通过合理的架构设计和最佳实践，开发者可以构建出高效、可靠、可扩展的智能协作网络，让 AI 真正成为企业的生产力倍增器。
参考资料
转载自CSDN-专业IT技术社区
原文链接：https://blog.csdn.net/sinat_41617212/article/details/160085545
