A2A 协议深度解析:AI Agent 协作的新纪元

216 阅读6分钟

摘要:本文深入剖析 Google 于 2025 年 4 月发布的 Agent2Agent (A2A) 协议,从协议背景、设计哲学、核心架构、实现细节、应用场景到未来展望,全面解读这一 AI Agent 互操作性的开放标准。


目录

  1. 什么是 A2A 协议
  2. A2A 要解决什么问题
  3. 设计哲学与核心原则
  4. 核心架构与组件
  5. 协议实现详解
  6. Multi-Agent 协作模式
  7. 与其他协议的对比
  8. 应用场景
  9. 未来展望:Agent 协作标准的演进
  10. 总结

什么是 A2A 协议

Agent2Agent (A2A) 是一个开放的通信协议,专为 AI Agent 之间的互操作性而设计。它于 2025 年 4 月由 Google 联合超过 50 家技术合作伙伴(包括 Atlassian、Salesforce、SAP、LangChain 等)共同发布,并于同年捐赠给 Linux 基金会,成为厂商中立的开放标准。

graph TB
    subgraph "A2A 协议定位"
        A[AI Agent A<br/>Claude/GPT]
        B[AI Agent B<br/>Gemini]
        C[AI Agent C<br/>企业自建Agent]

        A <-->|A2A Protocol| B
        B <-->|A2A Protocol| C
        C <-->|A2A Protocol| A
    end

    subgraph "协议层"
        P1[HTTP/HTTPS]
        P2[JSON-RPC 2.0]
        P3[Server-Sent Events]
    end

    A --- P1
    B --- P2
    C --- P3

    style A fill:#e1f5fe
    style B fill:#fff3e0
    style C fill:#f3e5f5

核心定义

概念说明
协议类型开放的 Agent-to-Agent 通信协议
技术基础HTTP + JSON-RPC 2.0 + SSE
治理机构Linux 基金会
核心理念不透明协作(Opaque Collaboration)

A2A 要解决什么问题

当前 AI Agent 生态的困境

graph LR
    subgraph "问题:Agent 孤岛"
        A1[LangChain Agent]
        A2[AutoGPT Agent]
        A3[企业 Agent A]
        A4[企业 Agent B]

        A1 x--x|无法通信| A2
        A2 x--x|无法通信| A3
        A3 x--x|无法通信| A4
    end

    subgraph "问题:N×M 集成"
        F1[框架 1]
        F2[框架 2]
        F3[框架 3]

        S1[系统 A]
        S2[系统 B]
        S3[系统 C]

        F1 ---|定制集成| S1
        F1 ---|定制集成| S2
        F1 ---|定制集成| S3
        F2 ---|定制集成| S1
        F2 ---|定制集成| S2
        F2 ---|定制集成| S3
        F3 ---|定制集成| S1
        F3 ---|定制集成| S2
        F3 ---|定制集成| S3
    end

    style A1 fill:#ffcdd2
    style A2 fill:#ffcdd2
    style A3 fill:#ffcdd2
    style A4 fill:#ffcdd2

A2A 解决的核心问题

问题现状A2A 解决方案
Agent 孤岛不同框架的 Agent 无法通信统一的通信协议层
N×M 集成复杂度每个 Agent 需要与每个系统单独集成标准化的 Agent Card 发现机制
私有协议锁定企业被锁定在特定厂商生态厂商中立的开放标准
安全边界模糊Agent 协作需要暴露内部状态不透明协作(Opacity)
长任务处理缺乏标准化的异步任务管理完整的任务生命周期管理

核心价值主张

03-value-pyramid.png

设计哲学与核心原则

A2A 协议遵循五大核心设计原则:

1. 拥抱 Agent 原生能力(Embrace Agentic Capabilities)

graph 
    subgraph "传统方式"
        T1[Agent A] -->|结构化 API| T2[中间件] -->|结构化 API| T3[Agent B]
    end

    subgraph "A2A 方式"
        A1[Agent A] <-->|自然语言 + 结构化数据| A2[Agent B]
    end

    style T2 fill:#ffcdd2
    style A1 fill:#c8e6c9
    style A2 fill:#c8e6c9

A2A 允许 Agent 以自然的、非结构化的方式协作,即使它们不共享内存、工具和上下文。

2. 基于现有标准(Build on Existing Standards)

graph 
    subgraph "A2A 技术栈"
        L1[A2A 协议层]
        L2[JSON-RPC 2.0]
        L3[HTTP/HTTPS]
        L4[TCP/IP]
    end

    L1 --> L2 --> L3 --> L4

    subgraph "可选扩展"
        E1[Server-Sent Events<br/>流式响应]
        E2[Push Notifications<br/>Webhook 回调]
        E3[gRPC<br/>高性能场景]
    end

    L1 -.-> E1
    L1 -.-> E2
    L1 -.-> E3

    style L1 fill:#2196f3,color:#fff
    style L2 fill:#64b5f6
    style L3 fill:#90caf9
    style L4 fill:#bbdefb

3. 默认安全(Secure by Default)

sequenceDiagram
    participant C as Client Agent
    participant S as Server Agent

    Note over C,S: 安全认证流程

    C->>S: GET /.well-known/agent.json
    S-->>C: Agent Card (含认证要求)

    C->>C: 分析认证方案

    alt OAuth 2.0
        C->>S: 请求 + Bearer Token
    else API Key
        C->>S: 请求 + X-API-Key Header
    else mTLS
        C->>S: 请求 + 客户端证书
    end

    S->>S: 验证凭证
    S-->>C: 响应

A2A 支持与 OpenAPI 同等的企业级认证授权方案。

4. 支持长任务(Support Long-Running Tasks)

  • 后台任务处理
  • 人机协作(Human-in-the-Loop)审批
  • 流式更新

5. 模态无关(Modality Agnostic)

支持文本、图片、音频、PDF、HTML、JSON 等多种格式。


核心架构与组件

整体架构

graph TB
    subgraph "A2A 协议架构"
        subgraph "Client Agent"
            CA[Agent Logic]
            CC[A2A Client]
        end

        subgraph "Server Agent"
            SA[Agent Logic]
            SC[A2A Server]
            AC[Agent Card]
        end

        subgraph "通信层"
            HTTP[HTTP/HTTPS]
            JSONRPC[JSON-RPC 2.0]
            SSE[Server-Sent Events]
        end

        CA --> CC
        CC <--> HTTP
        HTTP <--> SC
        SC --> SA
        SC --> AC

        CC -.->|流式| SSE
        SSE -.-> SC
    end

    subgraph "核心对象"
        O1[Agent Card<br/>能力描述]
        O2[Task<br/>任务管理]
        O3[Message<br/>消息交换]
        O4[Artifact<br/>产出物]
    end

    AC --- O1
    SA --- O2
    SA --- O3
    SA --- O4

    style CA fill:#e3f2fd
    style SA fill:#e8f5e9
    style O1 fill:#fff9c4
    style O2 fill:#fff9c4
    style O3 fill:#fff9c4
    style O4 fill:#fff9c4

四大核心对象

1. Agent Card(代理卡片)

Agent Card 是 Agent 的"数字名片",以 JSON 格式公开发布,描述 Agent 的身份、能力和连接信息。

{
  "name": "Code Review Agent",
  "description": "专业的代码审查 Agent,支持多种编程语言",
  "url": "https://agent.example.com/",
  "version": "1.0.0",
  "protocolVersion": "0.2.0",
  "provider": {
    "organization": "Example Corp",
    "url": "https://example.com"
  },
  "capabilities": {
    "streaming": true,
    "pushNotifications": true,
    "stateTransitionHistory": true
  },
  "skills": [
    {
      "id": "code_review",
      "name": "Code Review",
      "description": "审查代码质量、安全性和最佳实践",
      "tags": ["code", "review", "security"],
      "inputModes": ["text/plain", "application/json"],
      "outputModes": ["text/plain", "text/markdown"]
    }
  ],
  "securitySchemes": {
    "bearerAuth": {
      "type": "http",
      "scheme": "bearer"
    }
  }
}

2. Task(任务)

stateDiagram-v2
    [*] --> submitted: 创建任务
    submitted --> working: 开始处理
    working --> working: 处理中
    working --> input_required: 需要输入
    working --> auth_required: 需要认证
    input_required --> working: 收到输入
    auth_required --> working: 认证完成
    working --> completed: 成功完成
    working --> failed: 处理失败
    working --> canceled: 用户取消
    submitted --> rejected: 拒绝任务

    completed --> [*]
    failed --> [*]
    canceled --> [*]
    rejected --> [*]

    note right of working: 可发送状态更新<br/>可产生 Artifact
    note right of input_required: Human-in-the-Loop<br/>等待人工输入

3. Message(消息)

消息是 Agent 之间单次交互的载体,包含一个或多个 Part。

graph LR
    subgraph "Message 结构"
        M[Message]
        M --> R[role: user/agent]
        M --> ID[messageId]
        M --> P[parts]

        P --> P1[TextPart]
        P --> P2[FilePart]
        P --> P3[DataPart]
    end

    subgraph "Part 类型"
        P1 --> T1["kind: 'text'<br/>text: '...'"]
        P2 --> T2["kind: 'file'<br/>file: {name, mimeType, bytes/uri}"]
        P3 --> T3["kind: 'data'<br/>data: {type: 'json', data: {...}}"]
    end

4. Artifact(产出物)

Artifact 是 Server Agent 产生的交付物,如文档、图片、代码文件等。

graph TB
    subgraph "Artifact 结构"
        A[Artifact]
        A --> AID[artifactId]
        A --> N[name]
        A --> D[description]
        A --> P[parts]

        P --> P1[Part 1: 代码文件]
        P --> P2[Part 2: 文档]
        P --> P3[Part 3: 图片]
    end

    subgraph "流式产出"
        S1[ArtifactUpdate 1<br/>append: false]
        S2[ArtifactUpdate 2<br/>append: true]
        S3[ArtifactUpdate 3<br/>lastChunk: true]

        S1 --> S2 --> S3
    end

    style S1 fill:#e3f2fd
    style S2 fill:#e3f2fd
    style S3 fill:#c8e6c9

协议实现详解

JSON-RPC 方法

A2A 定义了以下核心 RPC 方法:

graph TB
    subgraph "A2A RPC 方法"
        subgraph "消息发送"
            M1[message/send<br/>发送消息并等待响应]
            M2[message/stream<br/>发送消息并接收流式响应]
        end

        subgraph "任务管理"
            T1[tasks/get<br/>获取任务状态]
            T2[tasks/cancel<br/>取消任务]
            T3[tasks/resubscribe<br/>重新订阅任务流]
        end

        subgraph "推送通知"
            P1[tasks/pushNotification/set<br/>设置推送配置]
            P2[tasks/pushNotification/get<br/>获取推送配置]
        end
    end

    style M1 fill:#e3f2fd
    style M2 fill:#e3f2fd
    style T1 fill:#e8f5e9
    style T2 fill:#e8f5e9
    style T3 fill:#e8f5e9
    style P1 fill:#fff3e0
    style P2 fill:#fff3e0

三种通信模式

模式 1:同步请求/响应

sequenceDiagram
    participant C as Client Agent
    participant S as Server Agent

    C->>S: message/send (JSON-RPC)
    Note right of S: 处理请求...
    S-->>C: Response (Task/Message)

    Note over C,S: 适用于简单、快速的任务

模式 2:流式响应 (SSE)

sequenceDiagram
    participant C as Client Agent
    participant S as Server Agent

    C->>S: message/stream (HTTP POST)
    S-->>C: HTTP 200 + Content-Type: text/event-stream

    loop 流式更新
        S-->>C: data: {"kind": "status-update", ...}
        S-->>C: data: {"kind": "artifact-update", ...}
    end

    S-->>C: data: {"kind": "status-update", "final": true}
    Note over C,S: 连接关闭

    Note over C,S: 适用于需要实时反馈的任务

模式 3:异步推送通知

sequenceDiagram
    participant C as Client Agent
    participant S as Server Agent
    participant W as Webhook (Client)

    C->>S: tasks/pushNotification/set<br/>{taskId, webhookUrl}
    S-->>C: OK

    C->>S: message/send
    S-->>C: Task (working)

    Note right of S: 长时间处理...

    S->>W: POST /webhook<br/>{taskId, state: completed}
    W-->>S: 200 OK

    C->>S: tasks/get {taskId}
    S-->>C: Task (completed) + Artifacts

    Note over C,S: 适用于长时间运行的任务

错误处理

A2A 定义了标准的 JSON-RPC 错误码:

错误码名称说明
-32700Parse errorJSON 解析错误
-32600Invalid Request无效的请求
-32601Method not found方法不存在
-32602Invalid params无效的参数
-32603Internal error内部错误
-32000Task not found任务不存在
-32001Task not cancelable任务无法取消
-32002Push notification not supported不支持推送通知
-32003Unsupported operation不支持的操作

Multi-Agent 协作模式

协作架构

graph TB
    subgraph "Multi-Agent 协作场景"
        U[用户请求]

        subgraph "Orchestrator Agent"
            O[协调者 Agent]
        end

        subgraph "Specialist Agents"
            S1[代码生成 Agent]
            S2[代码审查 Agent]
            S3[测试 Agent]
            S4[部署 Agent]
        end

        U --> O
        O <-->|A2A| S1
        O <-->|A2A| S2
        O <-->|A2A| S3
        O <-->|A2A| S4

        S1 -.->|MCP| T1[GitHub API]
        S2 -.->|MCP| T2[Code Analysis Tool]
        S3 -.->|MCP| T3[Test Runner]
        S4 -.->|MCP| T4[K8s API]
    end

    style O fill:#ff9800,color:#fff
    style S1 fill:#4caf50,color:#fff
    style S2 fill:#2196f3,color:#fff
    style S3 fill:#9c27b0,color:#fff
    style S4 fill:#f44336,color:#fff

协作流程示例

sequenceDiagram
    participant User
    participant Orch as Orchestrator
    participant Coder as Code Agent
    participant Review as Review Agent
    participant Test as Test Agent

    User->>Orch: "开发一个用户认证模块"

    Note over Orch: 分解任务

    Orch->>Coder: message/send<br/>"实现 JWT 认证逻辑"
    Coder-->>Orch: Task (working)
    Coder-->>Orch: Artifact (auth.ts)
    Coder-->>Orch: Task (completed)

    Orch->>Review: message/send<br/>"审查 auth.ts 代码"
    Review-->>Orch: Task (working)
    Review-->>Orch: Message ("发现安全问题...")
    Review-->>Orch: Task (input-required)

    Orch->>Coder: message/send<br/>"修复安全问题"
    Coder-->>Orch: Artifact (auth.ts v2)

    Orch->>Review: message/send<br/>"重新审查"
    Review-->>Orch: Task (completed, "审查通过")

    Orch->>Test: message/send<br/>"运行测试"
    Test-->>Orch: Task (completed, "100% 通过")

    Orch-->>User: "认证模块开发完成 ✓"

不透明协作(Opaque Collaboration)

A2A 的核心设计理念是不透明协作

graph LR
    subgraph "Agent A (内部不可见)"
        A1[私有记忆]
        A2[专有逻辑]
        A3[内部工具]
        A4[接口层]
    end

    subgraph "Agent B (内部不可见)"
        B1[私有记忆]
        B2[专有逻辑]
        B3[内部工具]
        B4[接口层]
    end

    A4 <-->|A2A Protocol<br/>仅交换任务和消息| B4

    style A1 fill:#ffcdd2
    style A2 fill:#ffcdd2
    style A3 fill:#ffcdd2
    style B1 fill:#ffcdd2
    style B2 fill:#ffcdd2
    style B3 fill:#ffcdd2
    style A4 fill:#c8e6c9
    style B4 fill:#c8e6c9

优势

  • 保护知识产权和商业机密
  • 保护用户隐私数据
  • 降低集成复杂度
  • 支持异构 Agent 协作

与其他协议的对比

协议定位对比

graph TB
    subgraph "AI Agent 协议生态"
        subgraph "工具层 (Agent-to-Tool)"
            MCP[MCP<br/>Model Context Protocol]
        end

        subgraph "Agent 协作层 (Agent-to-Agent)"
            A2A[A2A<br/>Agent2Agent Protocol]
            ACP[ACP<br/>Agent Communication Protocol]
        end

        subgraph "框架层"
            LC[LangChain]
            AG[AutoGPT]
            CW[CrewAI]
        end

        subgraph "应用层"
            APP[企业应用]
        end
    end

    APP --> LC
    APP --> AG
    APP --> CW
    LC --> MCP
    LC --> A2A
    AG --> MCP
    AG --> A2A
    CW --> A2A

    style MCP fill:#ff9800,color:#fff
    style A2A fill:#4caf50,color:#fff
    style ACP fill:#2196f3,color:#fff

详细对比表

维度A2AMCPLangChainFunction Calling
定位Agent-to-Agent 通信Agent-to-Tool 通信Agent 开发框架LLM 工具调用
发起者Google + Linux FoundationAnthropicHarrison ChaseOpenAI
协议类型开放标准开放标准开源框架私有协议
通信方式JSON-RPC + SSEJSON-RPC框架内部HTTP API
发现机制Agent CardTool Schema内置工具函数定义
长任务支持✅ 完整支持❌ 不支持🔶 部分支持❌ 不支持
流式处理✅ SSE❌ 不支持🔶 框架级别✅ 支持
跨厂商协作✅ 核心特性🔶 有限❌ 不支持❌ 不支持
企业级安全✅ OpenAPI 兼容🔶 基础🔶 框架级别✅ 支持

A2A 与 MCP 的互补关系

graph TB
    subgraph "完整的 Agent 架构"
        subgraph "Agent A"
            A1[Agent Core]
            A2[MCP Client]
        end

        subgraph "Agent B"
            B1[Agent Core]
            B2[MCP Client]
        end

        subgraph "工具层"
            T1[Database]
            T2[API Service]
            T3[File System]
        end
    end

    A1 <-->|A2A Protocol| B1
    A2 -->|MCP| T1
    A2 -->|MCP| T2
    B2 -->|MCP| T3

    style A1 fill:#4caf50,color:#fff
    style B1 fill:#4caf50,color:#fff
    style A2 fill:#ff9800,color:#fff
    style B2 fill:#ff9800,color:#fff

类比:如果 MCP 是将键盘插入电脑的 USB 接口,那么 A2A 就是电脑之间发送邮件的网络协议。


应用场景

场景 1:企业供应链协作

graph LR
    subgraph "零售商"
        R[库存 Agent]
    end

    subgraph "供应商 A"
        SA[销售 Agent]
    end

    subgraph "供应商 B"
        SB[销售 Agent]
    end

    subgraph "物流商"
        L[物流 Agent]
    end

    R <-->|A2A: 询价| SA
    R <-->|A2A: 询价| SB
    R <-->|A2A: 安排配送| L
    SA <-->|A2A: 协调配送| L

    style R fill:#2196f3,color:#fff
    style SA fill:#4caf50,color:#fff
    style SB fill:#4caf50,color:#fff
    style L fill:#ff9800,color:#fff

案例:Tyson Foods 和 Gordon Food Service 正在使用 A2A 协议构建协作系统,实现产品数据和销售线索的实时共享。

场景 2:软件开发流水线

graph TB
    subgraph "DevOps Agent 协作"
        PM[产品经理 Agent]
        DEV[开发 Agent]
        QA[测试 Agent]
        SEC[安全 Agent]
        OPS[运维 Agent]
    end

    PM -->|需求| DEV
    DEV -->|代码| QA
    QA -->|测试报告| DEV
    DEV -->|代码| SEC
    SEC -->|安全报告| DEV
    DEV -->|构建产物| OPS
    OPS -->|部署状态| PM

    style PM fill:#9c27b0,color:#fff
    style DEV fill:#4caf50,color:#fff
    style QA fill:#2196f3,color:#fff
    style SEC fill:#f44336,color:#fff
    style OPS fill:#ff9800,color:#fff

场景 3:跨云 Agent 协作

graph LR
    subgraph "Azure"
        A1[Copilot Agent]
    end

    subgraph "Google Cloud"
        G1[Vertex AI Agent]
    end

    subgraph "AWS"
        W1[Bedrock Agent]
    end

    subgraph "企业私有云"
        E1[企业 Agent]
    end

    A1 <-->|A2A| G1
    G1 <-->|A2A| W1
    W1 <-->|A2A| E1
    E1 <-->|A2A| A1

    style A1 fill:#0078d4,color:#fff
    style G1 fill:#4285f4,color:#fff
    style W1 fill:#ff9900,color:#fff
    style E1 fill:#6b7280,color:#fff

Microsoft 已宣布:Azure AI Foundry 和 Copilot Studio 将很快支持 A2A 协议。

场景 4:数字内容创作

graph LR
    subgraph "Adobe Agent 生态"
        A1[创意 Agent]
        A2[排版 Agent]
        A3[图像处理 Agent]
    end

    subgraph "Google Agent 生态"
        G1[翻译 Agent]
        G2[SEO Agent]
    end

    A1 <-->|A2A| G1
    A2 <-->|A2A| G2
    A3 <-->|A2A| G1

    style A1 fill:#ff0000,color:#fff
    style A2 fill:#ff0000,color:#fff
    style A3 fill:#ff0000,color:#fff
    style G1 fill:#4285f4,color:#fff
    style G2 fill:#4285f4,color:#fff

Adobe 正在使用 A2A 使其分布式 Agent 与 Google Cloud 生态系统中的 Agent 实现互操作。


未来展望:Agent 协作标准的演进

发展路线图

timeline
    title A2A 协议演进时间线

    2025 Q1 : Google 发布 A2A v0.1
            : 50+ 合作伙伴加入

    2025 Q2 : A2A v0.2 发布
            : 捐赠给 Linux Foundation
            : 支持无状态交互

    2025 Q3-Q4 : A2A v1.0 预计发布
               : 官方 SDK 正式版
               : 企业生产就绪

    2026+ : Agent Mesh 架构
          : 联邦注册中心
          : 跨域治理

未来架构演进

graph TB
    subgraph "当前:中心化发现"
        R1[Agent Registry]
        A1[Agent A] --> R1
        A2[Agent B] --> R1
        A3[Agent C] --> R1
    end

    subgraph "未来:Agent Mesh"
        subgraph "Domain A"
            RA[Registry A]
            AA1[Agent A1]
            AA2[Agent A2]
        end

        subgraph "Domain B"
            RB[Registry B]
            AB1[Agent B1]
            AB2[Agent B2]
        end

        subgraph "Governance Layer"
            G[统一治理层]
        end

        AA1 --> RA
        AA2 --> RA
        AB1 --> RB
        AB2 --> RB
        RA <--> G
        RB <--> G
        RA <-.->|Federation| RB
    end

    style R1 fill:#ffcdd2
    style G fill:#4caf50,color:#fff
    style RA fill:#2196f3,color:#fff
    style RB fill:#2196f3,color:#fff

预判:Agent 协作标准的未来

趋势说明可能性
A2A 成为事实标准100+ 企业支持 + Linux Foundation 治理⭐⭐⭐⭐⭐
A2A + MCP 组合形成完整的 Agent 互操作栈⭐⭐⭐⭐⭐
Agent Mesh 架构类似 Service Mesh 的分布式治理⭐⭐⭐⭐
联邦身份认证跨组织的 Agent 身份互认⭐⭐⭐⭐
实时协作协议WebRTC 等实时协议集成⭐⭐⭐

总结

A2A 协议核心要点

16-aionui-architecture.png

关键结论

  1. A2A 是 Agent 协作的事实标准:100+ 企业支持、Linux Foundation 治理、厂商中立
  2. A2A 与 MCP 互补:共同构成完整的 Agent 互操作栈
  3. 不透明协作是核心创新:保护隐私和知识产权的同时实现协作
  4. 企业就绪:支持 OAuth、长任务、流式处理、推送通知
  5. 未来趋势:Agent Mesh 架构、联邦治理、跨域协作

参考资料


  • 关于作者:【前端领秀】一个喜欢探索前端领域AI赋能的开发者,喜欢我的可以关注我,私信我邀请进入技术群,我会时刻分享最新前沿AI技术; 扫码_搜索联合传播样式-白色版.png