It feels like every other month, there is a new agent protocol and it’s getting hard to keep track of which protocol is used when. Recently, I looked into some of the main agent protocols and in this post, I will provide a high-level overview of MCP, A2A, A2UI, and AG-UI.
TLDR
If you’re too busy or too impatient to read the whole blog post, here’s a summary of the protocols along with links to samples in my repository:
| Protocol | Description |
|---|---|
| Model Context Protocol (MCP) | An open protocol, from Anthropic, that standardizes how models and agents access external tools and resources |
| Agent2Agent Protocol (A2A) | An open protocol, from Google, that standardizes how agents running on diverse frameworks and platforms communicate |
| Agent-User Interaction Protocol (AG-UI) | An open protocol, from CopilotKit, that standardizes how agents communicate with user interfaces |
| Agent to UI Protocol (A2UI) | A generative UI protocol, from Google, that enables AI agents to generate rich, interactive user interfaces across web, mobile, desktop |
Let’s now look into each protocol in more detail.
Model Context Protocol (MCP)
Model Context Protocol (MCP) is an open protocol from Anthropic that standardizes how models and agents access external tools and resources.
It has three distinct parts:
| Who controls it? | Use Cases | |
|---|---|---|
| Tools | Model-controlled: Model decides when to call these | Allow LLM to interact with external systems |
| Resources | App-controlled: App decides when to call these | Provide read-only access to data for the LLM or client application. |
| Prompts | User-controlled: The user decides when to use these | Reusable message templates that help LLMs generate structured, purposeful responses. |
While most people use MCP for tools, it can also be used for resources and prompts. You can also implement your own MCP server with FastMCP in Python, and there are other more advanced features of MCP such as elicitation, sampling, progress, and more.
MCP is the oldest and most mature of the protocols discussed in this post. It is also probably the most widely adopted protocol.
You can check out my MCP samples repo for more details. I also have an MCP presentation that accompanies the samples.
Agent2Agent Protocol (A2A)
Agent2Agent (A2A) Protocol is an open protocol from Google that standardizes how agents running on diverse frameworks and platforms communicate.
While MCP mainly deals with agent-to-tool calls, A2A deals with agent-to-agent communication. It is a more recent
protocol compared to MCP and is still evolving. You can wrap an agent with the AgentExecutor interface to make it A2A
compatible or use an agent framework like ADK to simplify your MCP and A2A communication.
You can check out my A2A samples to see A2A implemented in different languages (Python, C#) and how the Agent Development Kit (ADK) simplifies A2A communication.
I also have an A2A presentation that accompanies the samples.
Agent-User Interaction Protocol (AG-UI)
AG-UI is an open, lightweight, event-based protocol, created by CopilotKit, that standardizes how agent backends connect to agent frontends.
On the client side, CopilotKit is the reference client implementation of AG-UI but there are other clients. On the agent side, most major agent frameworks such as LangGraph, CrewAI, Google ADK, and more are supported.
You can read more details on the AG-UI protocol in the Core architecture and Events docs.
AG-UI vs. MCP, A2A
At this point, you might be wondering how AG-UI relates to MCP and A2A:
- MCP gives agents tools.
- A2A allows agents to communicate with other agents.
- AG-UI brings agents into user-facing applications.
See MCP, A2A, and AG-UI and my AG-UI samples for more details.
Agent to UI Protocol (A2UI)
Agent to UI Protocol (A2UI) is a generative UI protocol, created by Google, that enables AI agents to generate rich, interactive user interfaces across web, mobile, and desktop. The idea is that instead of building UIs for your agents, you can let them generate UIs from a predetermined list of UI widgets.
Despite similar names, AG-UI and A2UI serve very different and complementary roles in the agentic application stack:
- AG-UI connects your user-facing application to any agentic backend.
- A2UI is a declarative generative UI spec, which agents can use to return UI widgets as part of their responses.
See AG-UI and Generative UI Specs and AG-UI and A2UI for more details.
Conclusion
In this blog post, I provided a high-level overview of MCP, A2A, AG-UI, and A2UI. In the next blog post, I will deep dive into the AG-UI and A2UI protocols in more detail. To learn more, here are some resources: