Agent Communication Protocols Compared: A2A, MCP and ACP
An agent communication protocol defines how AI agents talk to tools, to other agents, and to users. This guide compares MCP, A2A and ACP, explains what happened to ACP, covers AG-UI and AP2, and shows how to govern them in production.
TL;DR
- An agent communication protocol standardizes one hop in an agent system: MCP connects agents to tools, A2A connects agents to other agents, and AG-UI connects agents to user interfaces.
- IBM's Agent Communication Protocol (ACP) merged into A2A under the Linux Foundation in August 2025, so new agent-to-agent work should target A2A.
- A2A reached a stable v1.0 specification in 2026 with support from more than 150 organizations, and joined the Agentic AI Foundation alongside MCP in August 2026.
- "ACP" also names the Agentic Commerce Protocol and the Agent Client Protocol, which solve different problems from IBM's ACP.
- Bifrost governs MCP tool calls, A2A agent calls, and model calls through one gateway with shared virtual keys and logs.
An agent communication protocol is a shared message format and interaction model that lets AI agents exchange requests, results, and context with tools, other agents, or users without custom integration code. MCP, A2A, and ACP dominate the topic, and their status has changed more than most comparison pages reflect. Bifrost, the open-source AI gateway for model, tool, and agent traffic built by Maxim AI, governs two of these protocols in production today, so this guide states where each one stands, how they compare, and which to use for which job.
What Is an Agent Communication Protocol?
An agent communication protocol is a specification for how an agent discovers a counterparty, sends it work, and receives results, covering transport, message schema, and authentication. Modern AI agent protocols are scoped by counterparty: one for tools, one for peer agents, one for user interfaces.
The current generation of protocols splits the problem by hop, which is why they complement rather than compete:
- Agent to tool: the Model Context Protocol (MCP) exposes tools, resources, and prompts to an agent.
- Agent to agent: the Agent2Agent Protocol (A2A) lets independent agents delegate tasks and return artifacts.
- Agent to user: AG-UI streams agent events to a frontend and carries user input back.
Figure 1: Each protocol owns one hop in the system; ACP no longer has a hop of its own because it merged into A2A.
Production systems usually run several at once, which is why the differences between an agent gateway, an LLM gateway, and an MCP gateway matter once traffic grows.
MCP: The Agent-to-Tool Protocol
The Model Context Protocol connects an AI application to external tools and data. Anthropic introduced MCP in November 2024 and donated it in December 2025 to the Agentic AI Foundation, a directed fund under the Linux Foundation.
The current MCP specification (version 2026-07-28) defines these properties:
- Message format: JSON-RPC 2.0 between hosts, clients, and servers.
- Server features: tools, resources, and prompts; clients can offer elicitation.
- Transports: stdio for local servers and Streamable HTTP for remote ones.
- Authorization: OAuth 2.1 for HTTP transports, with servers publishing Protected Resource Metadata (RFC 9728).
MCP does not define how two agents coordinate; handing work to another agent needs a separate protocol. For wire-level detail, see MCP transports, primitives, and the message lifecycle or the broader guide to the Model Context Protocol.
A2A: The Agent-to-Agent Protocol
The Agent2Agent Protocol (A2A) lets one agent discover another, send it a message, and track the resulting task to completion. Google announced A2A in April 2025 and moved it to the Linux Foundation in June 2025. A2A is the agent-to-agent standard that IBM's ACP later merged into.
The Linux Foundation reported in April 2026 that A2A had shipped its first stable specification, v1.0, with more than 150 supporting organizations and SDKs in five languages. In August 2026 the project joined the Agentic AI Foundation as a Growth Stage project, placing it under the same umbrella as MCP.
The A2A v1.0 specification defines:
- Discovery: an Agent Card, served at
/.well-known/agent-card.json, that lists skills, endpoints, capabilities, and security requirements. Cards can be signed. - Bindings: JSON-RPC, gRPC, and HTTP+JSON (REST).
- Work model: messages, tasks with states such as working, input required, completed, and failed, and artifacts as outputs.
- Async and auth: Server-Sent Events streaming, webhook push notifications, and security schemes declared on the card (API keys, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS).
Running these calls through a gateway in production adds the access checks and audit trail the protocol leaves to implementers.
A2A vs ACP: What Happened to IBM's Agent Communication Protocol
IBM Research launched the Agent Communication Protocol (ACP) in March 2025 to power its BeeAI platform. In August 2025, IBM announced that ACP was merging into A2A under the Linux Foundation, winding down active ACP development, with an IBM Research director joining the A2A Technical Steering Committee.
The A2A vs ACP question is therefore historical. Before the merge, the two protocols overlapped heavily but differed in design:
- ACP used REST over HTTP, MIME-typed multipart messages, and offline discovery through package metadata, callable with curl and no SDK.
- A2A used JSON-RPC from the start, centered discovery on the Agent Card, and specified authentication schemes in the card itself.
A2A v1.0 includes an HTTP+JSON binding that covers ACP's REST-first style. BeeAI now runs on A2A, and IBM published a migration guide for ACP agents.
Figure 2: ACP's lane ends in August 2025, when IBM folded it into A2A; MCP and A2A now sit under the same Linux Foundation umbrella.
Which "ACP" is this?
Three unrelated specifications share the acronym, and search results mix them:
| Acronym | Full name | Origin | What it standardizes |
|---|---|---|---|
| ACP | Agent Communication Protocol | IBM Research (BeeAI) | Agent-to-agent messaging; merged into A2A |
| ACP | Agentic Commerce Protocol | Stripe, OpenAI, and Meta | Agent-driven checkout, carts, and delegated payment |
| ACP | Agent Client Protocol | Zed | Communication between code editors and coding agents, JSON-RPC over stdio |
This guide uses ACP to mean IBM's protocol, as does this roundup of agent gateways for MCP and A2A.
Other AI Agent Protocols You Will Hear About
Beyond MCP and A2A, a handful of AI agent protocols cover narrower jobs. Each has a public specification and sits beside MCP and A2A rather than replacing them.
- AG-UI (Agent-User Interaction Protocol): an event-based protocol, from CopilotKit, that streams agent state to a frontend and carries user actions back.
- AP2 (Agent Payments Protocol): Google's protocol for agents that pay on a user's behalf, built on signed mandates and offered as an extension of A2A and MCP. The Linux Foundation counts more than 60 supporting organizations.
- ANP (Agent Network Protocol): an open-source suite for open agent networks, using W3C decentralized identifiers for identity and discovery.
None changes the core split: tool calls travel over MCP and agent calls over A2A, which is where an MCP gateway governs agent tool access and an agent gateway governs the rest.
MCP vs A2A vs ACP: Comparison Table
MCP, A2A, and ACP differ first by layer: MCP is agent-to-tool, while A2A and ACP are agent-to-agent. A2A and MCP are active Linux Foundation projects, and ACP is retired into A2A. The table compares all three on the attributes that matter in production.
| Attribute | MCP | A2A | ACP (IBM) |
|---|---|---|---|
| Layer | Agent to tool | Agent to agent | Agent to agent |
| Originator | Anthropic | IBM Research | |
| Governing body | Agentic AI Foundation (Linux Foundation) | Linux Foundation; Agentic AI Foundation since August 2026 | Linux Foundation, then merged |
| Message format | JSON-RPC 2.0 | Messages, tasks, artifacts | MIME multipart messages |
| Transport | stdio, Streamable HTTP | JSON-RPC, gRPC, HTTP+JSON | REST over HTTP |
| Discovery | Configured server, then capability listing | Agent Card at a well-known URI | Agent metadata, offline discovery |
| Auth | OAuth 2.1 for HTTP | Schemes declared on the card | Not specified in the protocol |
| Async model | Tasks extension | SSE streaming, push notifications | Sync, async, streaming |
| Status | Active (spec 2026-07-28) | Active, v1.0 stable | Merged into A2A, August 2025 |
The layer row tells you whether you need a protocol, and the status row tells you whether to build on it. For a team on the Bifrost MCP gateway, the practical pair is MCP for tools plus A2A for agents.
Which Agent Communication Protocol for Which Job
Choose an agent communication protocol by what sits on the other end of the connection. Use MCP when the counterparty is a tool, API, or data source; use A2A when it is another agent with its own reasoning; use AG-UI for a frontend; and add AP2 when an agent pays.
Figure 3: The counterparty decides the protocol: tools take MCP, agents take A2A, frontends take AG-UI, and payments add AP2 on top.
| Job | Protocol | Reason |
|---|---|---|
| Agent queries a database or SaaS API | MCP | The counterparty exposes functions, not goals |
| Planner hands research to a specialist agent | A2A | The counterparty owns a multi-step task and returns artifacts |
| Agent streams progress to a chat UI | AG-UI | Event stream designed for frontends |
| Agent completes a purchase | AP2 or Agentic Commerce Protocol | Payment mandates and checkout flows |
| Existing ACP agent | A2A, via IBM's migration guide | ACP is no longer developed |
The short MCP vs A2A rule: if the remote side runs one function and returns a result, expose it as an MCP tool; if it plans, calls its own tools, and reports back on a task, expose it as an A2A agent. Most systems need both, and the AI agent access governance question becomes how to control both in one place.
AI Agent Interoperability in Production: One Gateway for Every Protocol
AI agent interoperability creates three kinds of traffic, model calls, MCP tool calls, and A2A agent calls, and each needs access control, credentials, and logs. The Bifrost AI gateway governs all three as one gateway, with the same virtual keys and the same observability pipeline.
Figure 4: Agent access, tool access, and model access are separate grants, but they share one identity and one log trail in Bifrost.
A2A through the Agent Gateway
The Agent Gateway currently supports A2A v1. Teams register an agent by its Agent Card URL, and Bifrost serves a gateway Agent Card plus JSON-RPC, REST, and (when enabled) gRPC endpoints; a JSON-RPC client can reach a gRPC agent.
- Agent access: virtual keys are granted individual agents, and Enterprise adds grants through access profiles and projects. Agent access is separate from model and tool access.
- Credentials: Bifrost authenticates to the agent with headers or OAuth 2.0 client credentials, and can forward the caller's Bifrost credential so the agent's own calls stay attributed.
- Recovery: transport selection follows the card's interface order, and ambiguous or streaming operations are not replayed automatically.
The Agent Gateway launch post covers the design.
MCP through the MCP gateway
As an MCP gateway, Bifrost connects to MCP servers over STDIO, HTTP, or SSE and exposes approved tools to clients such as Claude Desktop. Tool calls are not executed automatically unless Agent Mode is enabled for specific tools, and Code Mode cuts input tokens by up to 92.8% in large deployments.
Tool filtering per virtual key is deny-by-default apart from clients marked Allow by Default, and upstream MCP authentication supports None, Headers, OAuth 2.0, Per-User OAuth, Per-User Headers, and Token Exchange. The MCP gateway resource page covers the benchmark.
Model calls and one trail across all three
The same gateway routes model calls to 10,000+ models across 25+ providers with retries and provider fallbacks. An agent that sends x-bf-session-id (the A2A context ID) and x-bf-agent-correlation-id (the A2A task ID) on its model and MCP requests has those calls linked to the task in Agent Logs.
A2A spans also export through OpenTelemetry, and virtual keys carry the agent grants, tool permissions, budgets, and rate limits for each caller. Bifrost runs inside the customer's infrastructure, as the enterprise deployment options describe.
Frequently Asked Questions
What are the main AI agent communication protocols?
The main AI agent communication protocols are MCP for agent-to-tool calls, A2A for agent-to-agent calls, and AG-UI for agent-to-user interaction. AP2 extends A2A and MCP for payments. IBM's ACP was a fourth major protocol until it merged into A2A in August 2025.
Is ACP still maintained?
No. IBM Research announced in August 2025 that the Agent Communication Protocol was merging into A2A under the Linux Foundation and that active ACP development was winding down. The BeeAI platform moved to A2A, and teams running ACP agents should follow IBM's migration guide to A2A.
What is the difference between A2A and ACP?
A2A and ACP both handled agent-to-agent communication. ACP used REST over HTTP with multipart messages, while A2A used JSON-RPC and Agent Cards with declared authentication. The difference is now historical: ACP merged into A2A in 2025, and A2A v1.0 added a REST binding.
Is MCP an agent communication protocol?
Yes, for one hop: an agent talking to tools, resources, and prompts. Delegating tasks between autonomous agents is the job of A2A. Most production systems use both, which is why Bifrost governs MCP and A2A traffic under one set of keys.
Which protocol should a new multi-agent system use?
A new multi-agent system should use MCP for tool and data access and A2A for communication between agents, adding AG-UI if agents stream to a frontend. ACP should not be adopted for new work because development stopped after the merge. Put both protocols behind one gateway so access and logs stay consistent.
Govern Every Agent Communication Protocol with Bifrost
The agent communication protocol landscape has consolidated: MCP for tools, A2A for agents, and ACP folded into A2A. Bifrost governs MCP tool calls, A2A agent calls, and model calls through one gateway, with per-key grants and Agent Logs that tie a task to every model and tool call it made. To see how the Bifrost MCP and Agent Gateway fits your multi-agent stack, book a demo with the Bifrost team.
