AI Agent Interoperability Protocols in 2026: MCP, A2A & the ACP Merger

Through 2025, teams building multi-agent systems had to pick from a fragmented set of overlapping specs for agent-to-tool and agent-to-agent communication, then defend that choice to every reviewer who asked "why this protocol and not the other one." By the middle of 2026, that fragmentation has largely resolved. The agentic AI protocol layer consolidated around a small set of open, vendor-neutral standards, and that consolidation directly changes how you should think about — and diagram — a multi-agent architecture.

This post is a state-of-the-ecosystem summary, not a protocol tutorial. For the mechanics of each protocol, see our deep-dives on MCP architecture and A2A protocol architecture (which also includes a detailed A2A vs. MCP comparison table). Here, the focus is on what changed at the ecosystem level and what that means for the diagrams you produce today.

What actually happened: ACP merged into A2A

ACP (Agent Communication Protocol) was an open, REST-based standard originally developed by IBM's BeeAI team to cover agent-to-agent, agent-to-application, and agent-to-human communication. Rather than compete indefinitely with Google's A2A protocol over largely overlapping ground — both were solving for how one agent hands off work to, or communicates with, another agent or a human — the two efforts converged. ACP merged into A2A. Its agent-to-agent and agent-to-human communication patterns were folded into the A2A specification rather than continuing as a separate, parallel standard.

At the same time, governance moved out from under any single vendor. MCP (Model Context Protocol, originally released by Anthropic), A2A, and ACP now sit under the Linux Foundation's Agentic AI Foundation, established in early 2026, with Anthropic, Google, IBM, and other organizations contributing under open governance. That matters as much as the ACP merger itself: it means the protocol stack you diagram today isn't a single company's proprietary interface, it's a shared, multi-stakeholder standard with the kind of neutral stewardship that procurement and compliance teams expect from foundational infrastructure (the way they'd expect it from, say, Kubernetes or gRPC).

The resulting layering: vertical and horizontal

With ACP absorbed into A2A and all three specs under one open governance umbrella, the practical architecture has settled into two clean layers:

• MCP — vertical integration. Standardizes agent-to-tool and agent-to-data communication: an agent calling a database, a file system, a search API, or any other external tool or data source. MCP has grown into the dominant tool-integration standard, with a large and fast-growing ecosystem of community-built servers covering everything from cloud infrastructure to SaaS APIs.
• A2A — horizontal and human-facing integration. Having absorbed ACP's patterns, A2A now standardizes both agent-to-agent delegation (one agent handing a subtask to another) and agent-to-human communication (an agent surfacing a decision, an approval request, or a status update to a person). One protocol now covers both directions that used to require picking between A2A and ACP.

The net effect: instead of asking "MCP, A2A, or ACP, and how do they interoperate," you're asking a much simpler question — does this connection go to a tool (MCP) or to another agent or a human (A2A)? That's a two-layer mental model, not a three-way negotiation.

Protocol layer in 2026

Why this matters for your architecture diagrams

Before consolidation, an accurate architecture diagram for a multi-agent system often had to show a bespoke or proprietary communication layer, because there wasn't a settled standard to point to — and reviewers had to trust that your bespoke choice was reasonable. Now, a diagram can show a clean, recognizable protocol stack: MCP arrows for every agent-to-tool call, A2A arrows for every agent-to-agent handoff, and (if you want to call it out separately) A2A arrows labeled distinctly for agent-to-human touchpoints like approvals.

That legibility compounds across audiences. A design reviewer can scan the diagram and immediately know which layer a given arrow belongs to without reading a legend of custom protocol names. An auditor or security reviewer can reason about trust boundaries at the protocol level — MCP calls typically cross into tool/data systems, A2A calls typically cross into other autonomous agents or out to a human — instead of having to first learn your team's internal naming for a proprietary RPC layer. A new engineer joining the team can map the diagram directly onto public documentation instead of onto tribal knowledge. And for procurement or compliance documentation, citing an open, Linux Foundation-governed protocol stack is a much easier sell than citing a single vendor's interface, because the standard isn't controlled by — or dependent on the continued goodwill of — any one company.

Prompt templates for diagramming the consolidated stack

Enterprise customer-service multi-agent system

Human-in-the-loop approval workflow

Key takeaways for architects

• Two layers, not three. Design and diagram against MCP (agent ↔ tool) and A2A (agent ↔ agent, agent ↔ human) — ACP is no longer a separate target for new architecture.
• Open governance is a diagram-worthy fact. Citing Linux Foundation Agentic AI Foundation stewardship in design docs and compliance materials is a stronger, more durable claim than citing a single vendor's protocol.
• Distinguish agent-to-human A2A traffic when it exists. If your system has approval steps or other human touchpoints, label those A2A arrows separately from agent-to-agent delegation arrows — reviewers care about where a human sits in the loop.
• MCP server sprawl is now the main integration surface to track. As the MCP ecosystem of community-built servers keeps growing, keep an explicit inventory of which MCP servers each agent calls — it's your tool-level attack surface and audit trail.
• Revisit older diagrams that show proprietary or bespoke agent-comms layers. If a diagram predates the consolidation, it likely models agent-to-agent or agent-to-human communication as a custom internal protocol that can now be redrawn as standard A2A.

FAQ

What happened to ACP?

ACP (Agent Communication Protocol), the open REST-based standard originally developed by IBM's BeeAI team, merged into A2A. Its agent-to-agent, agent-to-application, and agent-to-human communication patterns are now part of the A2A specification rather than a competing standard. New projects should target A2A directly rather than ACP.

Do I need to diagram MCP and A2A separately?

Yes — they represent different kinds of connections and different trust boundaries. MCP arrows represent an agent calling a tool or data source; A2A arrows represent one agent delegating to another agent, or an agent communicating with a human. Using a distinct arrow style or color for each layer makes the diagram legible to reviewers who need to reason about tool access separately from agent-to-agent delegation.

Which protocol should new multi-agent projects standardize on?

Use MCP for anything that looks like an agent calling a tool or retrieving data, and A2A for anything that looks like one agent handing work to another agent or communicating with a human. Both are governed by the Linux Foundation's Agentic AI Foundation with Anthropic, Google, IBM, and other contributors participating under open governance, so standardizing on this pair — rather than a proprietary in-house protocol — keeps the architecture aligned with where the rest of the ecosystem, and your future integration partners, already are.

Related guides: A2A protocol architecture, MCP architecture diagram, multi-agent orchestration patterns, and securing agentic AI systems.