Antigravity マルチエージェント設計の実践パターン — 複雑なワークフローを壊れにくく作る

// オーケストレーターの擬似コード（Antigravity ワークフロー）
const orchestrator = {
  name: "research_orchestrator",
  prompt: `
    あなたはリサーチプロジェクトのオーケストレーターです。
    ユーザーのリクエストを受け取り、以下のワーカーに適切なタスクを割り当ててください。
    
    利用可能なワーカー:
    - web_researcher: ウェブ検索と情報収集
    - data_analyzer: 収集データの分析と構造化
    - report_writer: 最終レポートの作成
    
    タスクの割り当ては JSON で返してください:
    {
      "tasks": [
        { "worker": "web_researcher", "task": "...", "priority": 1 },
        { "worker": "data_analyzer", "task": "...", "priority": 2 }
      ]
    }
  `
};

// NG: 状態を上書きする
workflow.state.data = await researcher.run(query);
workflow.state.data = await analyzer.run(workflow.state.data); // 元データが消える
 
// OK: ステップごとに保存
workflow.state.research_results = await researcher.run(query);
workflow.state.analysis_results = await analyzer.run(workflow.state.research_results);

const researchOutput = await researcher.run(query);
 
// バリデーション
if (\!researchOutput.sources || researchOutput.sources.length === 0) {
  throw new WorkflowError(
    "researcher_output_invalid",
    "sources が空です。クエリを調整して再試行してください",
    { query, output: researchOutput }
  );
}
 
const analysisInput = {
  sources: researchOutput.sources,
  context: researchOutput.summary,
};

async function runWithRecovery(agent, input, options = {}) {
  const {
    maxRetries = 3,
    retryDelay = 1000,
    fallbackAgent = null,
    onFailure = null,
  } = options;
 
  let lastError;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await agent.run(input);
    } catch (error) {
      lastError = error;
      
      // リトライ不要なエラー（入力が間違っている場合など）
      if (error.type === "invalid_input") {
        break;
      }
      
      // レート制限は待機してリトライ
      if (error.type === "rate_limit") {
        await sleep(retryDelay * attempt * 2);
        continue;
      }
      
      // それ以外は通常のリトライ
      if (attempt < maxRetries) {
        await sleep(retryDelay * attempt);
      }
    }
  }
  
  // フォールバックエージェントが設定されていれば試みる
  if (fallbackAgent) {
    try {
      return await fallbackAgent.run(input);
    } catch (fallbackError) {
      // フォールバックも失敗
    }
  }
  
  // カスタム失敗ハンドラー
  if (onFailure) {
    return onFailure(lastError, input);
  }
  
  throw lastError;
}

// 並列実行の基本パターン
async function runParallelResearch(topics) {
  const tasks = topics.map(topic => ({
    id: topic.id,
    promise: runWithRecovery(
      researchAgent,
      { topic: topic.query },
      { maxRetries: 2, fallbackAgent: lightResearchAgent }
    )
  }));
 
  // allSettled で部分的な失敗を許容する
  const results = await Promise.allSettled(
    tasks.map(t => t.promise)
  );
 
  const successful = [];
  const failed = [];
 
  results.forEach((result, index) => {
    if (result.status === "fulfilled") {
      successful.push({ id: tasks[index].id, data: result.value });
    } else {
      failed.push({ id: tasks[index].id, error: result.reason });
    }
  });
 
  // 最低限の成功数を確認
  if (successful.length < Math.ceil(topics.length * 0.7)) {
    throw new WorkflowError(
      "insufficient_results",
      `並列処理で十分な結果が得られませんでした（成功: ${successful.length}/${topics.length}）`
    );
  }
 
  return { successful, failed };
}