Multi-Agent Orchestration 是什么？

模式1: 顺序流水线 (Sequential Pipeline)
用户请求 → AgentA(搜索) → AgentB(总结) → AgentC(生成) → 结果
优点: 简单清晰  缺点: 慢，串行执行

模式2: 并行扇出 (Parallel Fan-out)
用户请求 → ┬→ AgentA(搜索新闻)
           ├→ AgentB(搜索论文)
           └→ AgentC(搜索视频)
         ↓ (等待所有完成)
         聚合器 → 生成最终报告
优点: 快，并行执行  缺点: 需要聚合逻辑

模式3: 层级编排 (Hierarchical)
Manager Agent (任务分解+分配)
  ├─ Worker Agent 1 (执行子任务1)
  ├─ Worker Agent 2 (执行子任务2)
  └─ Worker Agent 3 (执行子任务3)
优点: 灵活，可处理复杂任务  缺点: Manager可能成为瓶颈

模式4: 协作网络 (Collaborative Network)
AgentA ←→ AgentB ←→ AgentC
  (平等协作，互相传递信息)
优点: 动态调整  缺点: 可能死锁或冲突

# OpenClaw 多Agent编排配置
orchestration:
  mode: hierarchical  # sequential | parallel | hierarchical | collaborative
  
  # Manager Agent
  manager:
    model: claude-opus-4
    system_prompt: |
      你是一个任务编排器。收到复杂任务后，
      将其分解为子任务，分配给合适的Worker。
      等待所有Worker完成后，聚合结果返回给用户。
    max_workers: 5
  
  # Worker Agents
  workers:
    - name: news-fetcher
      model: claude-haiku
      skills: [web-search, rss-parser]
      specialization: "新闻采集"
      
    - name: content-writer
      model: claude-sonnet
      skills: [writing, html-generation]
      specialization: "内容创作"
      
    - name: seo-optimizer
      model: claude-haiku
      skills: [seo-analysis, keyword-research]
      specialization: "SEO优化"
  
  # 任务分配策略
  assignment:
    strategy: capability-based  # 基于能力匹配
    fallback: "round-robin"      # 回退策略
  
  # 通信方式
  communication:
    protocol: shared_context  # shared_context | message_queue | api_calls
    timeout: 300

// orchestrator.js
export class MultiAgentOrchestrator {
  constructor() {
    this.agents = new Map();
    this.taskQueue = [];
  }
  
  registerAgent(name, agent) {
    this.agents.set(name, agent);
  }
  
  // 顺序执行
  async runSequential(task, agentNames) {
    let result = task;
    for (const name of agentNames) {
      const agent = this.agents.get(name);
      if (!agent) throw new Error(`Agent ${name} not found`);
      console.log(`🤖 ${name} 处理中...`);
      result = await agent.process(result);
    }
    return result;
  }
  
  // 并行执行
  async runParallel(task, agentNames) {
    const promises = agentNames.map(name => {
      const agent = this.agents.get(name);
      if (!agent) throw new Error(`Agent ${name} not found`);
      console.log(`🤖 ${name} 并行处理...`);
      return agent.process(task);
    });
    return await Promise.all(promises);
  }
  
  // 层级编排
  async runHierarchical(task) {
    const manager = this.agents.get('manager');
    
    // 1. Manager分解任务
    const subtasks = await manager.decompose(task);
    console.log(`📋 分解为${subtasks.length}个子任务`);
    
    // 2. 分配并执行
    const results = [];
    for (const subtask of subtasks) {
      const workerName = await manager.assign(subtask);
      const worker = this.agents.get(workerName);
      const result = await worker.process(subtask);
      results.push(result);
    }
    
    // 3. 聚合结果
    return await manager.aggregate(results);
  }
}

// 使用示例
const orchestrator = new MultiAgentOrchestrator();

// 注册Agents
orchestrator.registerAgent('searcher', {
  process: async (task) => { /* 搜索逻辑 */ }
});
orchestrator.registerAgent('writer', {
  process: async (data) => { /* 写作逻辑 */ }
});
orchestrator.registerAgent('optimizer', {
  process: async (content) => { /* SEO优化 */ }
});

// 顺序执行：搜索→写作→优化
const result = await orchestrator.runSequential(
  '生成AI新闻日报',
  ['searcher', 'writer', 'optimizer']
);