第15章：Inter-Agent Communication (A2A)

单个 AI Agent 在应对复杂的、多方面的问题时，往往面临局限性，即使具备先进的能力也不例外。为了克服这一点，Inter-Agent Communication（A2A）使不同的 AI Agent（可能使用不同的框架构建）能够有效地协作。这种协作涉及无缝的协调、任务委派和信息交换。

Google 的 A2A 协议是一个开放标准，旨在促进这种通用通信。本章将探讨 A2A、其实际应用，以及它在 Google ADK 中的实现。

Inter-Agent Communication 模式概述

Agent2Agent（A2A）协议是一个开放标准，旨在实现不同 AI Agent 框架之间的通信与协作。它确保了互操作性，允许使用 LangGraph、CrewAI 或 Google ADK 等技术开发的 AI Agent 协同工作，无论其来源或框架差异如何。

A2A 得到了一系列技术公司和服务提供商的支持，包括 Atlassian、Box、LangChain、MongoDB、Salesforce、SAP 和 ServiceNow。Microsoft 计划将 A2A 集成到 Azure AI Foundry 和 Copilot Studio 中，展示了其对开放协议的承诺。此外，Auth0 和 SAP 正在将其平台中的 A2A 支持集成到其平台和 Agent 中。

作为一个开源协议，A2A 欢迎社区贡献，以促进其演进和广泛采用。

A2A 的核心概念

A2A 协议为 Agent 交互提供了结构化的方法，建立在几个核心概念之上。深入掌握这些概念对于任何开发或集成 A2A 兼容系统的人来说都至关重要。A2A 的基石包括核心参与者（Core Actors）、Agent Card、Agent 发现（Agent Discovery）、通信与任务（Communications and Tasks）、交互机制（Interaction mechanisms）和安全性（Security），所有这些都将被详细审查。

核心参与者（Core Actors）：A2A 涉及三个主要实体：

用户（User）：发起 Agent 协助请求。
A2A 客户端（Client Agent）：代表用户行动、请求操作或信息的应用程序或 AI Agent。
A2A 服务器（Remote Agent）：提供 HTTP 端点以处理客户端请求并返回结果的 AI Agent 或系统。远程 Agent 作为一个"不透明"（opaque）系统运行，这意味着客户端不需要理解其内部操作细节。

Agent Card（Agent 卡片）：一个 Agent 的数字身份由其 Agent Card 定义，通常是一个 JSON 文件。该文件包含用于客户端交互和自动发现的关键信息，包括 Agent 的身份、端点 URL 和版本。它还详细说明了支持的功能（如流式传输或推送通知）、特定技能、默认输入/输出模式以及身份验证要求。以下是 WeatherBot 的 Agent Card 示例：

json

{
  "name": "WeatherBot",
  "description": "Provides accurate weather forecasts and historical data.",
  "url": "http://weather-service.example.com/a2a",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "authentication": {
    "schemes": [
      "apiKey"
    ]
  },
  "defaultInputModes": [
    "text"
  ],
  "defaultOutputModes": [
    "text"
  ],
  "skills": [
    {
      "id": "get_current_weather",
      "name": "Get Current Weather",
      "description": "Retrieve real-time weather for any location.",
      "inputModes": [
        "text"
      ],
      "outputModes": [
        "text"
      ],
      "examples": [
        "What's the weather in Paris?",
        "Current conditions in Tokyo"
      ],
      "tags": [
        "weather",
        "current",
        "real-time"
      ]
    },
    {
      "id": "get_forecast",
      "name": "Get Forecast",
      "description": "Get 5-day weather predictions.",
      "inputModes": [
        "text"
      ],
      "outputModes": [
        "text"
      ],
      "examples": [
        "5-day forecast for New York",
        "Will it rain in London this weekend?"
      ],
      "tags": [
        "weather",
        "forecast",
        "prediction"
      ]
    }
  ]
}

Agent 发现（Agent discovery）：它允许客户端找到描述可用 A2A 服务器功能的 Agent Card。这一过程有几种策略：

Well-Known URI（知名 URI）：Agent 将其 Agent Card 托管在一个标准化路径（例如 /.well-known/agent.json）。这种方法为公共或特定领域的用途提供了广泛的、通常是自动化的可访问性。
Curated Registries（精选注册表）：这些提供了一个集中式目录，Agent Card 在其中发布，并可以根据特定条件进行查询。这非常适合需要集中管理和访问控制的企业环境。
Direct Configuration（直接配置）：Agent Card 信息被嵌入或私下共享。这种方法适用于耦合紧密或私有系统，其中动态发现并不关键。

无论选择哪种方法，重要的是保护 Agent Card 端点。这可以通过访问控制、双向 TLS（mTLS）或网络限制来实现，特别是当卡片包含敏感（尽管非秘密）信息时。

通信与任务（Communications and Tasks）：在 A2A 框架中，通信围绕异步任务构建，这些任务代表长时间运行过程的基本工作单元。每个任务都被分配一个唯一的标识符，并经历一系列状态——如 submitted、working 或 completed——这种设计支持复杂操作中的并行处理。Agent 之间的通信通过消息（Message）进行。

这种通信包含属性（attributes），即描述消息的键值元数据（如其优先级或创建时间），以及一个或多个部分（parts），它们携带被传递的实际内容，例如纯文本、文件或结构化 JSON 数据。Agent 在任务期间生成的有形输出称为工件（artifacts）。与消息一样，工件也由一个或多个部分组成，并且可以随着结果的可用而被增量流式传输。A2A 框架内的所有通信都通过 HTTP(S) 使用 JSON-RPC 2.0 协议进行负载传输。为了在多次交互中保持连续性，使用服务器生成的 contextId 来对相关任务进行分组并保留上下文。

交互机制（Interaction Mechanisms）：Request/Response（轮询）、Server-Sent Events（SSE）。A2A 提供了多种交互方法以适应各种 AI 应用需求，每种方法都有独特的机制：

同步请求/响应（Synchronous Request/Response）：适用于快速、即时的操作。在这个模型中，客户端发送一个请求，并主动等待服务器处理它，并在单个同步交换中返回一个完整的响应。
异步轮询（Asynchronous Polling）：适用于需要较长时间处理的任务。客户端发送一个请求，服务器立即以 "working" 状态和任务 ID 确认。然后，客户端可以自由执行其他操作，并可以通过发送新请求 periodically 轮询服务器以检查任务状态，直到它被标记为 "completed" 或 "failed"。
流式更新（Streaming Updates，Server-Sent Events - SSE）： ideal for receiving real-time, incremental results. This method establishes a persistent, one-way connection from the server to the client. It allows the remote agent to continuously push updates, such as status changes or partial results, without the client needing to make multiple requests.
推送通知（Push Notifications，Webhooks）：专为长时间运行或资源密集型任务而设计，在这种情况下保持恒定连接或频繁轮询效率低下。客户端可以注册一个 webhook URL，服务器将在任务状态发生重大变化时（例如在完成时）向该 URL 发送异步通知（"推送"）。

Agent Card 指定了一个 Agent 是否支持流式传输或推送通知功能。此外，A2A 是与模态无关的（modality-agnostic），这意味着它不仅可以促进文本的这些交互模式，还可以促进其他数据类型（如音频和视频）的交互，从而实现丰富的、多模态的 AI 应用。流式传输和推送通知功能都在 Agent Card 中指定。

同步请求示例：

json

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "sendTask",
  "params": {
    "id": "task-001",
    "sessionId": "session-001",
    "message": {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "What is the exchange rate from USD to EUR?"
        }
      ]
    },
    "acceptedOutputModes": ["text/plain"],
    "historyLength": 5
  }
}

同步请求使用 sendTask 方法，客户端在其中请求并期望对其查询做出单个、完整的回答。相比之下，流式请求使用 sendTaskSubscribe 方法来建立持久连接，允许 Agent 随着时间的推移发回多个、增量的更新或部分结果。

流式请求示例：

json

{
  "jsonrpc": "2.0",
  "id": "2",
  "method": "sendTaskSubscribe",
  "params": {
    "id": "task-002",
    "sessionId": "session-001",
    "message": {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "What's the exchange rate for JPY to GBP today?"
        }
      ]
    },
    "acceptedOutputModes": ["text/plain"],
    "historyLength": 5
  }
}

安全性：Inter-Agent Communication（A2A）：Inter-Agent Communication（A2A）是系统架构的重要组成部分，实现了 Agent 之间安全无缝的数据交换。它通过几个内置机制确保稳健性和完整性。

双向传输层安全性（Mutual TLS）：建立加密和经过身份验证的连接，以防止未经授权的访问和数据拦截，确保安全通信。

全面的审计日志（Comprehensive Audit Logs）：所有 Agent 间通信都被细致地记录，详述信息流、涉及的 Agent 和操作。这个审计线索对于问责制、故障排除和安全分析至关重要。

Agent Card 声明（Agent Card Declaration）：身份验证要求在 Agent Card 中明确声明，Agent Card 是一个概述 Agent 身份、功能和安全策略的配置工件。这集中并简化了身份验证管理。

凭证处理（Credential Handling）：Agent 通常使用安全凭证（如 OAuth 2.0 令牌或 API 密钥）进行身份验证，这些凭证通过 HTTP 头传递。这种方法防止了凭证在 URL 或消息体中的暴露，增强了整体安全性。

A2A vs. MCP

A2A 是一个对 Anthropic 的 Model Context Protocol（MCP）形成补充的协议（见图1）。MCP 专注于为 Agent 及其与外部数据和工具的交互构建上下文，而 A2A 促进 Agent 之间的协调和通信，实现任务委派和协作。

图1：A2A 和 MCP 协议对比

A2A 的目标是提高效率，降低集成成本，并促进复杂、多 Agent AI 系统开发中的创新和互操作性。因此，深入理解 A2A 的核心组件和操作方法，对于有效设计、实现和应用以构建协作且可互操作的 AI Agent 系统至关重要。

实际应用与用例

Inter-Agent Communication 对于在各个领域构建复杂的 AI 解决方案必不可少，实现了模块化、可扩展性和增强的智能。

多框架协作（Multi-Framework Collaboration）：A2A 的主要用例是使独立的 AI Agent（无论其底层框架如何，例如 ADK、LangChain、CrewAI）能够进行通信和协作。这对于构建复杂的多 Agent 系统至关重要，其中不同的 Agent 专注于问题的不同方面。
自动化工作流编排（Automated Workflow Orchestration）：在企业环境中，A2A 可以通过使 Agent 能够委派和协调任务来促进复杂的工作流。例如，一个 Agent 可能处理初始数据收集，然后将分析委派给另一个 Agent，最后将报告生成委派给第三个 Agent，所有这些都通过 A2A 协议进行通信。
动态信息检索（Dynamic Information Retrieval）：Agent 可以通过通信来检索和交换实时信息。一个主 Agent 可能从专门的"数据获取 Agent"请求实时市场数据，然后该 Agent 使用外部 API 收集信息并将其发回。

动手代码示例

让我们来研究 A2A 协议的实际应用。位于 https://github.com/google-a2a/a2a-samples/tree/main/samples 的存储库提供了 Java、Go 和 Python 中的示例，说明了各种 Agent 框架（如 LangGraph、CrewAI、Azure AI Foundry 和 AG2）如何使用 A2A 进行通信。此存储库中的所有代码均在 Apache 2.0 许可下发布。为了进一步说明 A2A 的核心概念，我们将审查专注于使用具有 Google 身份验证工具的基于 ADK 的 Agent 设置 A2A 服务器的代码片段。请参阅 https://github.com/google-a2a/a2a-samples/blob/main/samples/python/agents/birthday_planner_adk/calendar_agent/adk_agent.py

python

import datetime
from google.adk.agents import LlmAgent  # type: ignore[import-untyped]
from google.adk.tools.google_api_tool import CalendarToolset  # type: ignore[import-untyped]

async def create_agent(client_id, client_secret) -> LlmAgent:
    """Constructs the ADK agent."""
    toolset = CalendarToolset(client_id=client_id, client_secret=client_secret)
    return LlmAgent(
        model='gemini-2.0-flash-001',
        name='calendar_agent',
        description="An agent that can help manage a user's calendar",
        instruction=f"""
You are an agent that can help manage a user's calendar.
Users will request information about the state of their calendar or to make changes to their calendar. Use the provided tools for interacting with the calendar API.

If not specified, assume the calendar the user wants is the 'primary' calendar.
When using the Calendar API tools, use well-formed RFC3339 timestamps.
Today is {datetime.datetime.now()}.
""",
        tools=await toolset.get_tools(),
    )

这段 Python 代码定义了一个异步函数 create_agent，它构造了一个 ADK LlmAgent。它首先使用提供的客户端凭证初始化一个 CalendarToolset 以访问 Google Calendar API。随后，创建一个 LlmAgent 实例，配置了指定的 Gemini 模型、描述性名称和用于管理用户日历的指令。该 Agent 配备了来自 CalendarToolset 的日历工具，使其能够与 Calendar API 交互，并回应用户关于日历状态或修改的查询。Agent 的指令动态地结合了当前日期作为时间上下文。为了说明如何构建 Agent，让我们检查 GitHub 上 A2A 示例中找到的 calendar_agent 的一个关键部分。

下面的代码展示了如何使用其特定指令和工具来定义 Agent。请注意，仅显示了解释此功能所需的代码；您可以在此处访问完整文件：https://github.com/a2aproject/a2a-samples/blob/main/samples/python/agents/birthday_planner_adk/calendar_agent/__main__.py

python

def main(host: str, port: int):
    # Verify an API key is set.
    # Not required if using Vertex AI APIs.
    if os.getenv('GOOGLE_GENAI_USE_VERTEXAI') != 'TRUE' and not os.getenv('GOOGLE_API_KEY'):
        raise ValueError(
            'GOOGLE_API_KEY environment variable not set and GOOGLE_GENAI_USE_VERTEXAI is not TRUE.'
        )

    skill = AgentSkill(
        id='check_availability',
        name='Check Availability',
        description="Checks a user's availability for a time using their Google Calendar",
        tags=['calendar'],
        examples=['Am I free from 10am to 11am tomorrow?'],
    )

    agent_card = AgentCard(
        name='Calendar Agent',
        description="An agent that can manage a user's calendar",
        url=f'http://{host}:{port}/',
        version='1.0.0',
        defaultInputModes=['text'],
        defaultOutputModes=['text'],
        capabilities=AgentCapabilities(streaming=True),
        skills=[skill],
    )

    adk_agent = asyncio.run(create_agent(
        client_id=os.getenv('GOOGLE_CLIENT_ID'),
        client_secret=os.getenv('GOOGLE_CLIENT_SECRET'),
    ))

    runner = Runner(
        app_name=agent_card.name,
        agent=adk_agent,
        artifact_service=InMemoryArtifactService(),
        session_service=InMemorySessionService(),
        memory_service=InMemoryMemoryService(),
    )

    agent_executor = ADKAgentExecutor(runner, agent_card)

    async def handle_auth(request: Request) -> PlainTextResponse:
        await agent_executor.on_auth_callback(
            str(request.query_params.get('state')), str(request.url)
        )
        return PlainTextResponse('Authentication successful.')

    request_handler = DefaultRequestHandler(
        agent_executor=agent_executor, task_store=InMemoryTaskStore()
    )

    a2a_app = A2AStarletteApplication(
        agent_card=agent_card, http_handler=request_handler
    )

    routes = a2a_app.routes()
    routes.append(
        Route(
            path='/authenticate',
            methods=['GET'],
            endpoint=handle_auth,
        )
    )

    app = Starlette(routes=routes)
    uvicorn.run(app, host=host, port=port)

if __name__ == '__main__':
    main()

这段 Python 代码演示了如何设置一个符合 A2A 的"Calendar Agent"，用于使用 Google Calendar 检查用户的可用性。它涉及验证 API 密钥或 Vertex AI 配置以进行身份验证。Agent 的功能，包括 "check_availability" 技能，在 AgentCard 中定义，该卡片还指定了 Agent 的网络地址。随后，创建一个 ADK Agent，配置了内存中的服务用于管理工件、会话和内存。代码然后初始化一个 Starlette Web 应用，纳入一个身份验证回调和 A2A 协议处理程序，并使用 Uvicorn 执行它以通过 HTTP 暴露 Agent。

这些示例说明了构建符合 A2A 的 Agent 的过程，从定义其功能到将其作为 Web 服务运行。通过利用 Agent Card 和 ADK，开发人员可以创建能够集成 Google Calendar 等工具的互操作 AI Agent。这种实用方法展示了 A2A 在建立多 Agent 生态系统中的应用。

建议通过 https://www.trickle.so/blog/how-to-build-google-a2a-project 的代码演示进一步探索 A2A。此链接提供的资源包括 Python 和 JavaScript 中的示例 A2A 客户端和服务器、多 Agent Web 应用、命令行界面以及各种 Agent 框架的示例实现。

一览（At a Glance）

What（是什么）：单个 AI Agent，尤其是那些构建在不同框架上的 Agent，往往凭借自身应对复杂的、多方面的问题时遇到困难。主要的挑战是缺乏一种通用语言或协议，使它们能够有效地通信和协作。这种隔离阻碍了创建复杂系统的可能性，在这些系统中，多个专门的 Agent 可以结合其独特的技能来解决更大的任务。如果没有一种标准化的方法，集成这些不同的 Agent 成本高昂、耗时，并且阻碍了更强大、更具凝聚力的 AI 解决方案的开发。

Why（为什么）：Inter-Agent Communication（A2A）协议为这个问题提供了一个开放的、标准化的解决方案。它是一个基于 HTTP 的协议，实现了互操作性，允许不同的 AI Agent 无缝地协调、委派任务和共享信息，无论其底层技术如何。一个核心组件是 Agent Card，它是一个数字身份文件，描述了 Agent 的功能、技能 and 通信端点，促进了发现和交互。A2A 定义了各种交互机制，包括同步和异步通信，以支持多样化的用例。通过为 Agent 协作创建通用标准，A2A 培育了一个模块化和可扩展的生态系统，用于构建复杂的、多 Agent 的 Agentic 系统。

Rule of thumb（经验法则）：当您需要编排两个或多个 AI Agent 之间的协作时，使用此模式，特别是如果它们是使用不同框架（例如 Google ADK、LangGraph、CrewAI）构建的。它非常适合构建复杂的、模块化的应用，其中专门的 Agent 处理工作流的特定部分，例如将一个 Agent 的数据分析委派给另一个 Agent，并将报告生成委派给第三个 Agent。当一个 Agent 需要动态发现和使用其他 Agent 的功能来完成任务时，这种模式也是必不可少的。

Visual summary（视觉摘要）

图2：A2A 内部 Agent 通信模式

关键要点

关键要点：

Google A2A 协议是一个开放的、基于 HTTP 的标准，促进了使用不同框架构建的 AI Agent 之间的通信与协作。
AgentCard 作为 Agent 的数字标识符，允许其他 Agent 自动发现并理解其功能。
A2A 提供同步请求-响应交互（使用 tasks/send）和流式更新（使用 tasks/sendSubscribe），以适应不同的通信需求。
该协议支持多轮对话，包括一个 input-required 状态，允许 Agent 在交互期间请求额外信息并保持上下文。
A2A 鼓励模块化架构，其中专门的 Agent 可以独立地在不同的端口上运行，实现系统的可扩展性和分布式。
诸如 Trickle AI 之类的工具有助于可视化和跟踪 A2A 通信，这帮助开发人员监控、调试和优化多 Agent 系统。
虽然 A2A 是用于管理不同 Agent 之间任务和工作流的高级协议，但 Model Context Protocol（MCP）为 LLM 与外部资源对接提供了标准化接口。

结论

Inter-Agent Communication（A2A）协议建立了一个至关重要的开放标准，以克服单个 AI Agent 固有的隔离性。通过提供一个通用的、基于 HTTP 的框架，它确保了构建在不同平台（如 Google ADK、LangGraph 或 CrewAI）上的 Agent 之间的无缝协作和互操作性。一个核心组件是 Agent Card，它作为数字身份，明确定义了 Agent 的功能，并实现其他 Agent 的动态发现。该协议的灵活性支持各种交互模式，包括同步请求、异步轮询和实时流式传输，满足广泛的應用需求。

这使得创建模块化和可扩展的架构成为可能，其中专门的 Agent 可以被组合以编排复杂的自动化工作流。安全性是一个基本方面，具有内置机制（如 mTLS 和显式的身份验证要求）来保护通信。在与 MCP 等其他标准形成互补的同时，A2A 的独特重点在于 Agent 之间的高级协调和任务委派。主要技术公司的强力支持以及实际实现的可用性突出了其日益增长的重要性。该协议为开发人员铺平了道路，以构建更复杂的、分布式的和智能的多 Agent 系统。最终，A2A 是培育创新且可互操作的协作 AI 生态系统的基石。

参考文献

Chen, B. (2025, April 22). How to Build Your First Google A2A Project: A Step-by-Step Tutorial. Trickle.so Blog. https://www.trickle.so/blog/how-to-build-google-a2a-project
Google A2A GitHub Repository. https://github.com/google-a2a/A2A
Google Agent Development Kit (ADK) https://google.github.io/adk-docs/
Getting Started with Agent-to-Agent (A2A) Protocol: https://codelabs.developers.google.com/intro-a2a-purchasing-concierge#0
Google AgentDiscovery - https://a2a-protocol.org/latest/
Communication between different AI frameworks such as LangGraph, CrewAI, and Google ADK https://www.trickle.so/blog/how-to-build-google-a2a-project
Designing Collaborative Multi-Agent Systems with the A2A Protocol https://www.oreilly.com/radar/designing-collaborative-multi-agent-systems-with-the-a2a-protocol/