AgentKit 2.0 でマルチエージェント開発を始める — Antigravity 環境での設計と実装

import { Agent, Workflow, Coordinator } from '@google-cloud/agentkit';
 
// 3 つの調査エージェント
const webSearchAgent = new Agent({
  name: 'web_search_agent',
  systemPrompt: 'Search for information using web sources only.',
  tools: ['google_search', 'summarize'],
  maxIterations: 4,
  timeoutMs: 40000,
});
 
const githubAgent = new Agent({
  name: 'github_agent',
  systemPrompt: 'Find information from GitHub repositories, issues, and discussions.',
  tools: ['github_api', 'code_analysis'],
  maxIterations: 3,
  timeoutMs: 30000,
});
 
const docsAgent = new Agent({
  name: 'docs_agent',
  systemPrompt: 'Extract relevant information from official documentation.',
  tools: ['docs_fetch', 'parse_markdown'],
  maxIterations: 3,
  timeoutMs: 25000,
});
 
// 結果統合エージェント
const synthesisAgent = new Agent({
  name: 'synthesis_agent',
  systemPrompt: `You are a senior analyst. You receive research from 3 sources:
- web_search_agent: findings from the web
- github_agent: findings from GitHub
- docs_agent: findings from official docs
 
Your job is to synthesize these into a single coherent report that clearly attributes each claim to its source.`,
  tools: ['format', 'validate'],
  maxIterations: 5,
  timeoutMs: 30000,
});
 
// Workflow で「調査 3 つ→統合」の流れを定義
const researchWorkflow = new Workflow({
  name: 'parallel_research_workflow',
  agents: {
    web: webSearchAgent,
    github: githubAgent,
    docs: docsAgent,
    synthesis: synthesisAgent,
  },
  edges: [
    // 調査エージェント 3 つは同時起動（が、現在の実装では順序保証なしで起動される）
    // その後、synthesis エージェントが全結果を受け取る
    new Edge('web', 'synthesis', () => true),
    new Edge('github', 'synthesis', () => true),
    new Edge('docs', 'synthesis', () => true),
  ],
});
 
const result = await researchWorkflow.execute({
  input: {
    topic: 'Antigravity IDE の 2026 年ロードマップ',
    context: 'リサーチはできるだけ最新の情報を集めてください',
  },
});
 
console.log(result);
// 出力:
// {
//   status: 'success',
//   synthesis_result: { 
//     report: "Antigravity の...",
//     sources: { web: [...], github: [...], docs: [...] }
//   }
// }

// 提案エージェント
const proposalAgent = new Agent({
  name: 'proposal_agent',
  systemPrompt: `You are a proposal architect. Given a requirement, generate a concrete implementation plan.
Output must be valid JSON with fields: title, steps, estimated_hours, risk_level, alternatives.`,
  tools: ['plan', 'estimate'],
  maxIterations: 5,
  timeoutMs: 45000,
});
 
// 確認エージェント（人間が前に立つ）
const reviewerAgent = new Agent({
  name: 'reviewer_agent',
  systemPrompt: `You are a technical reviewer. Evaluate the proposal from proposal_agent.
Check for:
1. Feasibility (can this be done?)
2. Timeline (is the estimate realistic?)
3. Risks (what could go wrong?)
 
Output: APPROVED or REJECTED with explanation.`,
  tools: ['assess_feasibility', 'historical_data'],
  maxIterations: 3,
  timeoutMs: 30000,
});
 
// 実行エージェント
const executorAgent = new Agent({
  name: 'executor_agent',
  systemPrompt: `You are a project executor. You receive an APPROVED proposal.
Break it into actionable tasks, assign resources, set up monitoring.`,
  tools: ['task_create', 'resource_allocate', 'monitoring_setup'],
  maxIterations: 6,
  timeoutMs: 60000,
});
 
// 承認チェーン Workflow
const approvalWorkflow = new Workflow({
  name: 'approval_chain',
  agents: {
    propose: proposalAgent,
    review: reviewerAgent,
    execute: executorAgent,
  },
  edges: [
    // 条件分岐：review が APPROVED なら execute へ、そうでなければ終了
    new Edge('propose', 'review', () => true),
    new Edge('review', 'execute', (reviewOutput) => {
      return reviewOutput.decision === 'APPROVED';
    }),
  ],
});
 
const approval = await approvalWorkflow.execute({
  input: {
    requirement: 'Antigravity IDE に「コード品質分析」機能を追加する',
    budget_hours: 80,
  },
});
 
console.log(approval);
// 出力:
// {
//   status: 'success',
//   proposal: { title: '...', steps: [...], estimated_hours: 72 },
//   review_decision: 'APPROVED',
//   execution_plan: { tasks: [...], resources: [...] }
// }

// 下位エージェント（専門家）
const architectAgent = new Agent({
  name: 'architect',
  systemPrompt: 'You are a software architect. Design the system architecture for the given requirement.',
  tools: ['design_pattern', 'architecture_decision'],
  maxIterations: 4,
  timeoutMs: 30000,
});
 
const securityAgent = new Agent({
  name: 'security_expert',
  systemPrompt: 'You are a security expert. Identify potential security risks and recommend mitigations.',
  tools: ['threat_analysis', 'security_best_practices'],
  maxIterations: 4,
  timeoutMs: 30000,
});
 
const performanceAgent = new Agent({
  name: 'performance_expert',
  systemPrompt: 'You are a performance engineer. Analyze the architecture and identify optimization opportunities.',
  tools: ['profiling', 'benchmarking'],
  maxIterations: 4,
  timeoutMs: 30000,
});
 
// 上位エージェント（監督者）
const supervisorAgent = new Agent({
  name: 'supervisor',
  systemPrompt: `You are a technical director supervising 3 specialists:
- architect: handles system design
- security_expert: handles security
- performance_expert: handles performance
 
Given a requirement, delegate tasks to each specialist, collect their feedback, and produce a final integrated decision.`,
  tools: ['delegate_task', 'integrate_feedback', 'decision_make'],
  maxIterations: 8,
  timeoutMs: 60000,
});
 
// 階層型 Workflow
const hierarchicalWorkflow = new Workflow({
  name: 'hierarchical_review',
  agents: {
    supervisor: supervisorAgent,
    architect: architectAgent,
    security: securityAgent,
    performance: performanceAgent,
  },
  edges: [
    // supervisor が最初に起動、その結果を 3 つの下位エージェントに委譲
    new Edge('supervisor', 'architect', () => true),
    new Edge('supervisor', 'security', () => true),
    new Edge('supervisor', 'performance', () => true),
  ],
});
 
const result = await hierarchicalWorkflow.execute({
  input: {
    requirement: 'Antigravity 用のローカル LLM統合プラグインを開発する',
    constraints: { budget_days: 10, team_size: 2 },
  },
});
 
console.log(result);

// ❌ 悪い例：固定タイムアウト
const agent = new Agent({
  timeoutMs: 30000, // すべての実行で 30秒
});
 
// ✅ 良い例：適応的なタイムアウト
class AdaptiveAgent {
  private baseTimeoutMs = 30000;
  private currentWorkflowStartTime = 0;
  
  async execute(input: any, workflowDeadlineMs: number) {
    const elapsedMs = Date.now() - this.currentWorkflowStartTime;
    const remainingMs = workflowDeadlineMs - elapsedMs;
    const timeoutMs = Math.min(this.baseTimeoutMs, Math.max(remainingMs - 5000, 5000));
    
    return agent.execute(input, { timeoutMs });
  }
}

// ❌ 危険：判定が曖昧で、いつ終わるか不明
const judgmentAgent = new Agent({
  systemPrompt: 'Determine if the information is reliable.',
  maxIterations: 10, // デフォルトだと 10 回まで思考
});
 
// ✅ 安全：判定が明確で、終了条件がある
const judgmentAgent = new Agent({
  systemPrompt: `Determine if the information is reliable.
Output ONLY valid JSON:
{
  "is_reliable": true | false,
  "confidence": 0.0 to 1.0,
  "reasoning": "..."
}
You MUST output JSON in exactly this format. Do not think further once JSON is output.`,
  maxIterations: 3, // 複雑な判定は 3 回あれば十分
});

import { Agent, RateLimiter } from '@google-cloud/agentkit';
 
// グローバル rate limiter
const rateLimiter = new RateLimiter({
  maxRequests: 100,
  windowMs: 60000, // 1 分間に 100 リクエストまで
});
 
const agent = new Agent({
  name: 'search_agent',
  rateLimiter, // 全 API 呼び出しをこの limiter で統制
  tools: ['google_search'],
});

// ✅ Fallback 付きパース
function safeJsonParse(output: string) {
  try {
    return JSON.parse(output);
  } catch (e) {
    // JSON 風のテキストを抽出
    const match = output.match(/\{[\s\S]*\}/);
    if (match) {
      try {
        return JSON.parse(match[0]);
      } catch (e2) {
        // 最終手段：出力をそのまま返す（後続で適切にハンドル）
        return { raw_output: output, parse_error: true };
      }
    }
    throw new Error('Failed to parse agent output');
  }
}

// コスト追跡
interface CostTracker {
  completionTokens: number;
  promptTokens: number;
  costUsd: number;
  estimatedCostUsd: number; // 現在のレート×累計
}
 
const tracker: CostTracker = { completionTokens: 0, promptTokens: 0, costUsd: 0, estimatedCostUsd: 0 };
 
const coordinator = new Coordinator({
  workflows: { /* ... */ },
  onAgentComplete: (result) => {
    const { tokens } = result.usage;
    tracker.completionTokens += tokens.completion;
    tracker.promptTokens += tokens.prompt;
    
    // Gemini 1.5 Pro: $7.50/M prompts, $30/M completions
    const costUsd = (tokens.prompt * 7.50 + tokens.completion * 30) / 1_000_000;
    tracker.costUsd += costUsd;
    tracker.estimatedCostUsd = tracker.costUsd * 1.2; // 20% buffer
    
    // コスト上限に達したら停止
    if (tracker.estimatedCostUsd > 100) {
      console.warn('Cost limit approaching, halting...');
      return { action: 'halt' };
    }
  },
});

// 完全なイベントログ
const debuggingWorkflow = new Workflow({
  /* ... */
  onEdgeTransition: (from, to, data) => {
    console.log(`[TRACE] ${from} -> ${to}`);
    console.log(`[OUTPUT] ${JSON.stringify(data, null, 2)}`);
  },
  onAgentStart: (agentName, input) => {
    console.log(`[AGENT START] ${agentName} at ${new Date().toISOString()}`);
    console.log(`[INPUT] ${JSON.stringify(input)}`);
  },
  onAgentError: (agentName, error) => {
    console.error(`[AGENT ERROR] ${agentName}`);
    console.error(error.stack);
  },
});
 
const result = await debuggingWorkflow.execute(input);

const traces: Array<{
  agent: string;
  startTime: number;
  endTime: number;
  durationMs: number;
  tokensUsed: number;
}> = [];
 
coordinator.onAgentComplete = (result) => {
  traces.push({
    agent: result.agent,
    startTime: result.startTime,
    endTime: result.endTime,
    durationMs: result.endTime - result.startTime,
    tokensUsed: result.usage.tokens.total,
  });
};
 
// 実行後の分析
function analyzeBottleneck() {
  const totalMs = Math.max(...traces.map(t => t.endTime)) - Math.min(...traces.map(t => t.startTime));
  const parallelizableMs = traces.reduce((acc, t) => acc + t.durationMs, 0) - totalMs;
  console.log(`Total: ${totalMs}ms, Parallelizable: ${parallelizableMs}ms`);
}

// Antigravity 統合ログ
coordinator.onAgentStart = (agent) => {
  // Manager Surface に「〇〇 Agent が起動」と表示
  console.log(`[🚀 AGENT START] ${agent} running on Antigravity Manager...`);
};

const mixedWorkflow = new Workflow({
  agents: {
    research: researchAgent, // AgentKit Agent
    browser_check: new BrowserAgent({ // Antigravity 統組込みの Browser Agent
      task: 'Check GitHub Actions deployment status',
    }),
    summary: summaryAgent,
  },
  edges: [
    new Edge('research', 'browser_check'),
    new Edge('browser_check', 'summary'),
  ],
});