A very well made agent architecture diagram is going around. Seven protocols, each in its box, all the same size, connected by clean arrows. It looks like a map of the territory and it gets shared as one. The problem is that one of those seven wound down development last year, and another is not a layer of the stack but the direct competitor of the one above it.
The short answer: agent protocols do not carry the same weight, and the difference is not technical quality but maturity. Two have neutral governance and production deployments across three clouds. Two are emerging with large-vendor backing. Two are community projects. One no longer exists. A diagram that paints them equal does not help you decide, it helps you share.
What is the real status of each one?
This table is the article. The rest are footnotes.
| Protocol | What it connects | Real status | What to do today |
|---|---|---|---|
| MCP | Agent to tools and data | Standard. Since November 2024, thousands of public servers, neutral governance, Microsoft and Google support | Adopt if you touch several tools |
| A2A | Agent to other agents | Standard. Donated by Google to the Linux Foundation in June 2025, 50+ partners, v1.0, in production across three clouds | Adopt if you integrate with outside agents |
| AG-UI | Agent to the user interface | Emerging with backing. Open event-based protocol; Amazon Bedrock AgentCore runs AG-UI agents natively | Evaluate if you build agentic UI |
| A2UI | Agent to generated interface | Very new. Specification originated by Google, launched alongside Oracle and CopilotKit | Watch |
| UTCP | Agent to native APIs | Community. Open licence, no large-vendor backing, adoption far below MCP | Watch. It is not an MCP layer |
| ANP | Agent to agents on the open internet | Community. Built on W3C decentralized identifiers, aimed at the open web | Watch |
| ACP | Agent to other agents | Shut down. Development wound down in late 2025; its technology was contributed to A2A | Nothing. Evaluate A2A |
A note on why this article has no charts: the honest information here is categorical, not numeric. A maturity diagram with axes and bubbles would look better and would be inventing precision the sources do not provide. Which is exactly the problem the article is about.
Which ones are actually standards?
Two, and it shows in something harder to fabricate than an announcement: where they run.
MCP has been connecting agents to tools and data since November 2024. Its public registry holds thousands of servers, its SDKs are downloaded millions of times a month, and its governance moved to a neutral foundation. When Microsoft and Google implement the same protocol, the debate about whether it will survive is over.
A2A does the equivalent between agents. Google launched it in April 2025 and donated it to the Linux Foundation in June, with more than fifty initial partners including AWS, Microsoft, Salesforce and SAP [1]. It reached v1.0 with cryptographically signed agent cards and today runs inside Azure AI Foundry, Amazon Bedrock AgentCore and Google Agent Engine [3].
That last sentence is the test I use to separate a standard from an announcement: not how many companies signed it, but how many other people's products already run it.
Which one no longer exists and still appears in diagrams?
ACP, and its story is short and useful.
IBM Research launched the Agent Communication Protocol in March 2025 and that same month donated the BeeAI project, and with it ACP, to the Linux Foundation. By late 2025 the team decided to wind down active development and contribute its technology to A2A [1].
This is not a failure: it is healthy consolidation, and the correct way for a standard to die. What is a problem is that it still gets listed as an option in 2026 diagrams. If you are comparing ACP against A2A for a new architecture, you are comparing against something that already merged into the other column.
Why does UTCP not sit under MCP?
Because it is not a layer of it, it is its alternative. And the circulating diagram stacks them.
UTCP describes tools in a JSON manual so the agent calls them directly over their native protocol, with no execution proxy in between. Its argument is lower latency and less abstraction. The project's own documentation has a page dedicated to comparing itself with MCP, and its suggested adoption path starts by using existing MCP servers and later migrating the highest-value tools to native UTCP [2].
That is the definition of a competitor, not a layer. Drawing "MCP, then tools, then UTCP, then REST" implies a flow its authors do not propose.
The rest is worth saying too: it is an open-licence project maintained by a community, without the vendor backing or the adoption of MCP [2]. It can be right on the technical argument and still be premature as an architectural bet.
What is happening at the interface layer?
That is where the genuinely new work is, and it is the part almost nobody discusses.
The whole protocol debate concentrated on agent-to-tools and agent-to-agent. The third boundary, agent-to-person, was left for everyone to solve their own way, with bespoke websockets and event formats invented per project.
AG-UI standardizes that: an open, event-based protocol carrying the live stream between agent and application, including messages, tool calls, state updates and surface events. Amazon Bedrock AgentCore already runs AG-UI agents natively.
A2UI solves something different and newer: letting the agent return interface components, forms, cards and charts as part of its response instead of only text. It is a specification originated by Google, launched together with Oracle and CopilotKit.
The practical distinction between the two: AG-UI carries the interaction, A2UI describes what the user touches. They are used together, not instead of one another.
What to adopt and what to only watch
Three different decisions, and most projects only make the first.
Adopt now when the case calls for it: MCP when the agent touches several tools, A2A when you will integrate with agents you do not control. Both have neutral governance, which means that if the vendor that pushed them changes strategy, the protocol continues.
Evaluate AG-UI if you are building a genuinely interactive agentic interface, with state that changes while the agent works. It is the right answer to a real problem that is currently solved by hand in every project.
Watch without tying architecture to A2UI, UTCP and ANP. All three may end up right. None yet has the backing, the adoption or the time to justify committing a design. Watching costs an hour a quarter; migrating costs a project.
The general test, when protocol number eight appears: ask which other company's product already runs it. An announcement with fifty logos and no outside implementation in production is an intention, not a standard.
How we apply this at MasterDragon
We adopt a protocol only when it replaces work we are already doing by hand.
In practice that means we do not start a project by choosing protocols. We start by solving the case with the most direct integration that works, and adopt the standard when the third similar integration shows up, which is when it stops being overhead and starts being savings. For most of our clients that happens with MCP and never happens with the other six.
We also keep the boundary isolated: the code that speaks the protocol lives apart from the business logic, so switching standards is a module swap rather than a rewrite. With seven candidates and consolidations under way, that separation will pay for itself.
If you are defining an agent architecture and want to know which of these seven is useful to you today, talk to our engineers. You can start with how we build your software and review our portfolio of shipped AI-native products. Which way of extending an agent you need is in MCP, Skills, A2A and multi-agent, the full vocabulary in the agentic AI glossary, and how to design the system so one piece can change without taking down the rest in composable enterprise architecture.
References
- LF AI & Data Foundation. (2025, August 29). ACP joins forces with A2A under the Linux Foundation's LF AI & Data. https://lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a-under-the-linux-foundations-lf-ai-data/
- Universal Tool Calling Protocol. (2026). UTCP vs MCP. https://www.utcp.io/utcp-vs-mcp
- Ehtesham, A., Singh, A., Gupta, G. K., & Kumar, S. (2025). A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP). arXiv:2505.02279. https://arxiv.org/abs/2505.02279
- AG-UI. (2026). Agent User Interaction Protocol: overview. https://docs.ag-ui.com/introduction