Google Antigravity × A2Aプロトコル連携ガイド｜エージェント間通信の実装と活用【2026年版】

「AntigravityでA2Aプロトコルを使うにはどうすればいい？」「複数のAIエージェントを連携させたい」「A2Aってそもそも何なの？」

A2A（Agent-to-Agent）プロトコルは、Googleが提唱する異なるAIエージェント間の標準通信仕様です。 Google Antigravityは、A2Aプロトコルのネイティブサポートにより、Claude Code、Codex CLI、OpenClawなど他のAIツールとシームレスに連携できます。

この記事では、Google Antigravity完全攻略シリーズEp.55として、A2Aプロトコルの基礎から実践的な連携パターンまでを徹底解説します。

A2Aプロトコルとは？エージェント間通信の新標準

A2Aプロトコルの基本概念

A2A（Agent-to-Agent）プロトコルは、GoogleがCloud Next 2025で発表したオープンなエージェント間通信の標準仕様です。MCPがエージェントとツール間の通信を標準化したのに対し、A2Aはエージェント同士の通信を標準化します。

MCP（Model Context Protocol）:
  エージェント ←→ ツール/データソース

A2A（Agent-to-Agent Protocol）:
  エージェント ←→ エージェント

A2Aの主要コンセプト

A2Aプロトコルは以下の核心的な概念で構成されています：

1. Agent Card（エージェントカード）

各エージェントの能力とインターフェースを記述するメタデータ。他のエージェントが発見・理解できるように公開されます。

{
  "name": "CodeReviewAgent",
  "description": "TypeScript/JavaScriptのコードレビューを行うエージェント",
  "url": "https://agent.example.com/code-review",
  "version": "2.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "typescript-review",
      "name": "TypeScriptコードレビュー",
      "description": "型安全性、パフォーマンス、セキュリティの観点でレビュー",
      "inputModes": ["text/plain", "application/typescript"],
      "outputModes": ["text/plain", "application/json"]
    }
  ]
}

2. Task（タスク）

エージェント間で委譲される作業単位。ライフサイクル管理が組み込まれています。

{
  "id": "task-001",
  "status": "working",
  "message": {
    "role": "user",
    "parts": [
      {
        "type": "text",
        "text": "src/controllers/auth.tsのセキュリティレビューを行ってください"
      }
    ]
  },
  "artifacts": []
}

3. Artifact（成果物）

タスクの完了時に生成される出力。テキスト、ファイル、構造化データなどさまざまな形式をサポートします。

{
  "name": "review-result",
  "parts": [
    {
      "type": "text",
      "text": "## レビュー結果\n- SQLインジェクション脆弱性が2箇所検出...\n"
    },
    {
      "type": "data",
      "data": {
        "severity": "high",
        "issues_found": 2,
        "files_reviewed": 1
      }
    }
  ]
}

A2Aプロトコルのフロー

1. 発見（Discovery）
   クライアント → /.well-known/agent.json → エージェントのAgent Cardを取得

2. タスク作成（Task Creation）
   クライアント → POST /tasks/send → タスクを作成・送信

3. 処理（Processing）
   エージェント → タスクを受信 → 内部処理

4. 進捗報告（Status Update）
   エージェント → SSE/Webhook → 進捗を通知

5. 完了（Completion）
   エージェント → Artifactを含む完了レスポンスを返却

AntigravityでのA2A実装

A2Aサーバーの構築

Antigravityプロジェクト内で、他のエージェントからの要求を受け付けるA2Aサーバーを構築します。

// a2a-server.ts
import { A2AServer, AgentCard, TaskHandler } from '@google/a2a-sdk';

const agentCard: AgentCard = {
  name: 'AntigravityDevAgent',
  description: 'フルスタック開発タスクを実行するAntigravityエージェント',
  url: 'http://localhost:3100',
  version: '1.0',
  capabilities: {
    streaming: true,
    pushNotifications: true,
    stateTransitions: true
  },
  skills: [
    {
      id: 'code-generation',
      name: 'コード生成',
      description: 'TypeScript/Python/Goのコード生成',
      inputModes: ['text/plain'],
      outputModes: ['text/plain', 'application/json']
    },
    {
      id: 'test-generation',
      name: 'テスト生成',
      description: 'ユニットテスト・E2Eテストの自動生成',
      inputModes: ['text/plain', 'application/typescript'],
      outputModes: ['text/plain']
    }
  ]
};

const taskHandler: TaskHandler = async (task) => {
  const skillId = task.metadata?.skillId || 'code-generation';

  switch (skillId) {
    case 'code-generation':
      return await handleCodeGeneration(task);
    case 'test-generation':
      return await handleTestGeneration(task);
    default:
      throw new Error(`Unknown skill: ${skillId}`);
  }
};

const server = new A2AServer({
  agentCard,
  taskHandler,
  port: 3100
});

server.start();
console.log('A2A Server running on port 3100');

A2Aクライアントとしての利用

AntigravityのA2Aクライアントは、他のエージェントにタスクを委譲します。

// a2a-client.ts
import { A2AClient } from '@google/a2a-sdk';

// エージェントの発見
const client = new A2AClient();
const reviewAgent = await client.discover('https://review-agent.example.com');

console.log('発見したエージェント:', reviewAgent.name);
console.log('提供スキル:', reviewAgent.skills.map(s => s.name));

// タスクの送信
const task = await client.sendTask(reviewAgent.url, {
  message: {
    role: 'user',
    parts: [
      {
        type: 'text',
        text: 'src/controllers/order.ts のパフォーマンスレビューをお願いします'
      },
      {
        type: 'file',
        file: {
          name: 'order.ts',
          mimeType: 'application/typescript',
          bytes: btoa(await readFile('src/controllers/order.ts', 'utf8'))
        }
      }
    ]
  },
  metadata: {
    skillId: 'performance-review',
    priority: 'high'
  }
});

// ストリーミングで結果を受信
for await (const update of client.streamTask(task.id)) {
  if (update.status === 'working') {
    console.log('進捗:', update.message?.parts[0]?.text);
  } else if (update.status === 'completed') {
    console.log('完了:', update.artifacts);
    break;
  }
}

Antigravity設定ファイルでのA2A連携

# .antigravity/config.yaml
a2a:
  server:
    enabled: true
    port: 3100
    auth:
      type: bearer
      token: ${A2A_AUTH_TOKEN}

  agents:
    - name: code-reviewer
      url: https://review-agent.example.com
      auth:
        type: bearer
        token: ${REVIEW_AGENT_TOKEN}
      skills:
        - typescript-review
        - security-audit

    - name: test-generator
      url: https://test-agent.example.com
      skills:
        - unit-test
        - e2e-test

    - name: doc-generator
      url: https://doc-agent.example.com
      skills:
        - api-docs
        - readme-generation

マルチエージェントワークフローの設計パターン

パターン1: パイプライン型（Sequential）

各エージェントが順番にタスクを処理し、結果を次のエージェントに渡します。

// pipeline-workflow.ts
async function developmentPipeline(requirement: string) {
  // Step 1: 設計エージェントがアーキテクチャを設計
  const designResult = await a2aClient.sendTask(designAgent, {
    message: { parts: [{ type: 'text', text: `要件: ${requirement}` }] },
    metadata: { skillId: 'architecture-design' }
  });

  // Step 2: コーディングエージェントが実装
  const codeResult = await a2aClient.sendTask(codingAgent, {
    message: {
      parts: [
        { type: 'text', text: '以下の設計に基づいて実装してください' },
        ...designResult.artifacts[0].parts
      ]
    },
    metadata: { skillId: 'code-generation' }
  });

  // Step 3: テストエージェントがテストを生成・実行
  const testResult = await a2aClient.sendTask(testAgent, {
    message: {
      parts: [
        { type: 'text', text: '以下のコードのテストを生成して実行してください' },
        ...codeResult.artifacts[0].parts
      ]
    },
    metadata: { skillId: 'test-generation' }
  });

  // Step 4: レビューエージェントが最終チェック
  const reviewResult = await a2aClient.sendTask(reviewAgent, {
    message: {
      parts: [
        { type: 'text', text: 'コードとテスト結果をレビューしてください' },
        ...codeResult.artifacts[0].parts,
        ...testResult.artifacts[0].parts
      ]
    },
    metadata: { skillId: 'code-review' }
  });

  return { designResult, codeResult, testResult, reviewResult };
}

パターン2: 並列分散型（Fan-out/Fan-in）

複数のエージェントに同時にタスクを割り振り、結果を統合します。

// parallel-workflow.ts
async function parallelCodeReview(files: string[]) {
  // 複数ファイルを並列でレビュー
  const reviewTasks = files.map(file =>
    a2aClient.sendTask(reviewAgent, {
      message: {
        parts: [
          { type: 'text', text: `${file}をレビューしてください` },
          { type: 'file', file: { name: file, bytes: readFileSync(file) } }
        ]
      }
    })
  );

  // 全結果を待機
  const results = await Promise.all(reviewTasks);

  // 結果を統合
  const summary = await a2aClient.sendTask(summaryAgent, {
    message: {
      parts: [
        { type: 'text', text: '以下のレビュー結果を統合してサマリーを作成してください' },
        ...results.flatMap(r => r.artifacts[0].parts)
      ]
    }
  });

  return summary;
}

パターン3: 監督・委譲型（Supervisor）

監督エージェントがタスクを分析し、適切なワーカーエージェントに委譲します。

// supervisor-workflow.ts
async function supervisorWorkflow(userRequest: string) {
  // 監督エージェントがタスクを分析
  const analysis = await a2aClient.sendTask(supervisorAgent, {
    message: {
      parts: [{
        type: 'text',
        text: `以下のリクエストを分析して、必要なサブタスクに分解してください: ${userRequest}`
      }]
    },
    metadata: { skillId: 'task-decomposition' }
  });

  const subtasks = JSON.parse(analysis.artifacts[0].parts[0].data);

  // 各サブタスクを適切なエージェントに委譲
  const results = [];
  for (const subtask of subtasks) {
    const agent = selectAgent(subtask.type);
    const result = await a2aClient.sendTask(agent, {
      message: { parts: [{ type: 'text', text: subtask.description }] },
      metadata: { skillId: subtask.skillId }
    });
    results.push(result);
  }

  // 監督エージェントが結果を統合・品質チェック
  const finalResult = await a2aClient.sendTask(supervisorAgent, {
    message: {
      parts: [
        { type: 'text', text: '全サブタスクの結果を統合して品質チェックしてください' },
        ...results.flatMap(r => r.artifacts[0].parts)
      ]
    },
    metadata: { skillId: 'quality-assurance' }
  });

  return finalResult;
}

A2Aセキュリティとアクセス制御

認証・認可の設計

// a2a-auth.ts
import { A2AServer, AuthMiddleware } from '@google/a2a-sdk';

const authMiddleware: AuthMiddleware = async (request) => {
  const token = request.headers.get('Authorization')?.replace('Bearer ', '');

  if (!token) {
    throw new Error('認証トークンが必要です');
  }

  // トークン検証
  const claims = await verifyToken(token);

  // スキルベースのアクセス制御
  const requestedSkill = request.metadata?.skillId;
  if (!claims.allowedSkills.includes(requestedSkill)) {
    throw new Error(`スキル ${requestedSkill} へのアクセス権がありません`);
  }

  return claims;
};

const server = new A2AServer({
  agentCard,
  taskHandler,
  auth: authMiddleware,
  rateLimit: {
    maxRequests: 100,
    windowMs: 60000  // 1分あたり100リクエスト
  }
});

通信の暗号化

# .antigravity/a2a-security.yaml
security:
  transport:
    tls:
      enabled: true
      minVersion: "TLSv1.3"

  authentication:
    type: mutual-tls
    clientCert: /path/to/client.pem
    clientKey: /path/to/client-key.pem
    caCert: /path/to/ca.pem

  audit:
    enabled: true
    logDestination: /var/log/a2a/audit.log
    logLevel: info

SES現場でのA2A活用事例

事例1: 大規模マイグレーションプロジェクト

レガシーJavaシステムからTypeScriptへの移行を、A2Aで連携する複数エージェントで実行しました。

Antigravity（コーディネーター）
├── Java解析エージェント → コード構造の分析
├── TypeScript変換エージェント → コード変換
├── テストエージェント → テスト生成・実行
└── ドキュメントエージェント → 差分ドキュメント生成

成果：

• 移行期間を6ヶ月→2ヶ月に短縮
• コード変換の精度95%以上
• テストカバレッジ80%を自動達成

事例2: 24時間監視体制のDevOps

A2Aで連携するエージェント群により、24時間のシステム監視と自動対応を実現しました。

成果：

• インシデント対応時間を平均30分→5分に短縮
• 夜間の人員配置を3人→0人に削減
• 障害の自動復旧率75%を達成

事例3: マルチベンダー連携

異なるSES企業が担当するマイクロサービス間の連携テストを、各社のAIエージェントがA2Aで通信して自動化しました。

成果：

• 結合テストの準備時間を1日→2時間に短縮
• 企業間のAPI仕様齟齬を早期発見
• コミュニケーションコストを60%削減

まとめ: A2Aプロトコルがもたらす未来

A2Aプロトコルは、AIエージェントの世界に「標準化された協力関係」をもたらします。Google Antigravityのネイティブサポートにより、以下が実現可能です：

• ツール非依存: Claude Code、Codex CLI、Antigravity等を自由に組み合わせ
• スケーラブル: エージェントの追加・交換が容易
• セキュア: 標準化された認証・認可フレームワーク
• オブザーバブル: タスクのライフサイクル全体を追跡可能

SESエンジニアとして、A2Aプロトコルの理解と実装スキルは、マルチエージェント開発の時代において大きな差別化要因になります。

関連記事

• Google Antigravity使い方入門ガイド
• Antigravityマルチエージェント開発ガイド
• Antigravity ADKエージェント開発ガイド
• Antigravity API連携ガイド
• Antigravity Geminiモデル選択ガイド