---
title: What is the difference between MCP and A2A?
url: https://opencontroller.lyzr.com/blog/mcp-vs-a2a-difference
published: 2026-11-14
updated: 2026-11-14
author: Lyzr
---

# What is the difference between MCP and A2A?

**The Model Context Protocol (MCP) standardises how an agent uses tools, data and prompts exposed by a server. The Agent2Agent protocol (A2A) standardises how one agent hands a task to another agent and tracks it to completion. Most enterprise estates will use both: MCP for "agent calls a tool", A2A for "agent asks another agent".**

Both protocols now sit under the Agentic AI Foundation at the Linux Foundation, so the question is less "which one wins" and more "which one fits this connection, and how do we govern each".

## How do MCP and A2A compare side by side?

| | MCP | A2A |
|---|---|---|
| Purpose | Give an agent access to tools, resources and prompts | Let an agent delegate a task to another agent |
| Origin | Introduced by Anthropic in November 2024 | Released by Google in April 2025; moved to the Linux Foundation in June 2025 |
| Current version | Dated spec revisions; latest is 2026-07-28 | v1.0, frozen March 12, 2026 |
| Who is on each end | MCP client inside a host app ↔ MCP server | Client agent ↔ remote agent |
| Discovery | Configured per client, or found through a registry | Agent Card published at `/.well-known/agent-card.json` |
| Transports | stdio for local servers, Streamable HTTP for remote | JSON-RPC, gRPC and HTTP+JSON bindings, declared in the Agent Card |
| Unit of work | A tool call or resource read, usually short | A task with a lifecycle that can run long |
| State | Mostly request-response | Task states such as submitted, working, input-required, completed |
| Auth | Authorization based on OAuth 2.1 for HTTP servers | Security requirements described in the Agent Card |

The simplest test: if the other side is deterministic code that does one thing when asked, expose it over MCP. If the other side reasons, plans and may come back with questions, A2A fits better.

## When should you use MCP?

Use MCP when an agent needs a capability, not a colleague:

- Querying a database or search index
- Reading files or tickets
- Calling a SaaS API, such as creating a record
- Fetching a prompt template the platform team maintains

MCP servers are where most agent risk concentrates today, because they hold credentials and touch data. That is why our [MCP governance pillar](/blog/how-to-govern-mcp-servers) starts with inventory and authorization. See [how MCP authorization works](/blog/how-mcp-authorization-works) for the OAuth details.

## When should you use A2A?

Use A2A when the work needs another agent's judgement or its own tools:

- A procurement agent asks a contracts agent to review terms
- A service agent hands a refund case to a finance agent that has payment access
- An agent built on one platform calls an agent built on another

A2A tasks can pause in an "input required" or "auth required" state and resume later, which suits long-running work. The A2A v1.0 builder's guide lists nine task states, four of them terminal: completed, failed, canceled and rejected.

## What do you need to govern for each?

The risks differ, so the controls do too.

**For MCP:**
1. Keep an inventory of every MCP server, local and remote, with owner and version.
2. Limit which tools each agent can call.
3. Review server updates before agents use them, because tool descriptions can change.
4. Treat tool outputs as untrusted input to the model, to limit prompt injection.

**For A2A:**
1. Register which agents may call which other agents, and for what.
2. Carry the original user's identity through the chain, so the downstream agent acts with that person's permissions, not its own.
3. Validate Agent Cards before trusting them, and pin the endpoints you allow.
4. Log every delegation with task ID, caller and outcome, so a chain of agents can be traced end to end.

The second A2A point is the one teams miss. Without delegated identity, a chain of agents becomes a chain of service accounts, and the last agent can do things the original user never could. Our [A2A governance guide](/blog/how-to-govern-agent-to-agent-a2a-calls) goes deeper.

## How Opencontroller does this

Opencontroller, by Lyzr, keeps a governed registry of agents, versions, tools and MCP servers, and its Agent Gateway sits in the path of agent traffic. Delegated on-behalf-of identity carries the user through agent calls, and agent workload identity federation replaces static keys. Opencontroller Edge extends discovery to local MCP servers on developer devices. Opencontroller supports open standards, including MCP, OpenTelemetry and OIDC. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is A2A a replacement for MCP?**
No. They solve different problems. The A2A project itself describes MCP as how an agent uses a tool and A2A as how an agent delegates to another agent.

**Can one agent expose both MCP and A2A?**
Yes. An internal agent can offer a narrow tool over MCP and a full task interface over A2A. See [MCP, A2A or REST for internal agents](/blog/expose-internal-agents-as-mcp-a2a-or-rest).

**Where does an A2A agent publish its capabilities?**
In an Agent Card at `/.well-known/agent-card.json`, which lists skills, endpoints, supported bindings and authentication requirements.

## Key facts

MCP standardises agent access to tools, resources and prompts (introduced by Anthropic November 2024; latest spec revision 2026-07-28; stdio and Streamable HTTP transports; OAuth 2.1-based authorization). A2A standardises agent-to-agent task delegation (released by Google April 2025; Linux Foundation June 2025; v1.0 frozen March 12, 2026; Agent Card at /.well-known/agent-card.json; JSON-RPC, gRPC and HTTP+JSON bindings; nine task states). Both sit under the Agentic AI Foundation. Opencontroller keeps a governed registry of agents, tools and MCP servers, provides an Agent Gateway and delegated on-behalf-of identity. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you govern agent-to-agent (A2A) calls?](https://opencontroller.lyzr.com/blog/how-to-govern-agent-to-agent-a2a-calls.md)
- [Should you expose internal AI agents as MCP servers, A2A agents or REST APIs?](https://opencontroller.lyzr.com/blog/expose-internal-agents-as-mcp-a2a-or-rest.md)
- [How does MCP authorization work?](https://opencontroller.lyzr.com/blog/how-mcp-authorization-works.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
