マルチエージェント開発の実装パターン2026

graph TD
    U[ユーザー] --> H[Hub: Orchestrator]
    H --> A[Spoke A: Researcher]
    H --> B[Spoke B: Writer]
    H --> C[Spoke C: Reviewer]
    A --> H
    B --> H
    C --> H
    H --> U

// Hub-and-Spoke の最小実装
interface SubAgentTask {
  agentId: string;
  prompt: string;
  context?: string;
}

interface SubAgentResult {
  agentId: string;
  output: string;
  status: "success" | "failed";
}

async function orchestrate(
  tasks: SubAgentTask[],
  maxConcurrent = 3
): Promise<SubAgentResult[]> {
  // Semaphore で並列数を制御（後述）
  const semaphore = new Semaphore(maxConcurrent);

  const results = await Promise.allSettled(
    tasks.map((task) =>
      semaphore.acquire().then(async (release) => {
        try {
          const output = await callAgent(task.agentId, task.prompt);
          return { agentId: task.agentId, output, status: "success" as const };
        } catch (err) {
          return {
            agentId: task.agentId,
            output: String(err),
            status: "failed" as const,
          };
        } finally {
          release();
        }
      })
    )
  );

  return results.map((r) =>
    r.status === "fulfilled"
      ? r.value
      : { agentId: "unknown", output: String(r.reason), status: "failed" }
  );
}

graph LR
    I[入力] --> A[Agent A: 抽出]
    A --> B[Agent B: 翻訳]
    B --> C[Agent C: 要約]
    C --> D[Agent D: 校正]
    D --> O[出力]

// Pipeline の最小実装
type PipelineStep = {
  name: string;
  process: (input: string) => Promise<string>;
};

async function runPipeline(
  steps: PipelineStep[],
  initialInput: string
): Promise<{ results: string[]; finalOutput: string }> {
  const results: string[] = [];
  let current = initialInput;

  for (const step of steps) {
    try {
      current = await step.process(current);
      results.push(current);
    } catch (err) {
      // 失敗ステップを記録してスロー（上流でリトライ判断）
      throw new Error(`Pipeline failed at step "${step.name}": ${String(err)}`);
    }
  }

  return { results, finalOutput: current };
}

┌─────────────┐       ┌─────────────┐
│  Agent A    │◄─────►│  Agent B    │
│ (Proposer)  │       │ (Critic)    │
└──────┬──────┘       └──────┬──────┘
       │                     │
       ▼                     ▼
┌─────────────┐       ┌─────────────┐
│  Agent C    │◄─────►│  Agent D    │
│ (Verifier)  │       │ (Synthesizer│
└─────────────┘       └─────────────┘

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetry = 3,
  backoffMs = 1000
): Promise<T> {
  let lastError: unknown;

  for (let attempt = 1; attempt <= maxRetry; attempt++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err;
      if (attempt < maxRetry) {
        // 指数バックオフ
        await sleep(backoffMs * Math.pow(2, attempt - 1));
      }
    }
  }

  throw new Error(
    `Failed after ${maxRetry} attempts. Last error: ${String(lastError)}`
  );
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

class Semaphore {
  private permits: number;
  private queue: Array<() => void> = [];

  constructor(maxConcurrent: number) {
    this.permits = maxConcurrent;
  }

  async acquire(): Promise<() => void> {
    if (this.permits > 0) {
      this.permits--;
      return () => this.release();
    }

    return new Promise<() => void>((resolve) => {
      this.queue.push(() => {
        this.permits--;
        resolve(() => this.release());
      });
    });
  }

  private release(): void {
    this.permits++;
    const next = this.queue.shift();
    if (next) next();
  }
}

// 使用例: 最大3並列でエージェントを実行
const sem = new Semaphore(3);

const results = await Promise.allSettled(
  agentTasks.map(async (task) => {
    const release = await sem.acquire();
    try {
      return await runAgent(task);
    } finally {
      release();
    }
  })
);

async function callWithBackoff(
  apiFn: () => Promise<Response>,
  maxAttempts = 5
): Promise<Response> {
  for (let i = 0; i < maxAttempts; i++) {
    const response = await apiFn();

    if (response.status !== 429) return response;

    const retryAfter = response.headers.get("Retry-After");
    const waitMs = retryAfter
      ? parseInt(retryAfter) * 1000
      : 1000 * Math.pow(2, i);

    await sleep(waitMs);
  }

  throw new Error("Rate limit: max attempts exceeded");
}

Session A: main → article/slug-a ブランチを作成して作業
Session B: main → 同じブランチ名でチェックアウト → 衝突

# 各 conductor を独立した worktree で起動する
git worktree add .claude/worktrees/agent-<id> -b article/<slug>

# 完了後に worktree を削除
git worktree remove .claude/worktrees/agent-<id>

async function runResumablePipeline(
  steps: PipelineStep[],
  input: string,
  checkpointDir: string
): Promise<string> {
  let current = input;

  for (let i = 0; i < steps.length; i++) {
    const checkpointFile = `${checkpointDir}/step-${i}.json`;

    // 既存チェックポイントがあればスキップ
    if (await fileExists(checkpointFile)) {
      const saved = await readJson(checkpointFile);
      current = saved.output;
      continue;
    }

    current = await steps[i].process(current);
    await writeJson(checkpointFile, { output: current });
  }

  return current;
}

// Claude を Hub、Claude + Codex を Spoke とした設計
const analysisTask = {
  agentId: "claude",
  prompt: `以下の要件を分析し、実装すべき関数リストをJSON形式で出力してください：\n${requirements}`,
};

const codingTasks = functionList.map((fn) => ({
  agentId: "codex",
  prompt: `以下の仕様で TypeScript 関数を実装してください：\n${fn.spec}`,
}));

// Hub（Claude）が分析
const analysis = await callClaude(analysisTask.prompt);
const functionList = parseJson(analysis);

// Spoke（Codex）を並列実行（Semaphore で rate limit 制御）
const codeResults = await orchestrate(codingTasks, 3);

// Hub（Claude）が統合とレビュー
const reviewPrompt = `以下のコードをレビューし、問題点を指摘してください：\n${codeResults}`;
const review = await callClaude(reviewPrompt);

タスクを複数エージェントに分割したい
  │
  ├── タスク間に依存関係がある？
  │     ├── YES → Pipeline パターン
  │     │          （前段の出力が後段の入力になる）
  │     └── NO → Hub-and-Spoke パターン
  │               （独立タスクを Hub が管理）
  │
  └── エージェント同士が対話しながら成果を作りたい？
        ├── YES → Peer-to-Peer パターン
        │          （実装コストを許容できるか確認）
        └── NO → Hub-and-Spoke パターン（推奨デフォルト）