OpenClaw 主控 Agent + 子 Agent 分工协作完全指南

单个 AI Agent 处理复杂任务时容易"顾此失彼"。主控 Agent + 子 Agent 的分工模式，让 AI 像人类团队一样协作：主控负责规划和协调，子 Agent 各司其职，效率翻倍。

为什么需要主控 + 子 Agent 模式？

单 Agent 的局限

场景一：复杂任务

用户：帮我开发一个完整的网站，包括前端、后端、数据库设计

单 Agent：
"这个任务太复杂了，我需要一步步来...
先写前端...等等，后端还没设计...
数据库结构不对...前端又要改..."
（陷入循环，效率低下）

场景二：多领域协作

用户：分析这份财报，生成数据可视化，写一份数据分析报告

单 Agent：
"我擅长文本处理，数据分析也懂一点，
可视化...呃...好像也可以..."
（每个领域都不专业，质量参差不齐）

主控 + 子 Agent 的优势

主控 Agent（大脑）
    ├── 子 Agent A（前端专家）
    ├── 子 Agent B（后端专家）
    ├── 子 Agent C（数据库专家）
    └── 子 Agent D（测试专家）

对比项	单 Agent	主控 + 子 Agent
任务复杂度	⚠️ 有限	✅ 无限
专业程度	⚠️ 泛而不精	✅ 各司其职
执行效率	⚠️ 串行处理	✅ 并行执行
错误恢复	⚠️ 全局失败	✅ 局部重试
可维护性	⚠️ 一体化	✅ 模块化

---

核心概念

主控 Agent（Orchestrator）

职责：

• 接收用户任务
• 分解为子任务
• 分配给子 Agent
• 汇总结果
• 返回给用户

不负责：

• 具体执行细节
• 专业领域操作

子 Agent（Sub-agent）

职责：

• 执行具体任务
• 返回执行结果

特点：

• 单一职责（只做一件事）
• 专业性强（精通某个领域）
• 可复用（被多个主控 Agent 调用）

---

配置方法

Step 1：创建子 Agent

每个子 Agent 都是一个独立的配置文件。

示例：前端开发 Agent

# agents/frontend-agent.yaml
name: frontend-agent
description: 前端开发专家，负责 React/Vue 组件开发

capabilities:
  - 创建 React 组件
  - 编写 CSS 样式
  - 实现响应式布局
  - 优化前端性能

tools:
  - filesystem
  - browser-use
  
persona: |
  你是一名资深前端开发工程师。
  你精通 React、Vue、TypeScript。
  你专注于用户体验和性能优化。
  你只负责前端部分，不处理后端逻辑。

示例：后端开发 Agent

# agents/backend-agent.yaml
name: backend-agent
description: 后端开发专家，负责 API 和数据库设计

capabilities:
  - 设计 RESTful API
  - 编写后端逻辑
  - 数据库设计与优化
  - 接口安全防护

tools:
  - filesystem
  - shell
  
persona: |
  你是一名资深后端开发工程师。
  你精通 Node.js、Python、Java。
  你专注于系统架构和数据安全。
  你只负责后端部分，不处理前端展示。

Step 2：创建主控 Agent

主控 Agent 负责协调所有子 Agent。

# agents/orchestrator.yaml
name: project-orchestrator
description: 项目主控 Agent，负责分解任务、协调子 Agent、汇总结果

sub_agents:
  - frontend-agent
  - backend-agent
  - database-agent
  - test-agent

orchestration_strategy: parallel  # parallel 或 sequential

workflow: |
  1. 分析用户需求
  2. 分解为子任务
  3. 识别需要的子 Agent
  4. 分配任务给子 Agent
  5. 收集子 Agent 结果
  6. 汇总并检查一致性
  7. 返回最终结果
  
persona: |
  你是项目协调者，不负责具体实现。
  你的职责是：
  - 理解用户需求
  - 分解任务
  - 分配给合适的专家
  - 汇总结果
  - 确保各部分协调一致
  
  你不直接编写代码，而是协调专家团队完成。

Step 3：配置主控 Agent 的任务分解规则

# orchestrator-rules.yaml
task_decomposition:
  website_development:
    pattern: |
      任务：开发网站
      ├── 子任务1：设计数据库结构 → database-agent
      ├── 子任务2：开发后端 API → backend-agent
      ├── 子任务3：开发前端界面 → frontend-agent
      └── 子任务4：编写测试用例 → test-agent
      
  data_analysis_report:
    pattern: |
      任务：数据分析报告
      ├── 子任务1：数据清洗 → data-cleaner-agent
      ├── 子任务2：数据分析 → data-analyst-agent
      ├── 子任务3：可视化图表 → visualization-agent
      └── 子任务4：撰写报告 → report-writer-agent

---

实战案例：开发一个待办事项应用

用户输入

帮我开发一个待办事项 Web 应用，要求：
- 用户可以添加、删除、修改待办
- 支持分类和标签
- 数据持久化存储
- 界面简洁美观

主控 Agent 执行流程

Step 1：任务分析

{
  "task": "开发待办事项应用",
  "components": [
    {
      "subtask": "设计数据库",
      "assigned_to": "database-agent",
      "input": "待办事项数据结构，支持分类和标签"
    },
    {
      "subtask": "开发后端 API",
      "assigned_to": "backend-agent",
      "input": "CRUD 操作接口，分类标签管理"
    },
    {
      "subtask": "开发前端界面",
      "assigned_to": "frontend-agent",
      "input": "简洁美观的 UI，响应式设计"
    }
  ]
}

Step 2：并行执行

主控 Agent 同时调用 3 个子 Agent：

# 主控 Agent 的执行日志
[Orchestrator] 开始任务：开发待办事项应用
[Orchestrator] 分解为 3 个子任务
[Orchestrator] 并行调用：
  ├── [database-agent] 设计数据库...
  ├── [backend-agent] 开发 API...
  └── [frontend-agent] 开发界面...

Step 3：收集结果

{
  "database-agent": {
    "status": "success",
    "output": {
      "schema": "todos(id, title, category, tags, status, created_at)",
      "file": "database/schema.sql"
    }
  },
  "backend-agent": {
    "status": "success",
    "output": {
      "apis": ["GET /todos", "POST /todos", "PUT /todos/:id", "DELETE /todos/:id"],
      "file": "backend/routes/todos.js"
    }
  },
  "frontend-agent": {
    "status": "success",
    "output": {
      "components": ["TodoList", "TodoItem", "AddTodo", "FilterBar"],
      "file": "frontend/src/App.jsx"
    }
  }
}

Step 4：汇总返回

[Orchestrator] 所有子任务完成
[Orchestrator] 检查一致性：
  ✓ 数据库字段与 API 参数匹配
  ✓ API 返回格式与前端组件匹配
[Orchestrator] 任务完成，返回结果

最终产出：
├── database/schema.sql（数据库结构）
├── backend/routes/todos.js（后端 API）
└── frontend/src/App.jsx（前端界面）

---

高级配置

顺序执行 vs 并行执行

并行执行（parallel）：

• 子任务之间无依赖关系
• 执行速度快
• 适合独立模块

顺序执行（sequential）：

• 子任务之间有依赖关系
• 前一个任务的输出是后一个的输入
• 适合流水线流程

# 顺序执行示例：数据分析流水线
orchestration_strategy: sequential

workflow:
  - step: 1
    agent: data-cleaner-agent
    task: "清洗原始数据"
    
  - step: 2
    agent: data-analyst-agent
    task: "分析清洗后的数据"
    depends_on: step_1
    
  - step: 3
    agent: visualization-agent
    task: "生成可视化图表"
    depends_on: step_2

结果汇总策略

result_aggregation:
  strategy: merge  # merge, select, vote
  
  merge:
    description: "合并所有子 Agent 的结果"
    when: "各子任务独立，结果可合并"
    
  select:
    description: "选择最佳结果"
    when: "多个 Agent 执行相同任务，选择最优解"
    
  vote:
    description: "投票决定最终结果"
    when: "需要多方意见，少数服从多数"

错误处理

error_handling:
  retry_policy:
    max_attempts: 3
    backoff: exponential
    
  fallback:
    on_agent_failure: "使用备用 Agent 或跳过"
    on_all_failure: "返回错误信息和建议"

---

Swarm 编排模式

Swarm 是 OpenClaw 的高级编排模式，Agent 之间可以相互传递任务。

工作原理

用户 → 主控 Agent A
         ↓
      子 Agent B 执行任务
         ↓
      发现需要 Agent C 的能力
         ↓
      传递给 Agent C
         ↓
      Agent C 完成后返回
         ↓
      主控 Agent A 汇总

配置示例

# swarm-config.yaml
mode: swarm

agents:
  - name: researcher
    role: "信息收集者"
    can_handoff_to: [analyzer, writer]
    
  - name: analyzer
    role: "数据分析师"
    can_handoff_to: [writer]
    
  - name: writer
    role: "内容撰写者"
    can_handoff_to: [researcher]

handoff_rules:
  - from: researcher
    to: analyzer
    when: "需要数据分析"
    
  - from: analyzer
    to: writer
    when: "分析完成，需要撰写报告"

---

最佳实践

1. 单一职责原则

每个子 Agent 只做一件事：

✅ 好：
- frontend-agent：只负责前端
- backend-agent：只负责后端
- test-agent：只负责测试

❌ 坏：
- fullstack-agent：前端后端都做

2. 明确接口定义

子 Agent 的输入输出必须明确：

interface:
  input:
    - task_description: string
    - context: object
  output:
    - status: success | failure
    - result: string
    - artifacts: file[]

3. 合理拆分粒度

太粗：website-agent（一个 Agent 做整个网站）❌
太细：create-button-agent（一个 Agent 只创建按钮）❌
合适：frontend-agent（负责前端模块）✅

4. 监控和日志

主控 Agent 必须记录完整的执行日志：

{
  "task_id": "task-001",
  "started_at": "2026-04-08T13:00:00Z",
  "sub_tasks": [
    {
      "agent": "frontend-agent",
      "started_at": "2026-04-08T13:00:05Z",
      "completed_at": "2026-04-08T13:02:30Z",
      "status": "success"
    }
  ],
  "completed_at": "2026-04-08T13:05:00Z",
  "total_time": "5m"
}

---

常见问题

Q1：主控 Agent 会"抢活"吗？

答： 不会。主控 Agent 的 persona 明确定义"只协调不执行"，它不会直接处理具体任务。

Q2：子 Agent 之间可以通信吗？

答： 在 Swarm 模式下可以。子 Agent 可以根据需要传递任务给其他子 Agent。

Q3：如何处理子 Agent 失败？

答： 主控 Agent 会根据 error_handling 配置决定：

• 重试（retry）
• 跳过（skip）
• 回滚（rollback）
• 返回部分结果（partial）

Q4：并行执行会有冲突吗？

答： 不会。每个子 Agent 操作不同的文件和模块，主控 Agent 会检查结果一致性。

---

总结

要点	说明
核心思想	分工协作，各司其职
主控 Agent	规划、协调、汇总
子 Agent	执行具体任务
执行模式	并行或顺序
关键配置	persona + interface + error_handling

一句话总结：让专业的 Agent 做专业的事，主控 Agent 只负责协调，这才是多 Agent 协作的正确打开方式。