从 Agent Card 看 A2A 与 MCP 的核心差异：AI 代理协议的互补之道

龙哥AI2000

2026年04月07日 14:19

从 Agent Card 看 A2A 与 MCP 的核心差异：AI 代理协议的互补之道

引言

2025 年到 2026 年，AI 代理（AI Agent）领域迎来了两个重要的开放协议：Google 的 A2A（Agent2Agent） 和 Anthropic 的 MCP（Model Context Protocol）。

很多开发者会问：这两个协议有什么差异？我应该用哪个？答案是：都要用，因为它们解决的是不同层次的问题。

本文将从 Agent Card 这个独特视角，深入剖析 A2A 与 MCP 的核心差异，帮助你理解为什么它们是互补关系，而非竞争关系。

什么是 Agent Card？

在深入对比之前，先理解一个关键概念：Agent Card。

Agent Card = AI 代理的"名片" + "菜单"

想象你去餐厅吃饭： 1. 先看菜单 → 知道这家店能做什么菜 2. 再点菜 → 选择你需要的服务

Agent Card 就是 AI 代理的菜单，它是一个标准的 JSON 文件，通常位于：

 代码块
PlainText
自动换行
复制代码
https://your-agent.com/.well-known/agent-card.json
复制成功

这个文件告诉其他代理或客户端： - 这个 agent 能做什么（能力声明） - 支持什么输入/输出格式 - 有什么特殊能力（streaming、长周期任务等） - 如何与它通信

Agent Card 示例

 代码块
PlainText
自动换行
复制代码
{
  "name": "Travel Planner Agent",
  "description": "帮你规划旅行行程，包括预算、景点、餐饮推荐",
  "url": "https://travel-agent.example.com",

  "capabilities": {
    "streaming": true,
    "longRunning": true
  },

  "defaultInputModes": ["text"],
  "defaultOutputModes": ["text"],

  "skills": [
    {
      "id": "currency-conversion",
      "name": "Currency Conversion",
      "description": "实时汇率转换"
    },
    {
      "id": "activity-planning",
      "name": "Activity Planning",
      "description": "个性化行程规划"
    }
  ],

  "protocolVersion": "0.3.0"
}
复制成功

关键点：Agent Card 是 A2A 协议 的核心发现机制，而 MCP 没有这个概念。这就是我们对比的切入点。

A2A vs MCP：定位差异

核心定位对比

维度 A2A MCP 全称 Agent2Agent Protocol Model Context Protocol 定位 Agent ↔ Agent Agent ↔ Tools/Data 类比公共互联网 USB 接口 发现机制 Agent Card Tools List 任务模型 Task（有生命周期） Tool Call（即时响应） 长周期支持 ✅ 小时/天级别 ❌ 通常秒级完成

形象类比

MCP = USB 接口 - 你的电脑（Agent）通过 USB（MCP）连接鼠标、键盘、U 盘（Tools） - 即插即用，标准化接口 - 但鼠标不会跟键盘"聊天"

A2A = 公共互联网 - 你的电脑（Agent A）通过互联网（A2A）连接另一台电脑（Agent B） - 可以委托复杂任务："帮我分析这份数据" - Agent B 可能再委托给 Agent C（多跳协作）

从 Agent Card 看协议差异

1. 发现机制：Agent Card vs Tools List

A2A 的发现流程：

 代码块
PlainText
自动换行
复制代码
1. Client 访问 https://agent.example.com/.well-known/agent-card.json
2. 读取 Agent Card，了解这个 agent 的能力
3. 决定是否委托任务
4. 通过 A2A 协议创建 Task
5. 实时跟踪任务进度（Streaming）
6. 接收最终结果（Artifact）
复制成功

MCP 的发现流程：

 代码块
PlainText
自动换行
复制代码
1. Client 连接 MCP Server
2. Server 暴露 Tools List
3. Client 直接调用工具：call_tool("search", {"query": "..."})
4. 即时返回结果
复制成功

关键差异： - Agent Card 描述的是另一个 agent 的能力（可能跨组织、跨信任边界） - Tools List 描述的是自己配置的工具（通常是可信的）

2. 信任模型：不可信 vs 可信

A2A 的官方警告（来自 GitHub 仓库）：

Treat any agent operating outside of your direct control as a potentially untrusted entity.
将任何不在你直接控制下的 agent 视为潜在不可信的实体。

为什么？因为： - Agent Card 可能包含恶意 payload（prompt injection） - Remote Agent 可能返回错误/有害信息 - 需要输入验证、输出 sanitization

MCP 的信任模型： - Tools 通常是自己配置的（可信） - 直接访问内部数据/API - 安全边界：agent ↔ 外部系统

3. 任务复杂度：委托 vs 调用

A2A Task 示例：

 代码块
PlainText
自动换行
复制代码
# 委托一个复杂任务给另一个 agent
task = a2a.create_task(
    agent="https://travel-agent.example.com",
    message="帮我规划首尔 3 天行程，预算$150/天，包含汇率转换、景点推荐、餐饮建议"
)

# 任务状态跟踪
while task.status != "completed":
    update = await task.get_update()
    print(f"进度：{update.progress}%")  # Streaming 支持

# 接收最终结果
result = await task.get_artifact()
print(result.itinerary)  # 完整的行程单
复制成功

MCP Tool Call 示例：

 代码块
PlainText
自动换行
复制代码
# 调用一个工具
result = mcp.call_tool("currency_converter", {
    "from": "USD",
    "to": "KRW",
    "amount": 150
})

print(result.rate)  # 即时返回汇率
复制成功

关键差异： - A2A Task：高层级、语义化、长周期、有状态 - MCP Tool：低层级、原子化、即时、无状态

实际场景：旅行规划助手

让我们通过一个完整场景，看看 A2A 和 MCP 如何协同工作。

用户需求

"帮我规划首尔 3 天行程，预算$150/天，包含汇率转换、景点推荐、餐饮建议"

方案 1：纯 MCP（单 Agent + 多 Tools）

 代码块
PlainText
自动换行
复制代码
┌─────────────────────────────────────────┐
│         Travel Agent (LLM)              │
│  ┌─────────────────────────────────┐   │
│  │  MCP Tools:                      │   │
│  │  - Currency API (汇率查询)        │   │
│  │  - Hotel API (酒店预订)           │   │
│  │  - Weather API (天气查询)         │   │
│  │  - Maps API (景点推荐)            │   │
│  └─────────────────────────────────┘   │
└─────────────────────────────────────────┘
复制成功

优点： - 架构简单，易于调试 - 所有工具由同一个 agent 控制

缺点： - 工具耦合在 agent 内部 - 难以复用其他专业 agent（如专门的汇率 agent） - 扩展性受限

方案 2：A2A + MCP（多 Agent 协作）

 代码块
PlainText
自动换行
复制代码
                    用户/Client
                        ↓
            ┌───────────────────┐
            │  TravelManager    │ ← A2A Client Agent
            │  (Orchestrator)   │
            └─────────┬─────────┘
                      │ A2A 委托
        ┌─────────────┼─────────────┬──────────┐
        ↓             ↓             ↓          ↓
┌────────────┐ ┌────────────┐ ┌─────────┐ ┌─────────┐
│ Currency   │ │ Hotel      │ │ Weather │ │Activity │
│ Agent      │ │ Agent      │ │ Agent   │ │Planner  │
└─────┬──────┘ └─────┬──────┘ └────┬────┘ └────┬────┘
      │              │             │            │
      └──────────────┴─────────────┴────────────┘
                      MCP Tools
            (每个 agent 内部可能用 MCP 连接自己的工具)
复制成功

工作流：

TravelManager 接收用户请求
通过 A2A 委托给 Currency Agent："Convert $150 USD to KRW"
Currency Agent 内部用 MCP 连接汇率 API
通过 A2A 委托给 Activity Planner："Plan 3-day Seoul itinerary"
Activity Planner 内部用 MCP 连接 Maps API、餐饮数据库
汇总所有结果，返回给用户

优点： - 每个 agent 专注自己的领域（单一职责） - 可以复用第三方专业 agent - 易于扩展（添加新的 agent 即可）

缺点： - 架构复杂度增加 - 需要处理跨 agent 的错误处理、超时、重试

为什么两者需要互补？

1. 抽象层级不同

MCP 解决的是 Agent 如何连接外部世界（工具、数据、API）

A2A 解决的是 Agent 如何与其他 Agent 协作（委托、分工、多跳）

一个完整的 AI 系统，两者都需要： - 对外：用 A2A 与其他 agent 协作 - 对内：用 MCP 连接自己的工具和数据

2. 生态系统不同

MCP 生态： - 工具开发者：发布 MCP Server - Agent 开发者：集成 MCP Tools

A2A 生态： - Agent 开发者：发布 Agent Card，暴露能力 - Client 开发者：发现并委托任务

未来趋势：一个 agent 可能同时是： - A2A Server：对外提供服务（有 Agent Card） - A2A Client：委托任务给其他 agent - MCP Server：暴露自己的工具 - MCP Client：使用外部工具

3. 安全边界不同

MCP 安全模型：

 代码块
PlainText
自动换行
复制代码
[可信 Agent] ←MCP→ [外部 API/数据库]
     ↑
     │ 安全边界：防止外部系统攻击 agent
复制成功

A2A 安全模型：

 代码块
PlainText
自动换行
复制代码
[Agent A] ←A2A→ [Agent B] ←A2A→ [Agent C]
   ↑                ↑                ↑
   │                │                │
安全边界 1        安全边界 2        安全边界 3
复制成功

A2A 需要处理多信任域的复杂场景，而 MCP 主要处理单信任域内的工具调用。

对开发者的启示

1. 选择协议的原则

场景推荐协议连接外部 API、数据库、文件 MCP 委托复杂任务给另一个 agent A2A 多 agent 协作（跨组织） A2A 单个 agent 内部工具集成 MCP 长周期任务（小时/天） A2A 即时响应（秒级） MCP

2. 实现建议

如果你要构建一个 AI Agent：

先用 MCP 连接你的工具和数据
定义清晰的 Tools List
实现错误处理、重试机制
再用 A2A 暴露你的能力
创建 Agent Card（/.well-known/agent-card.json）
实现 Task 生命周期管理
支持 Streaming（SSE）
考虑安全
输入验证（Agent Card 可能被注入）
输出 sanitization
认证授权（如 OAuth、API Key）

3. 未来趋势

2026 年及以后的 AI 代理架构：

 代码块
PlainText
自动换行
复制代码
┌─────────────────────────────────────────────────────┐
│              Your AI Agent                           │
│                                                       │
│  ┌─────────────────────────────────────────────┐   │
│  │  A2A Layer (对外协作)                        │   │
│  │  - Agent Card 暴露能力                       │   │
│  │  - 接收/委托 Task                            │   │
│  │  - Streaming 进度跟踪                        │   │
│  └─────────────────────────────────────────────┘   │
│                       ↓                              │
│  ┌─────────────────────────────────────────────┐   │
│  │  MCP Layer (对内连接)                        │   │
│  │  - Tools List                                │   │
│  │  - 连接 API/数据库/文件                       │   │
│  │  - 即时调用                                  │   │
│  └─────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘
复制成功

总结

核心差异一句话

协议核心定位类比 MCP Agent 连接工具和数据 USB 接口 A2A Agent 连接其他 Agent 公共互联网

关键要点

Agent Card 是 A2A 的核心发现机制，MCP 没有这个概念
A2A 处理不可信的远程 agent，MCP 处理可信的本地工具
A2A 支持长周期、有状态任务，MCP 支持即时、原子化调用
两者互补，不是竞争——完整的 AI 系统需要同时使用两种协议

行动建议

学习 MCP：从连接一个简单的 API 开始
学习 A2A：从创建一个 Agent Card 开始
实践结合：构建一个同时使用两种协议的 agent
关注生态：A2A 已捐赠给 Linux Foundation，MCP 也在标准化进程中

参考资源：

A2A 官方文档：https://a2a-protocol.org/
A2A 代码示例：https://agent2agent.info/docs/examples/
MCP 官方文档：https://modelcontextprotocol.io/
GitHub A2A Samples：https://github.com/a2aproject/a2a-samples
IBM A2A 教程：https://www.ibm.com/think/tutorials/use-a2a-protocol-for-ai-agent-communication

本文基于 2026 年 4 月的 A2A 和 MCP 协议规范编写。协议仍在快速演进中，请关注官方文档获取最新信息。

本文为我原创，未经授权禁止转载

cv47565028

分享至

投诉或建议