Published 25 March 2026. Updated 5 November 2026: rewritten against the MCP 2026-07-28 specification and the A2A 1.0 specification, both read on 5 November 2026, with new sections on authentication, delegated tokens across agent hops, and what context and memory cross an A2A call. Several figures from the first version could not be sourced again and have been removed.
MCP connects an agent to tools and data; A2A connects an agent to another agent. The Model Context Protocol (MCP) is a client-server protocol in which an AI application calls servers that expose tools, resources and prompts, and as of the 2026-07-28 revision every request is stateless and self-contained. The Agent2Agent Protocol (A2A) is a peer protocol in which one agent discovers another through an Agent Card, hands it a task, and follows that task through a lifecycle that can run for hours and pause for a human. Both specifications say the two are complementary, and the A2A spec states the relationship in one line: a client agent asks a server agent to do a task over A2A, and the server agent "might use MCP" to reach the tools it needs to finish it.
That division of labour has held since both protocols launched. What has moved is where the real decisions sit. MCP dropped sessions and its initialize handshake in July 2026, A2A shipped 1.0 and joined the Linux Foundation's Agentic AI Foundation in August, and the hard questions in a multi-agent system have moved from "which protocol" to two others: whose authority does the second agent act under, and what does it get to keep once the task is done.
MCP vs A2A at a glance
| Dimension | MCP (revision 2026-07-28) | A2A (specification 1.0) |
|---|---|---|
| Connects | An AI application (host and client) to servers exposing tools, resources and prompts | An agent (client) to an independent, often opaque agent (server) |
| Unit of work | A request, such as tools/call or resources/read | A Task with states, messages and artifacts |
| Wire format | JSON-RPC 2.0 | Protocol-agnostic data model defined in a2a.proto, bound to JSON-RPC, gRPC and HTTP+JSON/REST |
| Transports | stdio and Streamable HTTP; the older HTTP+SSE transport is Deprecated | HTTPS for HTTP bindings, TLS for gRPC, both required in production |
| State | Stateless requests; cross-call state lives in server-minted handles passed as tool arguments | contextId groups related tasks and messages; the agent decides what it keeps behind it |
| Discovery | server/discover (required) plus tools/list, resources/list, prompts/list | Agent Card at /.well-known/agent-card.json, a registry, or direct configuration; cards can be JWS-signed |
| Authorization | Optional; for HTTP, OAuth 2.1 with Protected Resource Metadata, resource indicators, audience-bound tokens and no token passthrough | Schemes declared in the Agent Card (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS); credentials obtained out of band; TASK_STATE_AUTH_REQUIRED for mid-task authorization |
| Long-running work | Official Tasks extension (io.modelcontextprotocol/tasks) with polling | Core: streaming, task subscription, push notifications to a webhook |
| Created by | Anthropic, 25 November 2024 | Google, 9 April 2025 |
| Governed by | Model Context Protocol a Series of LF Projects, LLC, within the Agentic AI Foundation | Linux Foundation project since 23 June 2025; Growth Stage project at the Agentic AI Foundation since August 2026 |
Every row comes from the two specifications and the announcements linked in the sections below, read on 5 November 2026.
What MCP does in 2026
MCP standardises how an agent reaches the outside world. A host (the AI application) runs one client per server, and each server offers any of three features: tools the model can call, resources that carry context and data, and prompts that template a workflow for the user. On the client side the only active feature for new implementations is elicitation, in which a server asks the user for more information; the 2026-07-28 changelog deprecates Roots, Sampling and Logging, and suggests passing directories as tool parameters, calling an LLM provider directly instead of sampling, and logging to stderr or OpenTelemetry instead. For a longer walk through servers and their primitives, see MCP Servers Explained.
The 2026-07-28 revision changed the protocol's shape more than any release before it. It removed protocol-level sessions and the Mcp-Session-Id header, removed the initialize handshake so that each request now carries its protocol version and client capabilities in _meta, made server/discover mandatory for servers, and replaced server-initiated requests with a multi round-trip pattern in which the server returns input_required and the client retries with the answers. The spec overview now lists the base protocol's first property as "Stateless, self-contained requests." Any state that has to survive between calls now lives in an explicit handle the server mints and the client passes back as an ordinary tool argument. We documented every breaking change and the error each one causes in MCP 2026-07-28: 20 Breaking Changes and the Errors They Cause.
Two transports are standard: stdio for a server running as a local subprocess, and Streamable HTTP for a remote server. The first version of this post listed "HTTP/SSE", which was accurate in early 2025; the HTTP+SSE transport has been deprecated since protocol version 2025-03-26 and the 2026-07-28 changelog reclassifies it as Deprecated under the new feature lifecycle policy, so new servers should not use it.
MCP has no concept of another agent. A server can sit in front of anything, including an agent, but the caller sees a tool with an input schema and a result, not a peer with its own plan.
What A2A does in 2026
A2A standardises how one agent asks another for help when neither can see inside the other. The specification's own goal statement is that agents should "securely exchange information to achieve user goals without needing access to each other's internal state, memory, or tools", and that design choice, opacity, is what separates it from a tool call.
The moving parts are few. An Agent Card is a JSON document describing an agent's identity, skills, service endpoint, supported interfaces and authentication requirements; a client finds it at https://{server_domain}/.well-known/agent-card.json, in a curated registry, or through direct configuration. A Task is the unit of work, with states that include TASK_STATE_WORKING, TASK_STATE_INPUT_REQUIRED, TASK_STATE_AUTH_REQUIRED, TASK_STATE_COMPLETED and TASK_STATE_REJECTED. A Message carries a role, an array of Parts (text, raw file bytes, a file URL, or structured JSON data) and optional metadata, and the agent's outputs come back as Artifacts. Clients can send a message and wait, stream updates, subscribe to an existing task, poll it, or register a webhook for push notifications, which is why the spec calls the protocol "async first".
A2A 1.0.0 was tagged on 12 March 2026, with a 1.0.1 patch tag on 28 May 2026, according to the project's GitHub releases. The v1.0 release notes page lists the changes that matter for anyone who read an older explainer: a2a.proto became the single normative definition, the protocol now has three formally specified bindings (JSON-RPC, gRPC and HTTP+JSON/REST) with equivalence guarantees, enum values moved to SCREAMING_SNAKE_CASE (a breaking change), Agent Cards can be signed with JWS, the OAuth flows gained Device Code and PKCE and lost implicit and password, and listing tasks uses cursor pagination. Explainers that describe A2A only as "HTTP plus SSE plus JSON-RPC" are describing the early protocol; in 1.0 JSON-RPC is one of three equal bindings.
How each protocol handles authentication
The two specifications take opposite approaches to authorization: MCP specifies a flow, and A2A declares requirements and leaves the flow to the deployment.
MCP specifies the flow. Authorization is optional, and when an implementation uses an HTTP transport it "SHOULD conform" to the spec, while a stdio server "SHOULD NOT" and takes credentials from its environment instead. A protected MCP server acts as an OAuth 2.1 resource server. It must publish OAuth 2.0 Protected Resource Metadata (RFC 9728) so clients can discover its authorization server, clients must send the resource parameter from RFC 8707 naming the exact server they want a token for, and the server must reject any token not issued for it as the audience. The spec then closes the door that matters most in a chain: "MCP servers MUST NOT accept or transit any other tokens." The MCP security best practices call forwarding a client's token to a downstream API "token passthrough" and say it is explicitly forbidden. The 2026-07-28 revision also deprecates Dynamic Client Registration in favour of Client ID Metadata Documents and requires clients to validate the iss parameter in authorization responses when present.
A2A declares the requirements and leaves the flow to the deployment. The spec says "Identity information is handled at the protocol layer, not within A2A semantics." A client reads the securitySchemes in the Agent Card, obtains credentials "through an out-of-band process", and sends them with every request; the server must authenticate every request and then authorizes it under its own policies, which may consider the skill requested, the data touched or OAuth scopes. Two further rules carry weight for enterprise buyers. Section 13.1 requires servers to scope every result to the caller's authorised boundaries even when no contextId is supplied, whether the model is per user, per role, per project or per tenant. And when an agent needs new authority in the middle of a task (an OAuth token for another API, or a human's approval before a destructive action), it moves the task to TASK_STATE_AUTH_REQUIRED and the client resolves it, possibly by pushing the same state up to its own client, which forms what the spec calls "a chain of Tasks".
What A2A deliberately does not define is just as important. Section 7.6.4 says the protocol "does not define the scope, representation, validity, or revocation semantics" of the credential obtained that way, and that entering the auth-required state is not, by itself, authorization for anything.
What happens to a user's authority across an agent-to-agent hop
Once a request crosses two or three agents, the authentication question becomes a delegation question: when Agent B calls a billing API because Agent A asked it to on behalf of a user, whose authority is it spending, and how much of it? WorkOS published the clearest current answer on 29 October 2026 in Why agent-to-agent chains need per-hop delegated tokens, and its argument holds up against both specs.
The pattern WorkOS warns against is one long-lived credential, often held by an MCP server, that every hop can use. It names three consequences: authority becomes ambient (a manipulated translation agent can reach the billing API), identity disappears (the API only sees "the MCP server did it"), and trust becomes transitive (Agent C accepts Agent B because B is internal, so one compromised hop becomes a launchpad for every hop after it). The post ties this to research by Syed Anas Mohiuddin, as reported by The Next Web, on what he calls protocol pivoting: text planted in an MCP tool result, shaped like an A2A task, which an orchestrator passes to a subagent that runs it "because it trusts the orchestrator".
The fix is authority that narrows at every hop. Each hop gets its own token, issued for that hop, for one audience, with the narrowest scopes the call needs, a short lifetime, and the identity of everyone upstream. The pieces already exist as standards: OAuth 2.0 Token Exchange (RFC 8693) lets a service trade the token it received for a new one aimed at the next resource, RFC 8707 binds that token to one audience, and MCP's no-passthrough rule forces the exchange instead of a forward. WorkOS is careful to note that the MCP authorization spec does not prescribe token exchange for downstream calls; it forbids passthrough and requires audience validation, and token exchange is the standard OAuth way to meet both. Our reading of the 2026-07-28 text on 5 November matches that description.
One detail of RFC 8693 is easy to miss and changes how you write policy. A token can record the whole chain by nesting act (actor) claims, with the outermost act as the current actor and the deepest as the first, but the RFC says prior actors "are informational only and are not to be considered in access control decisions." The chain is an audit trail, not a permission set. If Agent C should never act for a user who came in through a particular front-end agent, that rule has to be enforced when the authorization server issues C's token, not by C reading the nested claims afterwards.
A2A's own guidance points the same way. When credentials are passed in-band along a chain of A2A agents, the spec warns that this exposes them "to each agent participating in the chain" and recommends binding each credential to the agent that requested it and encrypting anything sensitive so only that agent can read it.
WorkOS also describes how its own product applies this, and those details are vendor-reported, from WorkOS's post and the documentation it links rather than anything we tested. In its Agent Auth feature an agent can present its access token to mint a child session, access tokens last at most one hour, and revoking a session also revokes every session chained under it; the act claim on a delegated session identifies the delegating user but does not list every intermediate hop, and chaining uses WorkOS's own minting API rather than RFC 8693 exchange. WorkOS also states what per-hop tokens do not buy: they do not stop prompt injection, since a manipulated agent will still try the wrong thing, and they do not fix server-side request forgery, which needs its own controls on redirects and private IP ranges. What changes is the blast radius.
What context and memory cross an A2A hop
A token decides what the next agent may do. It says nothing about what the next agent is told, or what it keeps afterwards, and in a multi-agent system that second question is where data quietly spreads.
On the wire, an A2A hop carries what the client puts in the message: text, files and structured data as Parts, free-form metadata, and a contextId and taskId that tie the exchange to earlier ones. The server can return task history, and the client controls how much with historyLength, from none to "server default, possibly all". By design, nothing else crosses. The remote agent never sees the caller's memory, tools or internal state, and the caller never sees the remote agent's.
The other half of the picture is what the spec permits the remote agent to do with what it received. Section 3.4.1 says agents "MAY use the contextId to maintain internal state, conversational history, or LLM context across multiple interactions" and "MAY implement context expiration or cleanup policies and SHOULD document any such policies". In practice that means a billing specialist agent that receives a customer's account history to resolve one ticket can keep it, summarise it, embed it and use it on the next ticket, and the protocol defines no deletion, no provenance and no scope for that memory. Those are left to whoever runs the agent. Our reading is an inference from the spec's silence rather than a stated rule, but the silence is explicit: A2A standardises the conversation between agents, not the memory either side forms from it.
Per-hop tokens are therefore necessary but not sufficient. Revoking Agent B's token stops B's next call; it does not reach the facts B already wrote down while it held the token. We covered that gap in AI Agent Deprovisioning: Revoking Access Does Not Erase What the Agent Remembered, and the multi-agent version of it (which agent may write what, scoped to which user and tenant, with what provenance) in Multi-Agent Shared Memory. Reading the two specs together gives four working rules:
- Send the minimum in Parts. Pass the facts the remote agent needs for this task, not the whole conversation, and set
historyLengthdeliberately rather than taking the server default. - Treat every memory a remote agent forms as data written under a delegation. Record which user, which upstream agent and which token it came through, so that revoking the delegation can find and purge what was derived from it.
- Scope memory before retrieval, by user and tenant, the same way A2A section 13.1 scopes task results to the caller. A shared memory store that any agent can read back undoes the narrowing your tokens achieved.
- Ask every partner agent for its context expiration policy before sending it personal data. The spec says agents SHOULD document one, so treat a partner that cannot produce it as one that keeps what it receives indefinitely.
Maximem Synap is built around the memory half of this. Several agents share a central context layer while keeping their own agent-specific memories, isolation runs through a scope chain of client, customer and user plus conversation, and every memory carries provenance: where it came from, what it replaced and why it changed. Agents reach it through Python and TypeScript SDKs, a REST API, framework adapters, or a hosted MCP endpoint whose four tools log an exchange, check that it finished processing, recall context and list recent memories.
One request, both protocols: a worked example
A customer emails a support system about a billing charge. The flow below uses both protocols and the 2026 authorization model.
- The support agent receives the request. It is authenticated as acting for this customer.
- MCP, agent to tool. The support agent calls a CRM server's
tools/callover Streamable HTTP with a token issued for that server alone, and gets the account history back. - MCP again. It reads the refund policy as a resource from a document server, with a separate token for that server.
- A2A discovery. The case needs a billing specialist. The support agent reads the billing agent's Agent Card, sees it requires OAuth 2.0 with specific scopes, and obtains a token for that agent through its authorization server, with itself recorded as the actor for the customer.
- A2A, agent to agent. It sends a Message with two Parts: a short text summary and a structured data Part holding only the invoice lines in dispute, not the full CRM history.
- Mid-task authorization. The billing agent needs to issue a refund above a threshold. It moves the task to
TASK_STATE_AUTH_REQUIRED; the support agent passes the request up to a human approver, who approves out of band. - The billing agent uses its own MCP servers. It calls the payments API through its own MCP client, with a token it obtained by exchange for the payments server, never by forwarding the token it received in step 4.
- A2A result. The billing agent completes the task and returns an Artifact with the refund reference.
- The support agent replies to the customer.
MCP ran three times (steps 2, 3 and 7) and A2A carried the task from step 4 to step 8. Four hop tokens were issued after the customer's own sign-in, one per audience, and if the authorization server records the chain as act claims, the payments API can see both the customer and the agents that led to the call. What the billing agent remembers about this customer after step 8 is still its own decision, and neither protocol governs it.
When to use MCP, A2A, both, or neither
Use MCP when one agent needs tools or data. Almost every agent that touches an API, a database or a document store fits, and MCP is the standard interface for it. If your agents run in one process and you control all of them, MCP plus your framework's own orchestration is often all you need.
Add A2A when the other side is an agent you do not control. A2A earns its keep at an ownership boundary: another team's agent, a vendor's agent, a partner's agent, anything you cannot see inside and that may run for hours, ask for input or need fresh authorization mid-task. Discovery, task lifecycle and the auth-required state are what you would otherwise build by hand.
Use both for cross-boundary systems, which is where most enterprise designs end up: A2A between agents, MCP inside each agent. Budget for the authorization server and token exchange from the start, because retrofitting per-hop tokens onto a chain that grew up around one shared credential is the expensive path.
Use neither between functions in your own code. Two subagents in the same process that share a framework do not need a network protocol to talk to each other, and wrapping them in A2A adds latency and an authentication surface for no gain.
Governance and versions, and what we corrected
Both protocols now sit in the same house. Anthropic launched MCP on 25 November 2024 and donated it to the Linux Foundation's new Agentic AI Foundation (AAIF) on 9 December 2025; MCP's governance page names the project "Model Context Protocol a Series of LF Projects, LLC". Google announced A2A on 9 April 2025 with "more than 50 technology partners", the Linux Foundation launched the A2A project on 23 June 2025, and on 27 August 2026 the A2A project announced that it had been accepted as a Growth Stage project at the AAIF, alongside MCP, goose and AGENTS.md.
The current versions on 5 November 2026 are MCP 2026-07-28 (previous revision 2025-11-25) and A2A 1.0 (previous 0.3.0). MCP now runs a feature lifecycle policy with a minimum twelve-month deprecation window, which makes its deprecations easier to plan around than they were.
The first version of this post carried several figures we could not trace to a primary source on 5 November 2026: monthly MCP SDK downloads and a count of active servers attributed to Anthropic, a "100+" A2A partner count, a Gartner forecast about enterprise applications and a telecom-specific A2A variant. We removed them rather than leave unsourced numbers in place; the only adoption figure kept is Google's own "more than 50 technology partners" at launch.
Frequently asked questions
Is A2A part of MCP?
No. They are separate specifications run as separate projects, both now under the Linux Foundation's Agentic AI Foundation. A2A's specification has an appendix on its relationship to MCP that describes them as complementary: A2A for agents working with agents as peers, MCP for an agent working with tools and resources.
Can A2A replace MCP, or MCP replace A2A?
Only at the edges. You can put an agent behind an MCP server, but the caller then sees a tool with structured input and output, with no task lifecycle, no auth-required state and no way to hold a multi-turn exchange. You can ask a remote agent over A2A to reach a system for you, but only if that agent already has access, and it will usually use MCP to get it.
Does MCP still use SSE?
Not for new work. The 2026-07-28 revision defines stdio and Streamable HTTP as the standard transports and classifies the older HTTP+SSE transport as Deprecated. Server-sent events still appear inside Streamable HTTP responses, but the 2026-07-28 revision removed stream resumability, so a broken stream means re-issuing the request.
Is MCP stateful?
Not at the protocol level as of 2026-07-28. Sessions, the Mcp-Session-Id header and the initialize handshake were removed, and each request carries its own version and capabilities. A server that needs state across calls mints a handle and the client passes it back as a tool argument.
How does authentication differ between MCP and A2A?
MCP specifies an OAuth 2.1 flow for HTTP servers, with audience-bound tokens and a ban on token passthrough. A2A has each agent declare its accepted schemes in its Agent Card, leaves credential acquisition out of band, and adds an auth-required task state for authority needed mid-task, without defining the credential's scope or revocation.
What should be in the token when one agent calls another?
A token issued for that one hop: one audience, the narrowest scopes the call needs, a lifetime in minutes, and the upstream user and agents recorded, for example as nested RFC 8693 act claims. Obtain it by token exchange at an authorization server rather than forwarding the token you received.
Do agents share memory over A2A?
No. A2A carries messages, parts, artifacts, metadata and context identifiers, and the specification states agents collaborate without access to each other's internal state or memory. The receiving agent may still keep what it was sent, and the protocol leaves retention and deletion to whoever runs it.
How does RAG relate to MCP and A2A?
RAG is a retrieval pattern, not a protocol. An agent can run its retrieval step as an MCP resource or tool call, or ask another agent over A2A to retrieve and summarise, and neither protocol changes how the retrieval itself works.
Which should I learn first?
MCP, because almost every agent needs tools and data before it needs a peer. Learn A2A when your system has to work with an agent another team or company runs, and learn token exchange at the same time.
The two protocols settled the plumbing question in 2026: MCP for depth inside an agent, A2A for reach across agents. The questions that decide whether a multi-agent system is safe to run are the ones neither protocol answers on its own, namely how much authority each hop carries and what each agent keeps after the hop ends. Teams that answer both up front get agents that can work across team and company boundaries without every new partner agent becoming a new audit finding.



