多 Agent 架构设计模式对比分析
-关于作者:Aipollo
**深耕领域：**大语言AI应用 开发 / RAG 知识库 / AI Agent 落地 / 空间数据治理
**技术栈：**Python | RAG (LangChain / Dify + Milvus+mem0) | FastAPI + Docker
****工程能力：****专注数字空间智能化、大模型部署、知识库构建与优化，智能体工程化能力
多 Agent 通信模式总览
在多 Agent 系统中，通信模式决定了 Agent 之间如何交换信息、协调任务。主要有以下几种通信模式：
0.1 通信模式分类
| 通信模式 | 描述 | 适用场景 | 代表框架 |
|---|---|---|---|
| 直接调用 | Agent A 直接调用 Agent B 的接口 | 同步任务、简单委托 | LangGraph |
| 消息传递 | 通过消息队列/总线异步通信 | 解耦、异步处理 | AutoGen |
| 共享状态 | 多个 Agent 读写共享状态空间 | 协作编辑、状态同步 | LangGraph |
| 事件驱动 | 通过发布/订阅机制通信 | 松耦合、可扩展 | AutoGen 0.4+ |
| 黑板模式 | 共享知识库，Agent 自主读写 | 知识密集型任务 | CAMEL |
| 请求-响应 | 同步请求等待响应 | RPC 风格调用 | OpenClaw |
0.2 通信架构图
┌─────────────────────────────────────────────────────────────────────────────┐
│ 多 Agent 通信模式架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 1. 直接调用 (Direct Call) │
│ │
│ Agent A ────────────────────────────────────────► Agent B │
│ 同步调用 │
│ • 函数调用 │
│ • RPC │
│ • HTTP 请求 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 2. 消息传递 (Message Passing) │
│ │
│ Agent A ────────► [消息队列] ────────► Agent B │
│ 异步 │
│ • 消息队列 (RabbitMQ, Kafka) │
│ • 内存队列 │
│ • 通道消息 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 3. 共享状态 (Shared State) │
│ │
│ Agent A ────────► [共享状态空间] ◀─────── Agent B │
│ 读写 │
│ • 全局变量 │
│ • 状态数据库 │
│ • 图状态 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 4. 事件驱动 (Event-Driven) │
│ │
│ Agent A ────────► [事件总线] ────────► Agent B │
│ 发布 │
│ Agent C ────────► [事件总线] ────────► Agent D │
│ • 发布/订阅 │
│ • 事件广播 │
│ • 观察者模式 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 5. 黑板模式 (Blackboard) │
│ │
│ Agent A ────────► [黑板/知识库] ◀─────── Agent B │
│ 写入 读取 │
│ Agent C ────────► [黑板/知识库] ◀─────── Agent D │
│ • 共享知识库 │
│ • 自主读写 │
│ • 知识融合 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 6. 请求-响应 (Request-Response) │
│ │
│ Agent A ────────► Agent B │
│ 请求 │
│ Agent A ◀─────── Agent B │
│ 响应 │
│ • 同步调用 │
│ • 超时控制 │
│ • 重试机制 │
└─────────────────────────────────────────────────────────────────────────┘0.3 通信模式时序图
直接调用模式：
Agent A Agent B
│ │
│ 1. 调用请求 │
│───────────────────►│
│ │
│ │ 2. 处理请求
│ │──────────┐
│ │ │
│ │◄─────────┘
│ │
│ 3. 返回结果 │
│◄───────────────────│
│ │消息传递模式：
Agent A 消息队列 Agent B
│ │ │
│ 1. 发送消息 │ │
│────────────────►│ │
│ │ │
│ 2. 返回确认 │ │
│◄────────────────│ │
│ │ │
│ │ 3. 投递消息 │
│ │─────────────────►│
│ │ │
│ │ │ 4. 处理消息
│ │ │──────────┐
│ │ │ │
│ │ │◄─────────┘
│ │ │
│ │ 5. 处理完成 │
│ │◄─────────────────│
│ │ │共享状态模式：
Agent A 共享状态 Agent B
│ │ │
│ 1. 读取状态 │ │
│────────────────►│ │
│ │ │
│ 2. 返回状态 │ │
│◄────────────────│ │
│ │ │
│ 3. 修改状态 │ │
│────────────────►│ │
│ │ │
│ │ 4. 状态变更通知 │
│ │─────────────────►│
│ │ │
│ │ │ 5. 读取新状态
│ │◄─────────────────│
│ │ │
│ │ 6. 返回新状态 │
│ │─────────────────►│
│ │ │事件驱动模式：
Agent A 事件总线 Agent B Agent C
│ │ │ │
│ 1. 发布事件 │ │ │
│────────────────►│ │ │
│ │ │ │
│ │ 2. 事件通知 │ │
│ │─────────────────►│ │
│ │ │ │
│ │ 3. 事件通知 │ │
│ │─────────────────────────────────────►│
│ │ │ │
│ │ │ 4. 处理事件 │
│ │ │──────────┐ │
│ │ │ │ │
│ │ │◄─────────┘ │
│ │ │ │
│ │ │ │ 5. 处理事件
│ │ │ │──────────┐
│ │ │ │ │
│ │ │ │◄─────────┘
│ │ │ │0.4 各框架通信模式对比
| 框架 | 主要通信模式 | 辅助通信模式 | 通信特点 |
|---|---|---|---|
| OpenClaw | 请求-响应 | 消息传递、共享状态 | Gateway 中央路由 + A2A 工具 |
| LangGraph | 共享状态 | 直接调用 | 图状态传递 + 边条件 |
| AutoGen | 消息传递 | 事件驱动 | 对话消息 + 嵌套会话 |
| CrewAI | 直接调用 | 消息传递 | 任务委派 + 结果返回 |
MCP 与 A2A 协议详解
0.5.1 MCP (Model Context Protocol) 模型上下文协议
MCP 是什么：Anthropic 提出的开放协议，用于标准化 AI 模型与外部工具/数据源的交互。
核心架构：
┌─────────────────────────────────────────────────────────────────────────────┐
│ MCP 协议架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────┐
│ MCP Host │
│ (AI 应用) │
│ • Claude Code │
│ • OpenClaw │
│ • Cursor │
└────────┬────────┘
│
▼
┌─────────────────┐
│ MCP Client │
│ (协议客户端) │
└────────┬────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ MCP Server A │ │ MCP Server B │ │ MCP Server C │
│ (文件系统) │ │ (数据库) │ │ (API 服务) │
│ │ │ │ │ │
│ • read_file │ │ • query_db │ │ • call_api │
│ • write_file │ │ • insert_row │ │ • get_data │
│ • list_dir │ │ • update_row │ │ • post_data │
└──────────────┘ └──────────────┘ └──────────────┘MCP 三种传输方式：
┌─────────────────────────────────────────────────────────────────────────────┐
│ MCP 传输协议对比 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 1. Stdio (标准输入输出) │
│ ┌─────────┐ stdin/stdout ┌─────────┐ │
│ │ MCP │◄──────────────────────►│ MCP │ │
│ │ Client │ │ Server │ │
│ └─────────┘ └─────────┘ │
│ • 本地子进程通信 │
│ • 低延迟、高性能 │
│ • 适合本地工具 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 2. SSE (Server-Sent Events) │
│ ┌─────────┐ HTTP SSE ┌─────────┐ │
│ │ MCP │◄──────────────────────►│ MCP │ │
│ │ Client │ (单向流) │ Server │ │
│ └─────────┘ └─────────┘ │
│ • HTTP 长连接 │
│ • 服务器推送 │
│ • 适合远程服务 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 3. Streamable HTTP (流式 HTTP) │
│ ┌─────────┐ HTTP 流 ┌─────────┐ │
│ │ MCP │◄──────────────────────►│ MCP │ │
│ │ Client │ (双向流) │ Server │ │
│ └─────────┘ └─────────┘ │
│ • 双向流式通信 │
• 支持认证 (OAuth) │
• 适合生产环境 │
└─────────────────────────────────────────────────────────────────────────┘MCP 工具调用时序图：
用户 AI Agent MCP Client MCP Server 外部工具
│ │ │ │ │
│ 1. 发送请求 │ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 2. 解析意图 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ │ 3. 调用工具 │ │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 4. 转发请求 │ │
│ │ │──────────────►│ │
│ │ │ │ │
│ │ │ │ 5. 执行工具 │
│ │ │ │──────────────►│
│ │ │ │ │
│ │ │ │ 6. 返回结果 │
│ │ │ │◄──────────────│
│ │ │ │ │
│ │ │ 7. 返回结果 │ │
│ │ │◄──────────────│ │
│ │ │ │ │
│ │ 8. 返回结果 │ │ │
│ │◄──────────────│ │ │
│ │ │ │ │
│ 9. 生成回复 │ │ │ │
│◄──────────────│ │ │ │
│ │ │ │ │OpenClaw 中的 MCP 配置：
json5
{
"mcp": {
"servers": {
// 本地 Stdio 服务器
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
},
// 远程 SSE 服务器
"github": {
"url": "https://mcp.github.com/sse",
"transport": "sse",
"auth": "oauth"
},
// 带工具过滤的服务器
"database": {
"command": "uvx",
"args": ["mcp-server-postgres"],
"toolFilter": {
"include": ["query_*", "list_*"],
"exclude": ["delete_*", "drop_*"]
}
}
}
}
}0.5.2 A2A (Agent-to-Agent) 协议
A2A 是什么：Google 提出的开放协议，用于标准化 Agent 之间的通信和协作。
核心架构：
┌─────────────────────────────────────────────────────────────────────────────┐
│ A2A 协议架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────┐
│ A2A Client │
│ (请求 Agent) │
└────────┬────────┘
│
│ A2A Protocol
│ (HTTP + JSON-RPC)
▼
┌─────────────────┐
│ A2A Server │
│ (服务 Agent) │
│ │
│ • Agent Card │
│ • Task API │
│ • Message API │
└────────┬────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ 能力 A │ │ 能力 B │ │ 能力 C │
│ • 代码生成 │ │ • 数据分析 │ │ • 内容创作 │
│ • 代码审查 │ │ • 报告生成 │ │ • 翻译润色 │
└──────────────┘ └──────────────┘ └──────────────┘A2A 核心概念：
┌─────────────────────────────────────────────────────────────────────────────┐
│ A2A 核心概念 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 1. Agent Card (Agent 名片) │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ { │ │
│ │ "name": "Code Review Agent", │ │
│ │ "description": "专业代码审查 Agent", │ │
│ │ "url": "https://agent.example.com/a2a", │ │
│ │ "capabilities": { │ │
│ │ "streaming": true, │ │
│ │ "pushNotifications": true │ │
│ │ }, │ │
│ │ "skills": [ │ │
│ │ { "name": "code_review", "description": "代码审查" }, │ │
│ │ { "name": "security_scan", "description": "安全扫描" } │ │
│ │ ] │ │
│ │ } │ │
│ └─────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 2. Task (任务) │
│ • 有明确的生命周期 (submitted → working → completed/failed) │
│ • 支持长时间运行 │
│ • 支持进度更新 │
│ • 支持取消 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ 3. Message (消息) │
│ • 支持多种内容类型 (text, file, data, form) │
│ • 支持流式传输 │
│ • 支持推送通知 │
└─────────────────────────────────────────────────────────────────────────┘A2A 通信时序图：
Client Agent A2A Server Server Agent
│ │ │
│ 1. 发现 Agent │ │
│───────────────►│ │
│ │ │
│ 2. Agent Card │ │
│◄───────────────│ │
│ │ │
│ 3. 创建任务 │ │
│───────────────►│ │
│ │ │
│ 4. Task ID │ │
│◄───────────────│ │
│ │ │
│ │ 5. 分发任务 │
│ │───────────────►│
│ │ │
│ │ │ 6. 处理任务
│ │ │──────────┐
│ │ │ │
│ │ │◄─────────┘
│ │ │
│ │ 7. 进度更新 │
│ │◄───────────────│
│ │ │
│ 8. 进度通知 │ │
│◄───────────────│ │
│ │ │
│ │ 9. 任务完成 │
│ │◄───────────────│
│ │ │
│ 10. 结果返回 │ │
│◄───────────────│ │
│ │ │0.5.3 MCP vs A2A 对比
| 维度 | MCP | A2A |
|---|---|---|
| 提出者 | Anthropic | |
| 定位 | AI 与工具/数据源交互 | Agent 之间协作 |
| 通信方式 | 请求-响应 | 任务驱动 |
| 状态管理 | 无状态 | 有状态 (Task 生命周期) |
| 传输协议 | Stdio/SSE/HTTP | HTTP + JSON-RPC |
| 核心概念 | Tool, Resource, Prompt | Agent Card, Task, Message |
| 适用场景 | 工具调用、数据访问 | 复杂任务委托、多 Agent 协作 |
架构对比图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ MCP vs A2A 架构对比 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ MCP: AI ↔ 工具/数据 │
│ │
│ AI Agent ◄──────► MCP Server ◄──────► 工具/数据 │
│ (请求-响应) │
│ • 同步调用 │
│ • 无状态 │
│ • 工具发现 │
└─────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ A2A: Agent ↔ Agent │
│ │
│ Agent A ◄──────► A2A Protocol ◄──────► Agent B │
│ (任务驱动) │
│ • 异步任务 │
│ • 有状态 │
│ • 能力发现 │
└─────────────────────────────────────────────────────────────────────────┘0.5.4 OpenClaw 中的 MCP + A2A 实现
OpenClaw 同时支持 MCP 和 A2A：
┌─────────────────────────────────────────────────────────────────────────────┐
│ OpenClaw 中的 MCP + A2A 架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────┐
│ OpenClaw │
│ Gateway │
└────────┬────────┘
│
┌────────────────────────┼────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ MCP 角色 │ │ A2A 角色 │ │ Sub-agent │
│ │ │ │ │ │
│ ┌─────────────┐ │ │ ┌─────────────┐ │ │ ┌─────────────┐ │
│ │ MCP Server │ │ │ │ A2A Client │ │ │ │ 内部子代理 │ │
│ │ (暴露功能) │ │ │ │ (调用外部) │ │ │ │ (层次委托) │ │
│ └─────────────┘ │ │ └─────────────┘ │ │ └─────────────┘ │
│ │ │ │ │ │
│ ┌─────────────┐ │ │ ┌─────────────┐ │ │ ┌─────────────┐ │
│ │ MCP Client │ │ │ │ A2A Server │ │ │ │ ACP 运行时 │ │
│ │ (消费工具) │ │ │ │ (提供服务) │ │ │ │ (外部集成) │ │
│ └─────────────┘ │ │ └─────────────┘ │ │ └─────────────┘ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ 外部 MCP 服务器 │ │ 外部 A2A Agent │ │ Claude/Codex │
│ • 文件系统 │ │ • 代码审查 │ │ • 代码生成 │
│ • 数据库 │ │ • 数据分析 │ │ • 代码审查 │
│ • API 服务 │ │ • 内容创作 │ │ • 重构优化 │
└─────────────────┘ └─────────────────┘ └─────────────────┘MCP 配置示例：
json5
// ~/.openclaw/openclaw.json
{
"mcp": {
"servers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "~/.openclaw/workspace"]
},
"github": {
"url": "https://api.github.com/mcp",
"transport": "streamable-http",
"auth": "oauth"
}
}
}
}A2A/Sub-agent 配置示例：
json5
// ~/.openclaw/openclaw.json
{
"agents": {
"defaults": {
"subagents": {
"maxSpawnDepth": 2,
"maxChildrenPerAgent": 5,
"maxConcurrent": 8,
"runTimeoutSeconds": 900
}
}
},
"tools": {
"agentToAgent": {
"enabled": true,
"allow": ["coding", "research"]
}
}
}Sub-agent 调用时序图：
用户 主 Agent 子 Agent A 子 Agent B MCP Server
│ │ │ │ │
│ 1. 发送请求 │ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 2. 分析任务 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ │ 3. spawn 子 Agent A │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 4. 需要工具 │ │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ │ │ │ 5. 执行工具
│ │ │ │ │──────────┐
│ │ │ │ │ │
│ │ │ │ │◄─────────┘
│ │ │ │ │
│ │ │ 6. 工具结果 │ │
│ │ │◄──────────────────────────────│
│ │ │ │ │
│ │ │ 7. 继续处理 │ │
│ │ │──────────┐ │ │
│ │ │ │ │ │
│ │ │◄─────────┘ │ │
│ │ │ │ │
│ │ │ 8. 需要子 Agent B │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ │ │ 9. 执行任务 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ 10. 收到结果 │ │
│ │ │◄──────────────────────────────│
│ │ │ │ │
│ │ 11. 完成 │ │ │
│ │◄──────────────│ │ │
│ │ │ │ │
│ 12. 返回结果 │ │ │ │
│◄──────────────│ │ │ │
│ │ │ │ │一、行业主流多 Agent 设计模式
1. Supervisor（主管模式）
核心思想：一个中央 Agent 负责任务分配和协调，其他 Agent 执行具体任务。
架构图：
┌─────────────────────────────────┐
│ User Request │
└───────────────┬─────────────────┘
│
▼
┌─────────────────────────────────┐
│ Supervisor │
│ ┌───────────────────────────┐ │
│ │ • 解析用户意图 │ │
│ │ • 选择合适的 Agent │ │
│ │ • 分配任务 │ │
│ │ • 汇总结果 │ │
│ └───────────────────────────┘ │
└───────────────┬─────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Agent A │ │ Agent B │ │ Agent C │
│ ┌────────────┐ │ │ ┌────────────┐ │ │ ┌────────────┐ │
│ │ 研究能力 │ │ │ │ 编码能力 │ │ │ │ 测试能力 │ │
│ │ • 搜索 │ │ │ │ • 代码生成 │ │ │ │ • 单元测试 │ │
│ │ • 分析 │ │ │ │ • 重构 │ │ │ │ • 集成测试 │ │
│ │ • 总结 │ │ │ │ • 调试 │ │ │ │ • 报告 │ │
│ └────────────┘ │ │ └────────────┘ │ │ └────────────┘ │
└──────────────────┘ └──────────────────┘ └──────────────────┘时序图：
User Supervisor Agent A Agent B Agent C
│ │ │ │ │
│ 1.发送请求 │ │ │ │
│───────────────►│ │ │ │
│ │ │ │ │
│ │ 2.解析意图 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ │ 3.分配任务给Agent A │ │
│ │───────────────►│ │ │
│ │ │ │ │
│ │ │ 4.执行研究 │ │
│ │ │──────────┐ │ │
│ │ │ │ │ │
│ │ │◄─────────┘ │ │
│ │ │ │ │
│ │ 5.返回研究结果 │ │ │
│ │◄───────────────│ │ │
│ │ │ │ │
│ │ 6.分配任务给Agent B │ │
│ │──────────────────────────────►│ │
│ │ │ │ │
│ │ │ │ 7.执行编码 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ 8.返回编码结果 │ │ │
│ │◄──────────────────────────────│ │
│ │ │ │ │
│ │ 9.汇总结果 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ 10.返回最终结果│ │ │ │
│◄───────────────│ │ │ │
│ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 请求-响应 | Supervisor 同步调用 Worker Agent |
| 消息传递 | 异步任务分发（可选） |
通信流程：
Supervisor Worker A Worker B
│ │ │
│ 1. 分配任务 │ │
│─────────────────►│ │
│ │ │
│ 2. 返回结果 │ │
│◄─────────────────│ │
│ │ │
│ 3. 分配任务 │ │
│──────────────────────────────────►│
│ │ │
│ 4. 返回结果 │ │
│◄──────────────────────────────────│
│ │ │代表框架 ：LangGraph、AutoGen
优点 ：逻辑清晰、易于调试、任务路由明确
缺点：Supervisor 成为瓶颈、单点故障
2. Hierarchical（层级模式）
核心思想：多级管理层，支持递归委托。
架构图：
┌─────────────────┐
│ CEO/顶层 │
│ (战略决策) │
└────────┬────────┘
│
┌───────────────────────────┼───────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Manager A │ │ Manager B │ │ Manager C │
│ (技术部门) │ │ (产品部门) │ │ (运营部门) │
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Worker │ │ Worker │ │ Worker │ │ Worker │ │ Worker │ │ Worker │
│ (前端) │ │ (后端) │ │ (设计) │ │ (需求) │ │ (市场) │ │ (数据) │
└─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘时序图：
User CEO Manager A Worker(前端) Worker(后端)
│ │ │ │ │
│ 1.提出需求 │ │ │ │
│───────────►│ │ │ │
│ │ │ │ │
│ │ 2.分解任务 │ │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 3.分配前端任务 │ │
│ │ │───────────────►│ │
│ │ │ │ │
│ │ │ 4.分配后端任务 │ │
│ │ │───────────────────────────────►│
│ │ │ │ │
│ │ │ │ 5.开发前端 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ │ │ 6.开发后端
│ │ │ │ │──────────┐
│ │ │ │ │ │
│ │ │ │ │◄─────────┘
│ │ │ │ │
│ │ │ 7.前端完成 │ │
│ │ │◄───────────────│ │
│ │ │ │ │
│ │ │ 8.后端完成 │ │
│ │ │◄───────────────────────────────│
│ │ │ │ │
│ │ 9.汇总报告 │ │ │
│ │◄──────────────│ │ │
│ │ │ │ │
│ 10.最终结果│ │ │ │
│◄───────────│ │ │ │
│ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 逐级请求-响应 | 上级向下级分配任务，下级向上级汇报 |
| 消息传递 | 跨层级通信通过消息队列 |
通信流程：
CEO Manager Worker
│ │ │
│ 1. 分配任务 │ │
│──────────────►│ │
│ │ │
│ │ 2. 分解任务 │
│ │──────────────►│
│ │ │
│ │ 3. 返回结果 │
│ │◄──────────────│
│ │ │
│ 4. 汇总报告 │ │
│◄──────────────│ │
│ │ │代表框架 ：CrewAI、Microsoft AutoGen
优点 ：适合大型复杂任务、职责清晰
缺点：层级深时延迟增加、协调成本高
3. Swarm/Decentralized（去中心化/蜂群模式）
核心思想：Agent 之间直接通信和交接，无中央控制。
架构图：
┌─────────────────────────────────────┐
│ 共享状态空间 │
│ (黑板/消息总线/共享内存) │
└─────────────────────────────────────┘
│
┌────────────────────────────┼────────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Agent A │◄──────────►│ Agent B │◄──────────►│ Agent C │
│ │ │ │ │ │
│ • 自主决策 │ │ • 自主决策 │ │ • 自主决策 │
│ • 直接通信 │ │ • 直接通信 │ │ • 直接通信 │
│ • 任务交接 │ │ • 任务交接 │ │ • 任务交接 │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
│ ┌─────────────┐ │ │
└─────►│ Agent D │◄────┘ │
│ │◄───────────────────────────────┘
│ • 自主决策 │
│ • 直接通信 │
│ • 任务交接 │
└─────────────┘时序图：
Agent A Agent B Agent C Agent D
│ │ │ │
│ 1.发现任务 │ │ │
│──────────┐ │ │ │
│ │ │ │ │
│◄─────────┘ │ │ │
│ │ │ │
│ 2.评估能力 │ │ │
│──────────┐ │ │ │
│ │ │ │ │
│◄─────────┘ │ │ │
│ │ │ │
│ 3.能力不足，交接给B │ │
│──────────────►│ │ │
│ │ │ │
│ │ 4.接收任务 │ │
│ │──────────┐ │ │
│ │ │ │ │
│ │◄─────────┘ │ │
│ │ │ │
│ │ 5.部分完成，需要C协助 │
│ │──────────────────────────────►│
│ │ │ │
│ │ │ 6.接收子任务 │
│ │ │──────────┐ │
│ │ │ │ │
│ │ │◄─────────┘ │
│ │ │ │
│ │ │ 7.完成，返回结果
│ │ │◄──────────────│
│ │ │ │
│ │ 8.收到C结果 │ │
│ │◄──────────────────────────────│
│ │ │ │
│ │ 9.继续处理 │ │
│ │──────────┐ │ │
│ │ │ │ │
│ │◄─────────┘ │ │
│ │ │ │
│ │ 10.需要D的输入│ │
│ │───────────────────────────────►
│ │ │ │
│ │ │ │ 11.提供输入
│ │ │ │◄──────────────
│ │ │ │
│ │ 12.收到D输入 │ │
│ │◄──────────────────────────────│
│ │ │ │
│ │ 13.任务完成 │ │
│ │──────────┐ │ │
│ │ │ │ │
│ │◄─────────┘ │ │
│ │ │ │
│ 14.收到结果 │ │ │
│◄──────────────│ │ │
│ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 事件驱动 | Agent 自主发布/订阅事件 |
| 共享状态 | 通过黑板/共享空间交换信息 |
| 直接调用 | Agent 之间直接通信 |
通信流程：
Agent A 共享空间 Agent B
│ │ │
│ 1. 写入数据 │ │
│──────────────►│ │
│ │ │
│ │ 2. 读取数据 │
│ │◄──────────────│
│ │ │
│ │ 3. 写入结果 │
│ │◄──────────────│
│ │ │
│ 4. 读取结果 │ │
│──────────────►│ │
│ │ │代表框架 ：OpenAI Swarm（实验性）
优点 ：灵活、无单点故障、可扩展
缺点：难以调试、状态一致性挑战
4. Pipeline/Sequential（流水线模式）
核心思想：任务按顺序流经多个 Agent，每个 Agent 处理特定阶段。
架构图：
┌─────────────────────────────────────────────────────────────────────┐
│ Pipeline 处理流程 │
└─────────────────────────────────────────────────────────────────────┘
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ │ │ │ │ │ │ │
│ Agent A │─────►│ Agent B │─────►│ Agent C │─────►│ Agent D │─────► 输出
│ (数据 │ │ (数据 │ │ (数据 │ │ (结果 │
│ 收集) │ │ 清洗) │ │ 分析) │ │ 生成) │
│ │ │ │ │ │ │ │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
│ │ │ │
▼ ▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ 输入格式 │ │ 清洗规则 │ │ 分析模型 │ │ 输出模板 │
│ 配置 │ │ 配置 │ │ 配置 │ │ 配置 │
└──────────┘ └──────────┘ └──────────┘ └──────────┘时序图：
用户 Agent A Agent B Agent C Agent D
│ │ │ │ │
│ 1.提交原始数据│ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 2.收集数据 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ │ 3.传递原始数据│ │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 4.清洗数据 │ │
│ │ │──────────┐ │ │
│ │ │ │ │ │
│ │ │◄─────────┘ │ │
│ │ │ │ │
│ │ │ 5.传递清洗后数据 │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ │ │ 6.分析数据 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ │ 7.传递分析结果│
│ │ │ │──────────────►│
│ │ │ │ │
│ │ │ │ │ 8.生成报告
│ │ │ │ │──────────┐
│ │ │ │ │ │
│ │ │ │ │◄─────────┘
│ │ │ │ │
│ │ │ │ │ 9.返回最终结果
│ │ │ │ │◄──────────────
│ │ │ │ │
│ 10.返回结果 │ │ │ │
│◄──────────────────────────────────────────────────────────────│
│ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 消息传递 | 数据沿流水线顺序传递 |
| 直接调用 | 上游 Agent 调用下游 Agent |
通信流程：
Agent A Agent B Agent C Agent D
│ │ │ │
│ 1. 传递数据 │ │ │
│──────────────►│ │ │
│ │ │ │
│ │ 2. 传递数据 │ │
│ │──────────────►│ │
│ │ │ │
│ │ │ 3. 传递数据 │
│ │ │──────────────►│
│ │ │ │
│ │ │ │ 4. 返回结果
│ │ │ │◄──────────────
│ │ │ │代表框架 ：LangChain LCEL、Haystack
优点 ：简单直观、易于理解和实现
缺点：不支持并行、灵活性低
5. Parallel/Fan-Out（并行扇出模式）
核心思想：多个 Agent 并行处理同一任务的不同方面，然后汇总结果。
架构图：
┌─────────────────┐
│ 输入分发器 │
│ (Fan-Out) │
└────────┬────────┘
│
┌────────────────────────┼────────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────────┐ ┌───────────────────┐ ┌───────────────────┐
│ Agent A │ │ Agent B │ │ Agent C │
│ ┌───────────┐ │ │ ┌───────────┐ │ │ ┌───────────┐ │
│ │ 视角 1 │ │ │ │ 视角 2 │ │ │ │ 视角 3 │ │
│ │ • 数据分析 │ │ │ │ • 用户研究 │ │ │ │ • 技术评估 │ │
│ │ • 趋势预测 │ │ │ │ • 行为分析 │ │ │ │ • 可行性 │ │
│ └───────────┘ │ │ └───────────┘ │ │ └───────────┘ │
└───────────────────┘ └───────────────────┘ └───────────────────┘
│ │ │
└────────────────────────┼────────────────────────┘
│
▼
┌─────────────────┐
│ 结果汇总器 │
│ (Aggregator) │
│ • 合并结果 │
│ • 去重去噪 │
│ • 生成报告 │
└─────────────────┘时序图：
用户 分发器 Agent A Agent B Agent C 汇总器
│ │ │ │ │ │
│ 1.提交任务 │ │ │ │ │
│──────────────►│ │ │ │ │
│ │ │ │ │ │
│ │ 2.并行分发 │ │ │ │
│ │──────────────►│ │ │ │
│ │ │ │ │ │
│ │ 3.并行分发 │ │ │ │
│ │──────────────────────────────►│ │ │
│ │ │ │ │ │
│ │ 4.并行分发 │ │ │ │
│ │──────────────────────────────────────────────►│ │
│ │ │ │ │ │
│ │ │ 5.处理视角1 │ │ │
│ │ │──────────┐ │ │ │
│ │ │ │ │ │ │
│ │ │◄─────────┘ │ │ │
│ │ │ │ │ │
│ │ │ │ 6.处理视角2 │ │
│ │ │ │──────────┐ │ │
│ │ │ │ │ │ │
│ │ │ │◄─────────┘ │ │
│ │ │ │ │ │
│ │ │ │ │ 7.处理视角3 │
│ │ │ │ │──────────┐ │
│ │ │ │ │ │ │
│ │ │ │ │◄─────────┘ │
│ │ │ │ │ │
│ │ │ 8.返回结果A │ │ │
│ │ │───────────────────────────────────────────────►│
│ │ │ │ │ │
│ │ │ │ 9.返回结果B │ │
│ │ │ │───────────────────────────────►│
│ │ │ │ │ │
│ │ │ │ │ 10.返回结果C │
│ │ │ │ │───────────────►│
│ │ │ │ │ │
│ │ │ │ │ 11.汇总合并 │
│ │ │ │ │──────────┐ │
│ │ │ │ │ │ │
│ │ │ │ │◄─────────┘ │
│ │ │ │ │ │
│ │ │ │ │ 12.返回最终结果
│ │ │ │ │◄──────────────│
│ │ │ │ │ │
│ 13.返回结果 │ │ │ │ │
│◄──────────────────────────────────────────────────────────────────────────────│
│ │ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 请求-响应 | 分发器并行调用多个 Agent |
| 消息传递 | 结果异步汇总到聚合器 |
通信流程：
分发器 Agent A Agent B Agent C 汇总器
│ │ │ │ │
│ 1. 并行分发 │ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ 2. 并行分发 │ │ │ │
│──────────────────────────────►│ │ │
│ │ │ │ │
│ 3. 并行分发 │ │ │ │
│──────────────────────────────────────────────►│ │
│ │ │ │ │
│ │ 4. 返回结果 │ │ │
│ │───────────────────────────────────────────────►│
│ │ │ │ │
│ │ │ 5. 返回结果 │ │
│ │ │───────────────────────────────►│
│ │ │ │ │
│ │ │ │ 6. 返回结果 │
│ │ │ │───────────────►│
│ │ │ │ │
│ │ │ │ 7. 汇总合并 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │代表框架 ：LangGraph、Semantic Kernel
优点 ：高吞吐、多视角分析
缺点：结果合并复杂、资源消耗大
6. Debate/Adversarial（辩论/对抗模式）
核心思想：多个 Agent 从不同角度论证，通过对抗得出更优结论。
架构图：
┌─────────────────────────────────────────────────────────────────────┐
│ 辩论舞台 │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────┐ ┌─────────────────┐
│ Agent A │ │ Agent B │
│ (正方) │ │ (反方) │
│ ┌───────────┐ │ │ ┌───────────┐ │
│ │ • 支持论点 │ │◄───────────────►│ │ • 反对论点 │ │
│ │ • 提供证据 │ │ 直接对抗 │ │ • 质疑证据 │ │
│ │ • 反驳对方 │ │ │ │ • 提出替代 │ │
│ └───────────┘ │ │ └───────────┘ │
└────────┬────────┘ └────────┬────────┘
│ │
│ ┌─────────┐ │
│ │ 辩论记录 │ │
└──────────►│ • 论点 │◄────────────┘
│ • 证据 │
│ • 反驳 │
└────┬────┘
│
▼
┌─────────────────┐
│ Judge/Critic │
│ (裁决者) │
│ ┌───────────┐ │
│ │ • 评估论点 │ │
│ │ • 权衡证据 │ │
│ │ • 做出裁决 │ │
│ │ • 生成报告 │ │
│ └───────────┘ │
└─────────────────┘时序图：
用户 Agent A(正方) Agent B(反方) Judge 辩论记录
│ │ │ │ │
│ 1.提出问题 │ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 2.提出正方论点│ │ │
│ │──────────────────────────────────────────────►│
│ │ │ │ │
│ │ │ 3.提出反方论点│ │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ 4.反驳反方 │ │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 5.反驳正方 │ │
│ │◄──────────────│ │ │
│ │ │ │ │
│ │ 6.补充证据 │ │ │
│ │──────────────────────────────────────────────►│
│ │ │ │ │
│ │ │ 7.质疑证据 │ │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ 8.最终陈述 │ │ │
│ │──────────────────────────────────────────────►│
│ │ │ │ │
│ │ │ 9.最终陈述 │ │
│ │ │──────────────────────────────►│
│ │ │ │ │
│ │ │ │ 10.评估辩论 │
│ │ │ │◄──────────────│
│ │ │ │ │
│ │ │ │ 11.权衡论点 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ │ 12.做出裁决 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ │ 13.生成报告 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ 14.返回裁决 │ │ │ │
│◄──────────────────────────────────────────────────────────────│
│ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 消息传递 | Agent 之间通过消息交换论点 |
| 共享状态 | 辩论记录作为共享状态 |
| 事件驱动 | 论点变更触发对手响应 |
通信流程：
Agent A(正方) 辩论记录 Agent B(反方) Judge
│ │ │ │
│ 1. 提出论点 │ │ │
│──────────────►│ │ │
│ │ │ │
│ │ 2. 读取论点 │ │
│ │◄──────────────│ │
│ │ │ │
│ │ 3. 提出反驳 │ │
│ │◄──────────────│ │
│ │ │ │
│ 4. 读取反驳 │ │ │
│──────────────►│ │ │
│ │ │ │
│ 5. 补充论点 │ │ │
│──────────────►│ │ │
│ │ │ │
│ │ │ 6. 读取所有记录
│ │ │──────────────►│
│ │ │ │
│ │ │ │ 7. 做出裁决
│ │ │ │──────────┐
│ │ │ │ │
│ │ │ │◄─────────┘
│ │ │ │代表框架 ：AutoGen、CAMEL
优点 ：提高决策质量、减少偏见
缺点：延迟高、token 消耗大
7. Tool-Shared（工具共享模式）
核心思想：多个 Agent 共享同一工具注册表，各自选择需要的工具执行。
架构图：
┌─────────────────────────────────────────────────────────────────────┐
│ 工具注册表 (Tool Registry) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 搜索工具 │ │ 代码执行 │ │ 文件操作 │ │ 数据库 │ │ API调用 │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ • Web搜索│ │ • Python │ │ • 读取 │ │ • 查询 │ │ • REST │ │
│ │ • 知识库 │ │ • Shell │ │ • 写入 │ │ • 更新 │ │ • GraphQL│ │
│ │ • 向量DB │ │ • Node │ │ • 删除 │ │ • 删除 │ │ • gRPC │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
└───────┼────────────┼────────────┼────────────┼────────────┼────────┘
│ │ │ │ │
│ │ │ │ │
┌─────┴────────────┴────────────┴────────────┴────────────┴─────┐
│ 工具访问层 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 权限控制 • 工具发现 • 参数验证 • 结果过滤 │ │
│ └─────────────────────────────────────────────────────────┘ │
└─────┬────────────┬────────────┬────────────┬────────────┬─────┘
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Agent A │ │ Agent B │ │ Agent C │ │ Agent D │ │ Agent E │
│ (研究) │ │ (编码) │ │ (分析) │ │ (写作) │ │ (运维) │
│ │ │ │ │ │ │ │ │ │
│ 使用: │ │ 使用: │ │ 使用: │ │ 使用: │ │ 使用: │
│ • 搜索 │ │ • 代码 │ │ • 数据库│ │ • 文件 │ │ • API │
│ • 知识库│ │ • 文件 │ │ • 搜索 │ │ • 搜索 │ │ • 监控 │
└─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘时序图：
Agent A 工具注册表 搜索工具 代码执行 文件操作
│ │ │ │ │
│ 1.发现可用工具│ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ 2.返回工具列表│ │ │ │
│◄──────────────│ │ │ │
│ │ │ │ │
│ 3.请求使用搜索工具 │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 4.验证权限 │ │ │
│ │──────────┐ │ │ │
│ │ │ │ │ │
│ │◄─────────┘ │ │ │
│ │ │ │ │
│ │ 5.转发请求 │ │ │
│ │──────────────►│ │ │
│ │ │ │ │
│ │ │ 6.执行搜索 │ │
│ │ │──────────┐ │ │
│ │ │ │ │ │
│ │ │◄─────────┘ │ │
│ │ │ │ │
│ │ 7.返回结果 │ │ │
│ │◄──────────────│ │ │
│ │ │ │ │
│ 8.收到搜索结果│ │ │ │
│◄──────────────│ │ │ │
│ │ │ │ │
│ 9.需要执行代码│ │ │ │
│──────────────►│ │ │ │
│ │ │ │ │
│ │ 10.转发请求 │ │ │
│ │──────────────────────────────►│ │
│ │ │ │ │
│ │ │ │ 11.执行代码 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ 12.返回结果 │ │ │
│ │◄──────────────────────────────│ │
│ │ │ │ │
│ 13.收到执行结果 │ │ │
│◄──────────────│ │ │ │
│ │ │ │ │通信模式：
| 通信方式 | 描述 |
|---|---|
| 请求-响应 | Agent 通过工具注册表调用工具 |
| 共享状态 | 工具注册表作为共享资源 |
通信流程：
Agent A 工具注册表 搜索工具 代码执行
│ │ │ │
│ 1. 发现工具 │ │ │
│──────────────►│ │ │
│ │ │ │
│ 2. 返回列表 │ │ │
│◄──────────────│ │ │
│ │ │ │
│ 3. 调用搜索 │ │ │
│──────────────►│ │ │
│ │ │ │
│ │ 4. 转发请求 │ │
│ │──────────────►│ │
│ │ │ │
│ │ 5. 返回结果 │ │
│ │◄──────────────│ │
│ │ │ │
│ 6. 收到结果 │ │ │
│◄──────────────│ │ │
│ │ │ │
│ 7. 调用代码 │ │ │
│──────────────────────────────────────────────►│
│ │ │ │
│ 8. 返回结果 │ │ │
│◄──────────────────────────────────────────────│
│ │ │ │代表框架 ：LangChain、OpenClaw
优点 ：工具复用、减少重复开发
缺点：工具权限管理复杂
二、OpenClaw 多 Agent 架构分析
2.1 OpenClaw 的设计模式
OpenClaw 采用的是 Supervisor + Binding 路由 + 层级子 Agent 的混合模式：
通信模式：
| 通信方式 | 描述 | 使用场景 |
|---|---|---|
| Gateway 路由 | 通过中央 Gateway 路由消息 | 消息分发、Agent 选择 |
| 请求-响应 | Agent 同步调用子 Agent | 任务委托、结果收集 |
| 消息传递 | 异步任务分发 | 后台任务、长时间运行 |
| A2A 工具 | Agent-to-Agent 直接通信 | 跨 Agent 协作（可选） |
| Steering/Follow-Up | 消息队列注入 | 上下文补充、任务继续 |
整体架构图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ 用户 │
│ (WhatsApp/Telegram/Discord/...) │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Gateway (网关) │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ Binding 路由引擎 │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ • channel 匹配 (WhatsApp/Telegram/Discord/...) │ │ │
│ │ │ • accountId 匹配 (账号级别) │ │ │
│ │ │ • peer 匹配 (DM/群组/频道) │ │ │
│ │ │ • guildId/teamId/roles 匹配 (平台特定) │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│
┌───────────────────────┼───────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────┐
│ Agent A │ │ Agent B │ │ Agent C │
│ (main) │ │ (coding) │ │ (support) │
│ ┌───────────────┐ │ │ ┌───────────────┐ │ │ ┌───────────────┐ │
│ │ Workspace │ │ │ │ Workspace │ │ │ │ Workspace │ │
│ │ • AGENTS.md │ │ │ │ • AGENTS.md │ │ │ │ • AGENTS.md │ │
│ │ • SOUL.md │ │ │ │ • SOUL.md │ │ │ │ • SOUL.md │ │
│ │ • MEMORY.md │ │ │ │ • MEMORY.md │ │ │ │ • MEMORY.md │ │
│ └───────────────┘ │ │ └───────────────┘ │ │ └───────────────┘ │
│ ┌───────────────┐ │ │ ┌───────────────┐ │ │ ┌───────────────┐ │
│ │ Agent Dir │ │ │ │ Agent Dir │ │ │ │ Agent Dir │ │
│ │ • auth │ │ │ │ • auth │ │ │ │ • auth │ │
│ │ • model reg │ │ │ │ • model reg │ │ │ │ • model reg │ │
│ └───────────────┘ │ │ └───────────────┘ │ │ └───────────────┘ │
│ ┌───────────────┐ │ │ ┌───────────────┐ │ │ ┌───────────────┐ │
│ │ Session Store │ │ │ │ Session Store │ │ │ │ Session Store │ │
│ │ • 历史记录 │ │ │ │ • 历史记录 │ │ │ │ • 历史记录 │ │
│ │ • 路由状态 │ │ │ │ • 路由状态 │ │ │ │ • 路由状态 │ │
│ └───────────────┘ │ │ └───────────────┘ │ │ └───────────────┘ │
│ │ │ │ │ │ │ │
│ ▼ │ │ ▼ │ │ │
│ ┌─────────────┐ │ │ ┌─────────────┐ │ │ │
│ │ SubAgent │ │ │ │ SubAgent │ │ │ │
│ │ (leaf) │ │ │ │ (leaf) │ │ │ │
│ └─────────────┘ │ │ └─────────────┘ │ │ │
└─────────────────────┘ └─────────────────────┘ └─────────────────────┘消息路由时序图：
用户(WhatsApp) Gateway Binding引擎 Agent A(main) Agent B(coding)
│ │ │ │ │
│ 1.发送消息 │ │ │ │
│───────────────►│ │ │ │
│ │ │ │ │
│ │ 2.解析消息来源 │ │ │
│ │───────────────►│ │ │
│ │ │ │ │
│ │ │ 3.匹配Binding规则 │
│ │ │──────────┐ │ │
│ │ │ │ │ │
│ │ │◄─────────┘ │ │
│ │ │ │ │
│ │ │ 4.路由到Agent A │ │
│ │ │───────────────►│ │
│ │ │ │ │
│ │ │ │ 5.处理消息 │
│ │ │ │──────────┐ │
│ │ │ │ │ │
│ │ │ │◄─────────┘ │
│ │ │ │ │
│ │ │ │ 6.需要子Agent │
│ │ │ │────────────────►
│ │ │ │ │
│ │ │ │ │ 7.执行子任务
│ │ │ │ │──────────┐
│ │ │ │ │ │
│ │ │ │ │◄─────────┘
│ │ │ │ │
│ │ │ │ 8.返回结果 │
│ │ │ │◄────────────────
│ │ │ │ │
│ │ │ 9.汇总结果 │ │
│ │ │◄───────────────│ │
│ │ │ │ │
│ │ 10.发送回复 │ │ │
│ │◄───────────────│ │ │
│ │ │ │ │
│ 11.收到回复 │ │ │ │
│◄───────────────│ │ │ │
│ │ │ │ │2.2 核心特性对比
| 特性 | OpenClaw | LangGraph | AutoGen | CrewAI |
|---|---|---|---|---|
| 路由机制 | Binding 规则匹配 | 图节点边 | 对话驱动 | 角色分配 |
| 层级支持 | ✅ main/orchestrator/leaf | ✅ 子图 | ✅ 嵌套对话 | ✅ 层级委托 |
| 工作区隔离 | ✅ 三层隔离 | ❌ 共享状态 | ⚠️ 部分隔离 | ❌ 共享 |
| 通信方式 | Gateway + A2A 工具 | 状态传递 | 消息对话 | 任务委派 |
| 运行时 | embedded / ACP | Python | Python | Python |
| 会话管理 | ✅ 独立 Session Store | ⚠️ 图状态 | ✅ 对话历史 | ⚠️ 任务状态 |
| 模型配置 | 多层覆盖 + fallback | 节点级配置 | Agent 级配置 | Agent 级配置 |
| 工具隔离 | ✅ allow/deny 列表 | ⚠️ 共享 | ⚠️ 共享 | ⚠️ 角色绑定 |
三、设计模式详细对比
3.1 任务路由策略
| 框架 | 路由方式 | 灵活性 | 可预测性 |
|---|---|---|---|
| OpenClaw | Binding 规则（channel/peer/account） | 高 | 高 |
| LangGraph | 图边条件判断 | 极高 | 中 |
| AutoGen | 对话协商 | 中 | 低 |
| CrewAI | 预定义角色和任务 | 中 | 高 |
3.2 状态管理
| 框架 | 状态模型 | 持久化 | 隔离级别 |
|---|---|---|---|
| OpenClaw | 三层隔离（Workspace/Agent/Session） | SQLite | Agent 级 |
| LangGraph | 图状态（共享） | 可选 | 图级 |
| AutoGen | 对话历史 | 内存 | 对话级 |
| CrewAI | 任务上下文 | 内存 | 任务级 |
3.3 子 Agent 生成
| 框架 | 生成方式 | 深度限制 | 生命周期管理 |
|---|---|---|---|
| OpenClaw | ACP spawn / embedded | 可配置 maxSpawnDepth | 注册表 + sweeper |
| LangGraph | 子图嵌套 | 无内置限制 | 图执行器 |
| AutoGen | 嵌套对话 | 无内置限制 | 对话管理器 |
| CrewAI | 任务委派 | 无内置限制 | Crew 管理器 |
四、OpenClaw 独特设计亮点
4.1 三层隔离架构
OpenClaw 的三层隔离是行业中最完整的：
架构图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ Agent 隔离架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Layer 1: Workspace (工作区) │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ ~/.openclaw/workspace-<agentId>/ │ │
│ │ ├── AGENTS.md # Agent 人格、规则、能力定义 │ │
│ │ ├── SOUL.md # 灵魂定义（可选） │ │
│ │ ├── USER.md # 用户偏好（可选） │ │
│ │ ├── MEMORY.md # 长期记忆 │ │
│ │ ├── DREAMS.md # 做梦日记（可选） │ │
│ │ └── memory/ # 每日记忆目录 │ │
│ │ ├── 2026-06-04.md │ │
│ │ └── .dreams/ # 做梦状态 │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Layer 2: Agent Directory (Agent 目录) │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ ~/.openclaw/agents/<agentId>/agent/ │ │
│ │ ├── auth-profiles.json # 认证配置（API Keys、OAuth Tokens） │ │
│ │ ├── model-registry.json # 模型注册表 │ │
│ │ └── openclaw-agent.sqlite # Agent 状态数据库 │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Layer 3: Session Store (会话存储) │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ ~/.openclaw/agents/<agentId>/sessions/ │ │
│ │ ├── agent:main:dm:user123.json # 会话历史 │ │
│ │ ├── agent:main:group:abc.json # 群组会话 │ │
│ │ └── agent:main:acp:uuid.json # 子Agent会话 │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘对比其他框架：
- LangGraph：共享状态，无隔离
- AutoGen：对话级隔离，无工作区概念
- CrewAI：任务级隔离，无持久化
4.2 Binding 路由系统
OpenClaw 的 Binding 系统支持多维度路由：
路由匹配流程图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ Binding 路由匹配流程 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────┐
│ 输入消息 │
│ (channel + │
│ account + │
│ peer + │
│ guild + │
│ roles) │
└──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 1: Peer 精确匹配 │
│ (DM/群组/频道 ID) │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 2: ParentPeer 匹配 │
│ (线程继承) │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 3: GuildId + Roles 匹配 │
│ (Discord 角色路由) │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 4: GuildId 匹配 │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 5: TeamId 匹配 │
│ (Slack) │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 6: AccountId 匹配 │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Step 7: 通道级匹配 │
│ (accountId: "*") │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ 匹配成功 │ │ 未匹配 │
└─────────────┘ └──────┬──────┘
│
▼
┌─────────────┐
│ 默认 Agent │
│ 回退 │
└─────────────┘配置示例：
json5
{
bindings: [
// 精确匹配
{ agentId: "coding", match: { channel: "discord", peer: "coding-channel" } },
// 模糊匹配
{ agentId: "support", match: { channel: "whatsapp", accountId: "*" } },
// 角色匹配
{ agentId: "admin", match: { channel: "discord", guildId: "123", roles: ["admin"] } },
]
}对比其他框架：
- LangGraph：通过条件边实现，需要代码定义
- AutoGen：通过对话协商，无显式路由
- CrewAI：通过任务分配，无通道感知
4.3 ACP 运行时支持
OpenClaw 支持多种运行时：
运行时架构图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ Agent 运行时架构 │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────┐
│ Agent │
│ 配置 │
└──────┬──────┘
│
▼
┌────────────────────────────────┐
│ Runtime Router │
│ (运行时路由器) │
└────────────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────────────┐ ┌─────────────────────┐
│ Embedded Runtime │ │ ACP Runtime │
│ (内置运行时) │ │ (外部运行时) │
│ │ │ │
│ ┌───────────────┐ │ │ ┌───────────────┐ │
│ │ OpenClaw Loop │ │ │ │ ACP Client │ │
│ │ │ │ │ │ │ │
│ │ • 消息处理 │ │ │ │ • Codex │ │
│ │ • 工具调用 │ │ │ │ • Claude CLI │ │
│ │ • 状态管理 │ │ │ │ • 其他 ACP │ │
│ │ • 流式输出 │ │ │ │ │ │
│ └───────────────┘ │ │ └───────────────┘ │
│ │ │ │
│ ┌───────────────┐ │ │ ┌───────────────┐ │
│ │ 工具注册表 │ │ │ │ ACP Protocol │ │
│ │ • Bash │ │ │ │ • 任务分发 │ │
│ │ • 文件操作 │ │ │ │ • 结果收集 │ │
│ │ • 搜索 │ │ │ │ • 流式中继 │ │
│ │ • ... │ │ │ │ │ │
│ └───────────────┘ │ │ └───────────────┘ │
└─────────────────────┘ └─────────────────────┘
typescript
type AgentRuntime = "embedded" | "acp";- embedded：内置 OpenClaw 运行时
- acp：外部 ACP 运行时（如 Codex、Claude CLI）
对比其他框架：
- LangGraph：仅 Python 运行时
- AutoGen：仅 Python 运行时
- CrewAI：仅 Python 运行时
4.4 模型多层覆盖
OpenClaw 支持 5 级模型配置覆盖：
模型配置继承图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ 模型配置继承层级 │
└─────────────────────────────────────────────────────────────────────────────┘
Level 1: 全局默认
┌─────────────────────────────────────────────────────────────────────────┐
│ agents.defaults.model.primary = "mimo/mimo" │
│ agents.defaults.model.fallbacks = ["openai/gpt-4o", "anthropic/claude"]│
└─────────────────────────────────────────────────────────────────────────┘
│
│ 继承
▼
Level 2: Agent 级别
┌─────────────────────────────────────────────────────────────────────────┐
│ agents.list[0].model.primary = "anthropic/claude-sonnet-4-6" │
│ (覆盖全局默认) │
└─────────────────────────────────────────────────────────────────────────┘
│
│ 继承
▼
Level 3: 会话级别
┌─────────────────────────────────────────────────────────────────────────┐
│ session.model = "openai/gpt-5.5" │
│ (用户通过 /model 命令设置) │
└─────────────────────────────────────────────────────────────────────────┘
│
│ 继承
▼
Level 4: 通道级别
┌─────────────────────────────────────────────────────────────────────────┐
│ channels.modelByChannel.whatsapp = "anthropic/claude-haiku-4-5" │
│ (不同通道使用不同模型) │
└─────────────────────────────────────────────────────────────────────────┘
│
│ 继承
▼
Level 5: 自动 Fallback
┌─────────────────────────────────────────────────────────────────────────┐
│ 当主模型失败时，自动切换到 fallbacks 列表中的下一个模型 │
│ • 15 秒延迟等待重试 │
│ • 自动探测原模型恢复 │
│ • 状态标记: modelOverrideSource: "auto" │
└─────────────────────────────────────────────────────────────────────────┘对比其他框架：
- LangGraph：节点级配置，无 fallback
- AutoGen：Agent 级配置，无 fallback
- CrewAI：Agent 级配置，无 fallback
五、面试要点总结
5.1 常见面试问题
Q1：多 Agent 系统有哪些常见设计模式？
A：主要有 7 种：
- Supervisor（主管模式）--- 中央调度
- Hierarchical（层级模式）--- 多级管理
- Swarm（蜂群模式）--- 去中心化
- Pipeline（流水线模式）--- 顺序处理
- Parallel（并行模式）--- 扇出汇总
- Debate（辩论模式）--- 对抗决策
- Tool-Shared（工具共享模式）--- 工具复用
Q2：OpenClaw 的多 Agent 架构有什么特点？
A：OpenClaw 采用 Supervisor + Binding 路由 + 层级子 Agent 的混合模式，核心特点：
- 三层隔离架构（Workspace/Agent/Session）
- Binding 多维度路由（channel/peer/account/role）
- ACP 运行时支持（embedded + 外部运行时）
- 5 级模型配置覆盖 + 自动 fallback
- 子 Agent 角色体系（main/orchestrator/leaf）
Q3：如何保证多 Agent 系统的状态一致性？
A：常见策略：
- 隔离优先 --- 每个 Agent 独立状态空间（OpenClaw 方案）
- 共享状态 + 锁 --- LangGraph 方案
- 消息传递 --- AutoGen 方案
- 事件溯源 --- 记录所有状态变更
Q4：多 Agent 系统如何处理失败和重试？
A：OpenClaw 的策略：
- 子 Agent 失败延迟 15 秒等待重试
- 结果通告支持最多 N 次重试
- 超时控制（120 秒）
- sweeper 定期清理孤立运行
Q5：多 Agent 系统有哪些通信模式？如何选择？
A：主要有 6 种通信模式：
- 直接调用 --- 同步简单场景，如 Supervisor 调用 Worker
- 消息传递 --- 异步解耦场景，如任务队列
- 共享状态 --- 协作编辑场景，如 LangGraph 图状态
- 事件驱动 --- 松耦合扩展场景，如发布/订阅
- 黑板模式 --- 知识密集型场景，如辩论系统
- 请求-响应 --- RPC 风格调用，如 OpenClaw Gateway
选择依据：
- 同步 vs 异步需求
- 耦合度要求
- 扩展性需求
- 状态一致性要求
Q6：什么是 MCP 和 A2A？它们有什么区别？
A：MCP 和 A2A 是两种重要的 Agent 通信协议：
MCP (Model Context Protocol)：
- 提出者：Anthropic
- 定位：AI 模型与工具/数据源的标准交互协议
- 特点：请求-响应、无状态、工具发现
- 传输：Stdio、SSE、Streamable HTTP
- 场景：文件操作、数据库查询、API 调用
A2A (Agent-to-Agent)：
- 提出者：Google
- 定位：Agent 之间协作的标准协议
- 特点：任务驱动、有状态、能力发现
- 传输：HTTP + JSON-RPC
- 场景：复杂任务委托、多 Agent 协作
核心区别：
维度 MCP A2A 交互对象 AI ↔ 工具/数据 Agent ↔ Agent 通信模式 请求-响应 任务驱动 状态管理 无状态 有状态 核心概念 Tool, Resource Agent Card, Task
Q7：OpenClaw 如何同时支持 MCP 和 A2A？
A：OpenClaw 采用三层架构同时支持：
MCP 角色：
- 作为 MCP Server：暴露通道会话功能
- 作为 MCP Client：消费外部工具服务
A2A 角色：
- 作为 A2A Client：调用外部 Agent 服务
- 作为 A2A Server：提供 Agent 能力
Sub-agent 系统：
- 内部子代理：层次化委托
- ACP 运行时：集成 Claude/Codex/Gemini
配置示例：
json5{ "mcp": { "servers": { /* MCP 服务器配置 */ } }, "agents": { "defaults": { "subagents": { /* 子代理配置 */ } } }, "tools": { "agentToAgent": { /* A2A 配置 */ } } }
5.2 技术亮点（可写入简历）
- 多维度消息路由：基于 channel/peer/account/role 的 Binding 规则系统
- 三层隔离架构：Workspace/Agent Directory/Session Store 完全隔离
- ACP 运行时抽象：支持 embedded 和外部运行时（Codex、Claude CLI）
- 子 Agent 角色体系：main/orchestrator/leaf 三级角色 + 深度限制
- 模型多层覆盖：5 级配置覆盖 + 自动 fallback 机制
- 记忆系统：三阶段做梦机制（Light/REM/Deep）+ 短期到长期记忆提升
- 多通信模式支持：Gateway 路由 + 请求-响应 + 消息传递 + A2A 工具
- MCP 协议支持：双向 MCP 角色（Server + Client）+ 多传输协议
- A2A 协议支持：Sub-agent 系统 + ACP 运行时 + 层次化委托
5.3 架构对比表（速查）
| 维度 | OpenClaw | LangGraph | AutoGen | CrewAI |
|---|---|---|---|---|
| 设计模式 | Supervisor + Binding | 状态图 | 对话驱动 | 角色分配 |
| 隔离级别 | Agent 级（三层） | 图级 | 对话级 | 任务级 |
| 路由方式 | Binding 规则 | 条件边 | 协商 | 预定义 |
| 通信模式 | Gateway + 请求-响应 | 共享状态 | 消息传递 | 直接调用 |
| MCP 支持 | ✅ 双向 (Server + Client) | ⚠️ 仅 Client | ❌ 不支持 | ❌ 不支持 |
| A2A 支持 | ✅ Sub-agent + ACP | ❌ 不支持 | ⚠️ 嵌套对话 | ⚠️ 任务委派 |
| 运行时 | TS + ACP | Python | Python | Python |
| 持久化 | SQLite | 可选 | 内存 | 内存 |
| 适用场景 | 多通道 AI 网关 | 复杂工作流 | 研究对话 | 角色任务 |