MCP vs A2A (2026): What Each Protocol Does, and the Missing Memory Layer for Agents

TL;DR

MCP and A2A solve different problems, and most companies running agents will use both. The Model Context Protocol (MCP), created by Anthropic in November 2024 and now governed by the Linux Foundation's Agentic AI Foundation, connects an agent to tools and data: it gives agents hands. The Agent2Agent protocol (A2A), announced by Google in April 2025 and production-stable since version 1.0 in March 2026, lets agents from different vendors hand work to each other: it gives them a voice. Neither one defines shared memory, and A2A is explicitly designed so agents can collaborate "even when they don't share memory, tools and context". That gap is where company memory sits. Sentra is the managed organization memory that fills it today: one memory of what the company has decided and what changed, which every agent reads over MCP and REST with the permissions of the person it acts for.

What is MCP?

The Model Context Protocol is an open standard for connecting AI applications to the systems where data lives. Anthropic announced it on 25 November 2024, and in December 2025 donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded by Anthropic, Block and OpenAI.

• Roles: hosts (the AI application), clients (the connector inside it) and servers (the system being connected).
• What servers offer: tools the model can call, resources it can read (each identified by a URI) and prompt templates.
• Transports: stdio for local servers and Streamable HTTP for remote ones, per the 2026-07-28 specification.
• Authorization: optional, and when used over HTTP it is based on OAuth 2.1, with the server acting as a resource server and tokens bound to the specific server they were issued for.
• Change notifications: clients can subscribe to a resource and be told when it changes.

What is A2A?

The Agent2Agent protocol is an open standard for agents to discover each other and delegate work. Google announced it on 9 April 2025, transferred it to the Linux Foundation in June 2025, and version 1.0 shipped on 12 March 2026 as the first production-ready release, adding signed Agent Cards and multi-tenancy. The Linux Foundation reported more than 150 supporting organizations after one year.

• Agent Card: a JSON description of an agent's identity, skills, endpoint and authentication.
• Task: a stateful unit of work with a lifecycle, which can wait for input or finish later.
• Messages, parts and artifacts: the turns exchanged and the outputs produced.
• Push notifications: asynchronous updates sent to a webhook the client provides.
• Opaque execution: agents share declared capabilities and exchanged information, not their internal plans or memory.

MCP vs A2A compared

The short version: use MCP when an agent needs to reach a system, and A2A when one agent needs another agent to do something. A company with dozens of agents will run both.

The missing layer: shared company memory

Neither protocol tells agents what the company has decided. That is a problem as soon as a company runs more than a handful of agents from different vendors.

• Agents contradict each other. Legal pauses a customer's pricing on Friday. One agent heard; another, set up by a different team, sends the old offer on Monday. Both followed their protocols correctly.
• Pairwise syncing does not scale. Keeping agents in sync by messaging each other needs a channel for every pair: 10 for five agents, 4,950 for a hundred, and every channel is another place for the truth to split.
• Delegation passes only what the sender includes. In A2A, the receiving agent sees what the delegating agent put in the task message. If the sender did not know a decision changed, neither does the receiver.
• Learning stays trapped. What one agent learns stays in its session or its vendor's product.

Research on agent architecture reaches the same conclusion. The AIOS paper on an LLM agent operating system puts memory management, context management and access control in the kernel, as shared services every agent uses, and MemGPT models agent memory on an operating system's memory hierarchy. An agent OS needs a memory layer that is not owned by any single agent.

What a shared memory layer has to do

For hundreds of agents to work inside one company without contradicting each other, the memory they share needs five properties.

1. One source, many readers. Every agent, from every vendor, reads the same current facts.

2. Time on every fact. When a decision is reversed, the old value is superseded, not left to compete with the new one.

3. A receipt for every fact. A source, a date and who confirmed it, so an agent can show its premises.

4. Permissions that follow the source. An agent sees only what the person it acts for could see in the original tool.

5. A record of what agents did. What an agent reports stays a claim until a person or a system of record confirms it.

How Sentra fits with MCP and A2A

Sentra is the managed organization memory for teams and AI agents. It reads Slack, email, meetings, calendars and project tools, resolves what they say into facts with their source and time, and keeps them current as things change.

• Over MCP: Claude, ChatGPT, Cursor and other MCP clients connect to Sentra's remote MCP server and read company memory with the user's own permissions. In Claude Code it is one command: claude mcp add --transport http sentra https://api.sentra.app/mcp/.
• Over REST: custom agents and platforms query the same memory through the API.
• Alongside A2A: agents can delegate work to each other over A2A while each checks the same company memory, so delegation stops carrying stale context.

The result is the layer neither protocol defines: agents get hands from MCP, a voice from A2A, and judgment from a memory the company owns.

Frequently Asked Questions