MCP + A2A + A2UI：2026 年多 Agent 系统的完整协议栈实战指南

构建一个生产级的多 Agent 系统，意味着你必须同时解决三个截然不同的通信问题：Agent 如何与工具对话、Agent 如何与其他 Agent 对话、Agent 如何与用户对话。2026 年，行业已经收敛到三个开放协议——MCP、A2A 和 A2UI——它们共同构成了 AI Agent 架构中完整且可互操作的协议栈。

核心摘要

MCP（Model Context Protocol）负责 Agent 到工具的集成。A2A（Agent-to-Agent）负责 Agent 间的协调与任务委派。A2UI（Agent-to-UI）通过声明式 JSON 描述用户界面。三者共同覆盖了多 Agent 系统中的所有通信边界。它们由不同团队（Anthropic、Google）分别设计，但可以干净地互操作——A2UI 消息可以承载在 A2A 传输上，A2A Agent 可以暴露 MCP 工具。采纳策略推荐渐进式：先上 MCP，需要多 Agent 协调时加 A2A，需要富界面时加 A2UI。

核心要点

• 三个协议，三种边界：MCP 覆盖 Agent↔工具，A2A 覆盖 Agent↔Agent，A2UI 覆盖 Agent↔用户。没有任何单一协议能同时解决这三个问题。
• 天然互补：MCP 使用 JSON-RPC over stdio/SSE，A2A 使用 JSON-RPC over HTTP，A2UI 使用声明式 JSON 格式。三者能够自然组合。
• 渐进式采纳：可以从 MCP 单独起步，需要多 Agent 协调时加入 A2A，需要超越聊天的富 UI 时叠加 A2UI。
• 行业级背书：MCP 获得 Anthropic、OpenAI、Google、Microsoft 支持；A2A 获得 Google 及 50+ 合作伙伴支持；A2UI 提供 Web、移动端和 Flutter 渲染器。
• 可投产：三个协议在 2026 年均已拥有稳定规范、参考实现和持续增长的生态。

为什么需要协议栈？

每个 AI Agent 系统都至少面临三种通信边界之一。随着系统日趋复杂，这三种边界都会出现：

三种通信边界

没有哪个单一协议能优雅地解决这三个问题。MCP 针对 Agent 与工具之间紧密的、模式驱动的交互循环做了优化。A2A 专为自治 Agent 之间松耦合、异步的协调场景而设计。A2UI 则专门用于安全敏感的 Agent 生成界面渲染。强行让一个协议承担所有角色，就意味着在安全性、性能或开发体验上做出妥协。

三协议栈一览

协议栈是分层的：底层是基础，上层可选。简单的单 Agent 工具场景只用 MCP 即可。多 Agent 后端系统加入 A2A。需要富 UI 的全栈 Agent 应用则在顶部叠加 A2UI。

MCP：工具集成层

MCP（Model Context Protocol）是协议栈的基石。它标准化了 Agent 发现和调用外部工具、读取数据资源、使用提示词模板的方式。更深入的解析请参阅 MCP 协议完全指南 和 MCP 协议进阶指南。

MCP 在协议栈中的位置

在三协议架构中，MCP 是底层——每个 Agent 都需要它。即使参与 A2A 协调或生成 A2UI 界面的 Agent，内部仍然使用 MCP 来访问工具和数据源。

MCP 核心原语

MCP 工具调用示例

以下是一个最小化的 MCP 服务器示例，它暴露了一个餐厅搜索工具——在后面的完整实战场景中，专业 Agent 会用到这类工具：

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

const server = new McpServer({
  name: "restaurant-service",
  version: "1.0.0",
});

server.tool(
  "search_restaurants",
  "Search restaurants by cuisine, location, and party size",
  {
    cuisine: z.string().describe("Type of cuisine"),
    location: z.string().describe("City or neighborhood"),
    partySize: z.number().min(1).max(20).describe("Number of guests"),
    date: z.string().describe("Reservation date (YYYY-MM-DD)"),
  },
  async ({ cuisine, location, partySize, date }) => {
    const results = await queryRestaurantDB(cuisine, location, partySize, date);
    return {
      content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
    };
  }
);

关键洞察：MCP 工具是框架无关的。同一个 MCP 服务器可以同时服务于 Claude、GPT、Gemini 或任何支持 MCP 协议的自定义 Agent。你可以使用 JSON 格式化工具 验证 MCP 工具的 Schema，尽早发现错误。

A2A：Agent 协调层

MCP 连接 Agent 与工具，而 A2A（Agent-to-Agent）协议连接 Agent 与 Agent。它解决的是从单 Agent 迁移到多 Agent 系统时必然面临的发现、通信和任务委派问题。

关于多 Agent 架构的更多背景，请参阅 多 Agent 系统完全指南 和 2026 年 AI Agent 框架对比。

Agent Card：发现机制

每个 A2A Agent 都会在 /.well-known/agent.json 发布一张 Agent Card（Agent 名片）——一份机器可读的能力、技能和支持协议的描述：

{
  "name": "Restaurant Booking Agent",
  "description": "Finds restaurants and manages reservations",
  "url": "https://restaurant-agent.example.com",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "skills": [
    {
      "id": "search-restaurants",
      "name": "Search Restaurants",
      "description": "Find restaurants by cuisine, location, date, and party size",
      "tags": ["restaurants", "dining", "reservations"]
    },
    {
      "id": "book-table",
      "name": "Book a Table",
      "description": "Make a restaurant reservation",
      "tags": ["booking", "reservations"]
    }
  ],
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["text/plain", "application/json"]
}

编排 Agent（Orchestrator Agent）通过拉取各专业 Agent 的 Agent Card 来发现它们，然后根据技能和标签决定将任务委派给哪个 Agent。

任务生命周期

A2A 定义了清晰的任务生命周期，具有明确的状态转换规则：

A2A 通信流程

A2A 使用 JSON-RPC 2.0 over HTTP。对于长时间运行的任务，响应通过服务器发送事件（Server-Sent Events，SSE）进行流式传输，让编排 Agent 可以在远程 Agent 处理过程中实时接收增量更新。

A2UI：用户界面层

A2UI（Agent-to-UI）是协议栈中最新的协议，它解决了前两个协议未涉及的问题：Agent 如何通过富交互界面（而非纯文本）与用户进行通信。

更深入的解析请参阅 A2UI 协议深度解读。关于与其他方案的对比，请参阅 A2UI vs AG-UI vs Vercel。

A2UI 工作原理

A2UI 使用声明式 JSON 格式来描述 UI 组件。Agent 发送 JSON 描述，客户端在其平台（Web、移动端、桌面端）上原生渲染：

{
  "type": "updateComponents",
  "components": [
    {
      "type": "form",
      "id": "booking-form",
      "title": "Book a Restaurant",
      "fields": [
        { "type": "date", "id": "date", "label": "Date", "required": true },
        { "type": "time", "id": "time", "label": "Time", "required": true },
        {
          "type": "number",
          "id": "partySize",
          "label": "Party Size",
          "min": 1,
          "max": 20,
          "defaultValue": 2
        },
        {
          "type": "select",
          "id": "cuisine",
          "label": "Cuisine",
          "options": ["Italian", "Japanese", "Mexican", "Thai", "French"]
        }
      ],
      "submitLabel": "Search Restaurants"
    }
  ]
}

A2UI 关键特性

A2UI 刻意不做布局引擎。它描述语义化的 UI 意图（表单、卡片、图表），信任客户端渲染器来应用平台适配的样式。

完整实战场景：餐厅预订流程

让我们走完一个完整的示例，体验三个协议如何协同运作：用户通过多 Agent 系统预订餐厅。

"预订餐厅"完整流程

逐步详解

第 1 步 — A2UI：展示预订表单。 编排 Agent 生成一条 A2UI updateComponents 消息，包含日期、时间、人数和菜系字段的表单。客户端在用户设备上将其渲染为原生表单。

第 2 步 — A2UI：捕获用户输入。 用户填写表单并提交。客户端向编排 Agent 发送一个 formSubmit 事件，携带结构化的表单数据。

第 3 步 — A2A：委派给餐厅 Agent。 编排 Agent 构建一个 A2A tasks/send 请求，将搜索任务委派给专业的餐厅 Agent。编排 Agent 此前已通过拉取 Agent Card 发现了该 Agent。

第 4 步 — MCP：查询数据库。 餐厅 Agent 调用其 MCP 工具 search_restaurants，传入用户的搜索条件。MCP 服务器查询餐厅数据库并返回匹配结果。

第 5 步 — A2A + A2UI：返回富结果。 餐厅 Agent 将结果打包为一个 A2A artifact，其中包含 A2UI 载荷——一组餐厅卡片，包含名称、评分、照片和"立即预订"按钮。

第 6 步 — A2UI：渲染与交互。 编排 Agent 将 A2UI 组件转发到客户端，客户端渲染出可交互的餐厅卡片。用户点击"立即预订"确认预订。

这个流程清楚地说明了为什么我们需要三个协议：A2UI 负责用户界面、A2A 负责 Agent 间委派、MCP 负责工具调用。每个协议干净地处理各自的通信边界。

A2UI 的 A2A 扩展规范

协议栈最强大的特性之一是 A2UI 消息可以原生地通过 A2A 传输。A2UI 规范包含一份官方的 A2A 扩展（A2A Extension），定义了如何将 UI 载荷嵌入 A2A 消息中。

工作原理

远程 Agent 在其 Agent Card 中声明对 A2UI 的支持：

{
  "name": "Restaurant Booking Agent",
  "url": "https://restaurant-agent.example.com",
  "capabilities": {
    "streaming": true,
    "extensions": ["a2ui-0.2"]
  },
  "defaultOutputModes": [
    "text/plain",
    "application/json",
    "application/json+a2ui"
  ]
}

返回结果时，Agent 将 A2UI 组件作为 A2A DataPart 对象包含在内：

{
  "jsonrpc": "2.0",
  "id": "task-42",
  "result": {
    "id": "task-42",
    "status": { "state": "completed" },
    "artifacts": [
      {
        "parts": [
          {
            "type": "data",
            "mimeType": "application/json+a2ui",
            "data": {
              "type": "updateComponents",
              "components": [
                {
                  "type": "card",
                  "id": "restaurant-1",
                  "title": "Trattoria Roma",
                  "subtitle": "⭐ 4.8 — Italian — $$",
                  "body": "Available tonight at 7:30 PM for 4 guests",
                  "actions": [
                    { "type": "button", "label": "Book Now", "id": "book-1" }
                  ]
                }
              ]
            }
          }
        ]
      }
    ]
  }
}

你可以使用 JSON 校验工具 验证复杂的 A2A/A2UI JSON 载荷，确保它们在部署前符合预期的 Schema。

会话映射

架构模式

根据系统复杂度，你可以采纳一个、两个或全部三个协议。以下是三种典型模式：

模式一：单 Agent + MCP

最简单的模式。一个 Agent 直接访问工具。不需要 Agent 间协调，不需要富 UI。

适用场景：构建带工具访问的聊天机器人或助手。单一领域、单一交互模式。

示例：一个编程助手，通过 MCP 读取文件、运行测试、搜索代码。这是大多数智能体工作流实现的起点。

模式二：多 Agent + MCP + A2A

多个专业 Agent 由一个编排 Agent 协调。每个 Agent 有自己的 MCP 工具。没有富 UI——与用户的通信基于纯文本。

适用场景：构建后端多 Agent 系统，不同 Agent 专注于不同领域。用户通过简单聊天或 API 调用进行交互。

示例：一个内容创作流水线——调研 Agent 收集信息（通过 MCP），写作 Agent 起草内容，审校 Agent 检查质量——全部通过 A2A 协调。

模式三：全栈 — MCP + A2A + A2UI

完整协议栈。多个 Agent 加上交付给用户的富交互界面。这是最强大的模式，也是生产级 Agent 应用的目标架构。

适用场景：构建全功能 Agent 应用，需要富 UI、多 Agent 协调和工具集成。企业应用、消费级产品、内部工具。

示例：上述的餐厅预订系统，或一个企业助手——协调 HR、IT 和财务 Agent，每个 Agent 拥有专属工具——同时向用户展示交互式仪表盘和表单。

渐进式采纳策略

你无需一次性采纳全部三个协议。协议栈天然支持渐进式采纳：

第一阶段：从 MCP 开始

何时：你正在构建带工具访问的单 Agent 应用。

怎么做：将工具定义为 MCP 服务器。通过 MCP SDK 将它们连接到 Agent。这让你从第一天起就拥有标准化、可复用的工具层。

迁移成本：低。如果你已经有函数调用定义，将它们包装为 MCP 工具是很直接的。

第二阶段：加入 A2A 实现多 Agent

何时：单 Agent 已触达能力上限。你需要不同领域的专业 Agent。

怎么做：将单体 Agent 拆分为专业 Agent，每个 Agent 拥有自己的 MCP 工具。添加一个编排 Agent。为每个专业 Agent 发布 Agent Card。使用 A2A tasks/send 进行任务委派。

迁移成本：中等。主要工作是 Agent 拆分和编排逻辑的设计。MCP 工具无需变更。

第三阶段：加入 A2UI 打造富界面

何时：纯聊天交互已成为用户体验的瓶颈。你需要表单、卡片、图表或交互组件。

怎么做：将纯文本响应替换为 A2UI updateComponents 消息。在客户端（Web、移动端或桌面端）集成 A2UI 渲染器。启用 A2A 扩展，让远程 Agent 也能返回 UI 载荷。

迁移成本：中等。Agent 端的改造是添加 A2UI 消息生成逻辑。主要工作在于客户端渲染器的集成。

最佳实践

1. 围绕协议而非框架来设计 Agent

先选协议，再选支持它们的框架。MCP、A2A 和 A2UI 都是框架无关的——它们适用于 LangGraph、CrewAI、AutoGen 或任何自定义 Agent。这可以避免供应商锁定。

2. 保持 MCP 工具原子化和可组合

每个 MCP 工具应该只做好一件事。Agent 通过顺序调用多个工具来编排复杂的智能体工作流。不要构建试图在内部处理整个流程的巨型工具。

3. 把 Agent Card 当作契约

像对待 API 契约一样对待 A2A Agent Card。为它们做版本管理，精确描述技能，并测试 Agent 是否兑现了 Card 中的承诺。这是实现可靠的 Agent 发现和任务委派的基础。

4. 在每个协议边界验证 JSON 载荷

三个协议都大量使用 JSON。在每个协议边界都要验证 MCP 工具 Schema、A2A 任务载荷和 A2UI 组件描述。Schema 验证能尽早发现集成 Bug——开发期间可以使用 JSON 格式化工具 辅助验证。

5. 为部分采纳做好规划

并非每个 Agent 都需要三个协议。设计你的系统时，应让 Agent 能在各自的能力水平上参与——一个只支持 MCP 的 Agent 仍然可以被编排 Agent 通过 A2A 调用，只需编排 Agent 包装一层交互即可。

常见问题 (FAQ)

AI Agent 协议栈中的三个协议分别是什么？

三个协议分别是 Anthropic 的 MCP（Model Context Protocol）负责 Agent 到工具的集成，Google 的 A2A（Agent-to-Agent）负责 Agent 间的通信与任务委派，Google 的 A2UI（Agent-to-UI）负责 Agent 驱动的用户界面。三者共同覆盖了多 Agent 系统中的所有通信边界：Agent↔工具、Agent↔Agent、Agent↔用户。

MCP、A2A 和 A2UI 如何协同工作？

MCP 连接 Agent 与外部工具和数据源。A2A 让 Agent 能够发现、通信和委派任务给其他 Agent。A2UI 让 Agent 生成在用户设备上原生渲染的富交互界面。在典型流程中：用户通过 A2UI 交互，编排 Agent 通过 A2A 委派给专业 Agent，专业 Agent 通过 MCP 访问工具和数据。本文的餐厅预订示例完整演示了这一流程。

我的 Agent 应用需要三个协议都用吗？

不一定。对于单 Agent + 工具的应用，MCP 可能就够了。需要多 Agent 协调时加入 A2A。需要超越聊天的富界面时加入 A2UI。三个协议设计上支持渐进式采纳——从 MCP 开始，需要 Agent 协调时加 A2A，需要动态界面时加 A2UI。具体指导请参阅架构模式章节。

哪些公司支持这些协议？

MCP 得到 Anthropic、OpenAI、Google、Microsoft 及主要 AI 框架的支持。A2A 得到 Google、Salesforce、SAP、Oracle 及 50+ 技术合作伙伴的支持。A2UI 得到 Google、CopilotKit（通过 AG-UI 传输）、Vercel（通过 json-renderer）和 Flutter 团队的支持。生态在 2026 年正在快速扩展。

A2UI 消息可以通过 A2A 传输吗？

可以。A2UI 有官方的 A2A 扩展规范。A2UI 消息被编码为 MIME 类型为 application/json+a2ui 的 A2A DataPart 对象。这让远程 Agent 能够将富 UI 描述发回编排 Agent，再由编排 Agent 转发到客户端进行原生渲染。详情和代码示例请参阅 A2UI 的 A2A 扩展规范章节。

A2A 和 MCP 在 Agent 通信方面有什么区别？

MCP 设计用于 Agent 到工具的通信——紧密的、同步的、模式驱动的交互，Agent 调用工具并获取结果。A2A 设计用于 Agent 到 Agent 的通信——松耦合的、可能异步的交互，一个 Agent 将任务委派给另一个自治 Agent。A2A 包含 MCP 不需要的功能：Agent 发现（Agent Card）、任务生命周期管理，以及对长时间异步任务的支持。

同时使用三个协议的性能开销有多大？

每个协议都会增加一层 JSON-RPC 或 JSON 序列化/反序列化。在实践中，相比大语言模型（LLM）的推理时间，这些开销可以忽略不计。MCP 工具调用增加约 1-5ms 的协议开销。A2A 增加 HTTP 往返延迟（取决于网络状况）。A2UI 增加 UI 组件的 JSON 序列化开销（典型载荷约 1ms）。Agent 系统中的瓶颈永远是 LLM 推理，而非协议开销。

总结

MCP + A2A + A2UI 协议栈代表了行业对一个根本性挑战的回答：如何构建多 Agent 系统，使 Agent 能够可靠地访问工具、相互协调，并为用户交付丰富的体验。

• MCP 提供通用的工具层——工具写一次，任何 Agent 都能用。
• A2A 提供协调层——Agent 相互发现、委派任务、流式传输结果。
• A2UI 提供 UI 层——Agent 用 JSON 描述界面，客户端原生渲染。

这些协议是互补的，而非竞争关系。它们由不同团队（Anthropic 和 Google）设计，但天然可互操作。根据你的系统需求渐进式采纳，你将获得一个基于标准的干净架构——避免供应商锁定，并随你的目标一起扩展。

现在就开始构建：选择一个工具，将它包装为 MCP 服务器，看看协议栈如何加速你的 AI Agent 开发。

相关资源

• MCP 协议完全指南 — 深入解析 MCP 架构、组件和开发实践
• MCP 协议进阶指南 — MCP 高级模式，包括 OAuth、远程服务器和安全性
• A2UI 协议深度解读 — A2UI 协议规范和渲染器的全面指南
• A2UI vs AG-UI vs Vercel — Agent 驱动 UI 三种方案的对比
• 多 Agent 系统完全指南 — 多 Agent 系统架构模式
• 2026 年 AI Agent 框架对比 — LangGraph、CrewAI、AutoGen 等框架的全面对比
• JSON 格式化工具 — 验证和格式化你的 MCP/A2A/A2UI JSON 载荷