Your personal memory, across sessions, agents, and devices.

A2A vs MCP vs AG-UI: The Agent Interop Stack Explained

memU Team memU Team

Three open protocols now cover most of how an AI agent talks to the outside world. MCP connects an agent to tools and data. A2A connects agents to each other. AG-UI connects an agent to the app a person is using. Each shipped a new spec in 2026. MCP and A2A now sit under the same Linux Foundation umbrella. None of them defines memory that lasts beyond a conversation, which is where this post ends.

What is the agent interop stack, in one sentence?

The agent interop stack is the set of open protocols that let an agent call tools (MCP), delegate to other agents (A2A) and stream progress to users (AG-UI).

The AG-UI docs draw the same layers in their introduction, one protocol per boundary. A2A's own comparison page puts it in one line: A2A connects agents to each other, and MCP connects each agent to its own tools.

How MCP, A2A and AG-UI differ

MCP A2A AG-UI
Connects Agent to tools and data Agent to agent Agent to user-facing app
Core objects Tools, resources, prompts Agent Card, task, message, artifact Typed event stream, shared state
Transports stdio, Streamable HTTP JSON-RPC, gRPC, HTTP/REST HTTP with SSE, HTTP with Protobuf
Current version Spec revision 2026-07-28 1.0.0, March 12, 2026 1.0 spec
Started by Anthropic, donated December 2025 Google, April 9, 2025 CopilotKit, public April 9, 2025
Governance LF Projects, in the Agentic AI Foundation Agentic AI Foundation since August 2026 CopilotKit-led open source project

Each protocol owns one boundary, so a single agent can use all three at once. The AG-UI docs say an agent often does exactly that.

What is MCP, and what changed in 2026?

The Model Context Protocol is, in its own words, an open-source standard for connecting AI applications to external systems. A server exposes tools the model can call. It can also offer resources that give the model context, plus prompt templates. Messages are JSON-RPC 2.0, carried over stdio for local servers or Streamable HTTP for remote ones. Authorization is optional and based on OAuth 2.1.

The current spec revision is 2026-07-28, and it is a breaking one. Its changelog removes the initialize handshake and protocol-level sessions, including the session ID header. Tasks moved out of the core spec into an official extension. Roots, Sampling and Logging are deprecated, with a deprecation window of at least twelve months. Any MCP tutorial that starts with the initialize call describes an older revision.

Governance moved too. On December 9, 2025 the Linux Foundation announced the Agentic AI Foundation. MCP was one of its three founding projects. The release counted more than 10,000 published MCP servers at the time.

What is A2A, and how does it relate to MCP?

The Agent2Agent protocol is an open standard for communication and collaboration between AI agents, per its homepage. Google launched it on April 9, 2025 with more than 50 partners. The Linux Foundation took it on as a project on June 23, 2025.

An A2A agent publishes an Agent Card, a JSON document that says who it is and where to reach it. A client sends it a message, which starts a task: a stateful unit of work with its own ID. The agent returns results as artifacts. The key concepts page defines each of these. Agents stay opaque to each other. They collaborate without sharing their internal memory or tools.

Version 1.0 shipped on March 12, 2026, adding multi-tenancy and signed Agent Cards. On August 27, 2026 A2A joined the Agentic AI Foundation as a Growth Stage project, alongside MCP.

What is AG-UI?

AG-UI is an event-based protocol that standardizes how agents connect to user-facing applications, per its introduction. It came out of CopilotKit's work with LangChain and CrewAI. The 1.0 spec sums it up as one request in and one ordered stream of typed events out.

The spec defines 31 event types in eight families. Two of the families are tool calls and reasoning. Shared state is synced with full snapshots and JSON Patch deltas. That is how a front end shows an agent's plan or a half-filled form as it changes. There are first-party SDKs in three languages. The docs list integrations with many frameworks, including Google ADK and the Claude Agent SDK.

Do you need all three protocols?

Only for the boundaries you actually have. A coding agent in your terminal needs MCP for tools and nothing else. A product with an agent embedded in its web app gains the most from AG-UI. A2A pays off when agents built by different teams or vendors must hand work to each other without sharing code.

Start with MCP, because most tools already speak it. The Linux Foundation names Claude, Cursor, Microsoft Copilot, Gemini, VS Code and ChatGPT as adopters. Add A2A at the point where a second agent you do not control enters the system.

Read the fine print

Adoption numbers come from the projects and their foundations. A2A's partner count grew from 50+ at launch to 100+ in June 2025 and to the 150+ organizations its blog claims in August 2026. Those counts are self-reported and measure backers. Neither project publishes how many teams run it in production.

Governance is uneven. MCP and A2A are under the Agentic AI Foundation. The AG-UI pages we read name no foundation, and production support is offered by CopilotKit.

The word "skills" also means two things: A2A skills are entries in an Agent Card, while MCP's Skills extension follows the separate Agent Skills specification.

The bottom line

Treat the three protocols as layers, one per boundary. Build on MCP now and pin the spec revision you target, since 2026-07-28 removed sessions. Add AG-UI if users watch your agent work in an app, and A2A when you need to call agents you did not build.

Where does shared memory fit in the agent interop stack?

None of the three protocols define long-term memory. MCP's base protocol now calls itself stateless and says an open connection is not a conversation or session. A2A groups related tasks under a contextId and lets an agent use it for internal history, but the spec leaves storage to each agent. AG-UI state persists across runs within a single thread. All three carry context while work is in progress, and none stores what an agent learned for a later session.

memU fills that gap for coding agents. It gives hosts such as Claude Code and Codex one shared memory backend. Memories an agent writes from Claude Code can be retrieved from Codex, and the reverse. The agent decides what to remember and writes it as readable Markdown files. memU makes no LLM calls of its own. It stores and embeds what the agent wrote, then returns it on request. A standing instruction in CLAUDE.md or AGENTS.md tells the agent to retrieve first. The reasoning behind that split is in why memU leaves the thinking to the agent.

To try the hosted version, get an API key from memu.so and send your agent one message:

Read https://memu.pro/SKILL.md, follow its instructions to install and configure memU, API Key is YOUR_MEMU_API_KEY.

The self-hosted setup and the support matrix are in the memU GitHub repository.

FAQ

What is the difference between A2A and MCP?

MCP connects one agent to its tools and data. A2A connects separate agents so they can delegate tasks to each other without sharing internals. A2A's docs call MCP vertical and A2A horizontal.

Is A2A replacing MCP?

No. A2A's homepage says it is not a replacement for MCP, and both are now projects of the Linux Foundation's Agentic AI Foundation.

Does MCP or A2A store agent memory?

No. MCP's current spec describes it as a stateless protocol. A2A lets an agent keep history under a contextId but leaves storage to each agent.

What is the latest MCP spec version?

The current revision is 2026-07-28. It made MCP stateless by removing the initialize handshake and protocol sessions, and moved tasks into an extension.

Who governs MCP and A2A?

Both sit under the Agentic AI Foundation at the Linux Foundation. MCP was a founding project in December 2025, and A2A joined in August 2026.