A2A vs MCP: what each protocol does and when you need both

MCP (Model Context Protocol) connects an AI agent to tools and data: a database, a GitHub repo, a search API. A2A (Agent2Agent Protocol) connects an agent to other agents, so it can hand off a task to an agent built by another team, on another framework, and get the result back. They solve different problems, and production systems that use one may eventually need both.

People mix them up because they look alike on the surface: both are open standards governed by the Agentic AI Foundation, part of the Linux Foundation, and both can run over HTTP. The difference is what sits on the other end of the connection: either a tool your agent controls or an agent that makes its own decisions.

What is MCP?

MCP is an open protocol that gives an AI application a standard way to connect to tools, data, and prompts. Anthropic released it in November 2024 and later donated it to the Agentic AI Foundation, a Linux Foundation fund co-founded by Anthropic, Block, and OpenAI.

An MCP server wraps a capability, such as querying Postgres, reading files, or creating a Jira ticket, and describes it in a way a model can understand. An MCP client, usually inside an agent or an assistant like Claude or ChatGPT, discovers those capabilities and calls them. Write the server once, and any MCP-compatible client can use it.

The current specification, dated 2026-07-28, introduced a stateless protocol core. Each request carries its own protocol version and client information, so MCP servers can scale behind an ordinary load balancer without relying on protocol-level sessions.

An MCP server exposes what a system can do, but it doesn't decide when to call a tool or in what order. The agent makes those decisions.

What is A2A?

A2A is an open protocol that lets AI agents built on different frameworks, by different teams or companies, discover each other and work together on tasks. Google announced it in April 2025 and donated it to the Linux Foundation that June. Version 1.0, its first stable specification, shipped in March 2026, and by April the project counted more than 150 supporting organizations, including Microsoft, AWS, Salesforce, SAP, and ServiceNow. In August 2026, A2A joined MCP in the Agentic AI Foundation.

Each A2A agent publishes an Agent Card, a JSON document at a well-known URL (/.well-known/agent-card.json) that describes what the agent can do, where to reach it, and how to authenticate. Another agent reads the card, sends a message, and gets back a task it can follow until the work is done, including streamed updates for long-running jobs.

The key difference from MCP is that the agent on the other end doesn't have to expose its internals. It advertises skills and returns results; whether it also reveals its tools, prompts, or intermediate steps is its own choice rather than something the protocol requires. Some implementations do stream them, and Agno's A2A streams can include tool names and arguments. That matters when the agent belongs to another team or another company: you can delegate work to it without either side having to open up how it works.

How do A2A and MCP differ?

MCP exposes tools and capabilities, which can also include an agent. A2A provides a standard way for agents to exchange messages and delegate tasks. Most of the practical differences come down to control: an MCP client directs each call, while an A2A agent that receives a task decides for itself how to complete it.

To choose, look at what's on the other end of the connection. If your agent should direct it step by step, put it behind MCP. If it should own the task and decide how to finish it, reach it over A2A.

When should you use MCP, A2A, or both?

MCP fits when your agent needs to act on a system directly, and A2A fits when the work belongs to another agent. Many systems end up using both.

Take a support agent for a subscription company. It uses MCP to search the help center and look up the customer in the CRM. When a customer asks for a refund, it doesn't call the payments API itself. It hands the refund to the billing team's agent over A2A.

The billing agent has its own MCP connections to the payments API and the ledger, plus its own rules about when a refund needs approval. It doesn't have to surface any of that, and here it doesn't. The support agent only knows that the billing agent advertises a refund skill, so it sends the request and gets the outcome back.

Splitting the work this way keeps each team's logic with the team that owns it. The billing team can change its refund rules, switch payment providers, or add an approval step, and the support agent doesn't have to change at all.

MCP on its own works when a single agent needs access to tools. A2A becomes useful when a task has to cross a team or company boundary, or reach an agent built on a different framework.

If you're deciding how to expose your own product to outside assistants, there's a related choice between publishing raw MCP tools and publishing an agent behind them. We covered that in A pile of MCP tools is not an agent.

How do you use MCP and A2A with Agno?

Agno supports both protocols in both directions: your agents can call MCP servers and A2A agents, and AgentOS can expose your agents over MCP and A2A.

Install the extras for AgentOS, MCP, and A2A:

uv pip install -U "agno[os,mcp,a2a,openai]"
export OPENAI_API_KEY="your-openai-api-key"

To serve the billing agent from the example over both protocols, turn on both in AgentOS:

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS
 
billing_agent = Agent(
    id="billing-agent",
    name="Billing Agent",
    model=OpenAIResponses(id="gpt-5.5"),
    instructions="Process refund requests. Refunds over $50 need approval.",
)
 
agent_os = AgentOS(
    agents=[billing_agent],
    a2a_interface=True,  # serve an Agent Card and A2A endpoints
    mcp=True,            # serve AgentOS over MCP
)
app = agent_os.get_app()

The agent's Agent Card is then available at /a2a/agents/billing-agent/.well-known/agent-card.json. Any compatible A2A client can call it, including one built with Google ADK or another framework. From an Agno agent or plain Python, use the A2A client:

import asyncio
 
from agno.client.a2a import A2AClient
 
 
async def main():
    client = A2AClient("https://billing.example.com/a2a/agents/billing-agent")
    result = await client.send_message(
        message="Refund the duplicate $30 charge for customer 4821"
    )
    print(result.content)
 
 
asyncio.run(main())

If AgentOS runs with authorization turned on, every A2A request needs a valid token (passed through the client's headers), so the billing team decides who can delegate work to its agent. On the tool side, Agno agents connect to any MCP server through MCPTools; the A2A interface docs and A2A client docs cover the full setup.