The agent interoperability stack is crystallizing around three complementary protocols: MCP for tool connections (97 million monthly SDK downloads), A2A for agent-to-agent communication, and AG-UI for agent-to-user interfaces. Microsoft's Agent Framework RC supports all three. Google's A2A protocol enables agents built on different frameworks to collaborate. Anthropic's MCP, donated to the Linux Foundation in December 2025, has become the universal standard for connecting AI to external tools and data sources. Together, they form the TCP/IP of the agent era — standardized protocols that let any agent talk to any tool, any other agent, and any user interface.

The adoption velocity is extraordinary. MCP went from launch to 97 million monthly downloads in 14 months — faster than OpenAPI (5 years) or OAuth 2.0 (4 years) achieved comparable adoption. Over 10,000 MCP servers are registered. Every major AI lab — Anthropic, OpenAI, Google, Microsoft, AWS — has adopted the protocol. The agent interop stack isn't a proposal; it's the de facto standard for how AI agents connect to the world.

But interoperability standards solve communication, not cognition: agents that can talk to each other through A2A and access tools through MCP still can't share what they've learned, remember previous collaborations, or build on past interactions.

The Three-Protocol Stack

MCP (Model Context Protocol) standardizes how agents connect to external tools and data. A single MCP integration works with Claude, ChatGPT, Cursor, Gemini, and any other MCP-compatible client. Developers build one server; every agent can use it. The 10,000+ registered servers cover databases, APIs, file systems, browsers, and enterprise platforms.

A2A (Agent-to-Agent) standardizes how agents communicate with each other across frameworks. A LangGraph agent can delegate tasks to a CrewAI agent, which can collaborate with a Microsoft Agent Framework agent. A2A defines the message formats, capability discovery, and task delegation protocols that make cross-framework collaboration possible.

AG-UI (Agent-to-User Interface) standardizes how agents present information and collect input from humans. Instead of every agent building its own UI, AG-UI provides common patterns for showing agent progress, requesting approvals, displaying results, and handling human-in-the-loop interactions.

Together, the three protocols form a complete interoperability layer: agents talk to tools (MCP), agents talk to agents (A2A), and agents talk to users (AG-UI). The communication infrastructure is solved. What's missing is the knowledge infrastructure.

Connected But Not Collaborative

The interop stack enables agents to exchange messages, but messages aren't knowledge. When a Claude agent delegates a task to a GPT-5 agent via A2A, it sends task parameters and receives results. The GPT-5 agent doesn't receive Claude's reasoning process, contextual understanding, or accumulated insights. The delegation is transactional, not collaborative.

Consider a realistic multi-agent workflow: a research agent gathers information via MCP, a analysis agent processes the data, and a writing agent produces a report. With A2A, they can delegate tasks to each other. Without shared memory, the analysis agent has no context about why the research agent chose certain sources. The writing agent has no understanding of the analytical methodology. Each agent operates on the inputs it receives, unaware of the broader context that informed the workflow.

MCP tool access compounds the issue. An agent that accesses a database through MCP can query data. But it can't know that another agent queried the same database yesterday and discovered an anomaly. The MCP connection provides access to tools; it doesn't provide access to the knowledge that previous tool interactions generated. Two agents using the same MCP server are parallel users, not collaborators.

Shared Memory as the Fourth Protocol

The interop stack needs a fourth layer: persistent shared memory. MCP connects agents to tools. A2A connects agents to agents. AG-UI connects agents to users. Shared memory connects agents to accumulated knowledge. Without it, the interop stack creates connected strangers — agents that can communicate but can't truly collaborate.

Shared memory in the interop context means cross-agent, cross-framework, cross-provider knowledge persistence. A memory written by a Claude agent is readable by a GPT-5 agent. An insight generated in a LangGraph workflow is available in a Microsoft Agent Framework workflow. Knowledge persists across framework boundaries, provider boundaries, and time boundaries.

How MemU Completes the Interop Stack

MemU provides the persistent memory layer that the agent interop stack requires. Any agent, on any framework, using any model, can write memories to MemU and read memories from MemU. The memory layer is protocol-agnostic — it works alongside MCP, A2A, and AG-UI without requiring modifications to any of them.

For multi-agent workflows, MemU enables genuine collaboration: agents share not just task inputs and outputs but accumulated understanding. The research agent's reasoning is available to the analysis agent. The analysis agent's methodology is available to the writing agent. Every agent benefits from every other agent's experience, regardless of which framework or provider powers it.

MCP, A2A, and AG-UI built the communication layer. MemU provides the knowledge layer. Together, they create the complete infrastructure for truly collaborative multi-agent systems.

Get Started

Add shared memory to your agent interop stack. Explore MemU at memu.pro and on GitHub.