A2A vs MCP: how the Agent2Agent and Model Context protocols differ

A2A vs MCP comes down to what each protocol connects. The Model Context Protocol (MCP), released by Anthropic on 25 November 2024, connects an AI application to tools, data and prompts. The Agent2Agent (A2A) Protocol, announced by Google on 9 April 2025, connects one agent to another. Both are open standards now hosted by the Linux Foundation's Agentic AI Foundation, and A2A's own documentation calls them complementary.

Last updated: 11 November 2026.

What is the difference between A2A and MCP?

MCP standardises how an agent reaches its tools and data, and A2A standardises how independent agents talk to each other. The table compares them on 11 November 2026 using each project's own documentation.

The first row is the one that matters. A tool in MCP is a function with a defined input and output. A remote agent in A2A is another system that reasons and plans on its own, which is why the protocol hands work over as a task that can take time, ask for more input and return artifacts.

Who created A2A, and who governs it now?

Google created the Agent2Agent (A2A) Protocol. The Google Developers Blog announced the protocol on 9 April 2025 with support and contributions from more than 50 technology partners and said the protocol complements Anthropic's MCP, which provides tools and context to agents.

On 23 June 2025 the Linux Foundation announced the launch of the Agent2Agent protocol project, describing A2A as an open protocol created by Google and saying it would stay vendor neutral under the Foundation's governance.

A post on the A2A site dated 27 August 2026 then says A2A was accepted as a Growth Stage project at the Agentic AI Foundation (AAIF), the Linux Foundation-directed body whose other projects include MCP, goose and AGENTS.md. The project's home page still describes a Technical Steering Committee with representatives from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP and ServiceNow, and an Apache License 2.0.

MCP followed a similar path. Anthropic created it and donated it to the same foundation on 9 December 2025, as covered in the Model Context Protocol guide. The AAIF projects page lists both protocols.

How does A2A work: Agent Cards, tasks and messages?

An A2A interaction has three parts: discovery through an Agent Card, a message from a client agent, and a task that the server agent works through. The specification defines the Agent Card as the JSON document an agent publishes, found at https://{server_domain}/.well-known/agent-card.json, listing its name, supported interfaces, capabilities, security schemes and skills.

A client agent sends a Message made of Parts, using an operation such as SendMessage or SendStreamingMessage. The server agent answers with a Message or a Task. A Task moves through states including submitted, working, input required, completed, failed and canceled, and results arrive as Artifacts. A client can poll with GetTask, follow a stream, or receive push notifications for long-running work.

Two design points are worth knowing. A2A is built on HTTP, JSON-RPC 2.0 and Server-Sent Events, and it is opaque by design: the specification says agents collaborate without needing to share their internal thoughts, plans or tool implementations. A2A's documentation also states what it is not: not an agent development kit, not a protocol for an agent's own sub-agents or tool calls, and not a replacement for MCP.

What does a minimal A2A agent look like?

The A2A Python SDK, a2a-sdk version 1.3.0 on PyPI (Apache-2.0, Python 3.10 or later), implements specification 1.0. The sample below is adapted from the helloworld sample in the project's a2a-samples repository. The agent is a hypothetical converter that turns an amount in lakh into rupees, and it was run with Python 3.12, a2a-sdk 1.3.0 and uvicorn.

The executor holds the agent's logic. It creates a task, reports working, adds one artifact and reports completed:

from a2a.helpers import get_message_text, new_task_from_user_message, new_text_part
from a2a.server.agent_execution import AgentExecutor, RequestContext
from a2a.server.events import EventQueue
from a2a.server.tasks import TaskUpdater
from a2a.types import TaskState

class LakhAgentExecutor(AgentExecutor):
    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
        task = context.current_task or new_task_from_user_message(context.message)
        await event_queue.enqueue_event(task)
        updater = TaskUpdater(event_queue, task.id, task.context_id)
        await updater.update_status(TaskState.TASK_STATE_WORKING)
        lakh = float(get_message_text(context.message))
        answer = f"{lakh} lakh = Rs {round(lakh * 100_000)}"
        await updater.add_artifact(parts=[new_text_part(text=answer, media_type="text/plain")])
        await updater.update_status(TaskState.TASK_STATE_COMPLETED)

    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
        raise NotImplementedError("Cancel is not supported.")

The server file declares the Agent Card and serves it with the JSON-RPC routes:

import uvicorn
from a2a.server.request_handlers import DefaultRequestHandler
from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
from a2a.server.tasks import InMemoryTaskStore
from a2a.types import AgentCapabilities, AgentCard, AgentInterface, AgentSkill
from starlette.applications import Starlette
from executor import LakhAgentExecutor

card = AgentCard(
    name="Lakh Converter Agent",
    description="Converts an amount in lakh to rupees.",
    version="0.1.0",
    default_input_modes=["text/plain"],
    default_output_modes=["text/plain"],
    capabilities=AgentCapabilities(streaming=True),
    supported_interfaces=[AgentInterface(protocol_binding="JSONRPC",
                                         url="http://127.0.0.1:9999", protocol_version="1.0")],
    skills=[AgentSkill(id="lakh_to_rupees", name="Lakh to rupees", description="Send a number of lakh.",
                       tags=["finance"], examples=["12.5"])],
)
handler = DefaultRequestHandler(agent_executor=LakhAgentExecutor(), task_store=InMemoryTaskStore(), agent_card=card)
routes = create_agent_card_routes(card) + create_jsonrpc_routes(handler, "/")
uvicorn.run(Starlette(routes=routes), host="127.0.0.1", port=9999)

A client then discovers the agent from its card and sends a message:

import asyncio
import httpx
from a2a.client import A2ACardResolver, ClientConfig, create_client
from a2a.helpers import new_text_message
from a2a.types import Role, SendMessageRequest

async def main() -> None:
    async with httpx.AsyncClient() as http:
        card = await A2ACardResolver(httpx_client=http, base_url="http://127.0.0.1:9999").get_agent_card()
    print("Agent:", card.name, "| skills:", [s.id for s in card.skills])
    client = await create_client(agent=card, client_config=ClientConfig(streaming=False))
    request = SendMessageRequest(message=new_text_message("12.5", role=Role.ROLE_USER))
    async for chunk in client.send_message(request):
        print(chunk)
    await client.close()

asyncio.run(main())

With the server running, the client printed the agent's name and skill, then the returned task. The excerpt below keeps the first line, the task state and the artifact text:

Agent: Lakh Converter Agent | skills: ['lakh_to_rupees']
    state: TASK_STATE_COMPLETED
      text: "12.5 lakh = Rs 1250000"

The same server exposes the Agent Card over plain HTTP. Fetching /.well-known/agent-card.json returned this, trimmed here to the main fields:

{
  "name": "Lakh Converter Agent",
  "version": "0.1.0",
  "supportedInterfaces": [{"url": "http://127.0.0.1:9999", "protocolBinding": "JSONRPC", "protocolVersion": "1.0"}],
  "capabilities": {"streaming": true},
  "skills": [{"id": "lakh_to_rupees", "name": "Lakh to rupees"}]
}

On the wire, a version 1.0 request uses the method name SendMessage. A raw JSON-RPC POST with that method and a message from the role ROLE_USER returned a task whose artifact text was "12.5 lakh = Rs 1250000" (trimmed here: task and context ids, timestamps and history removed):

{"jsonrpc": "2.0", "id": 1, "result": {"task": {"status": {"state": "TASK_STATE_COMPLETED"}, "artifacts": [{"parts": [{"text": "12.5 lakh = Rs 1250000", "mediaType": "text/plain"}]}]}}}

The version detail is worth knowing. The A2A "What's new in v1.0" page says message/send was renamed SendMessage. In the same test, a request using the old name message/send got the JSON-RPC error code -32601, "Method not found". That is one result from a server built with the SDK's default settings, and the SDK's README describes a compatibility mode for 0.3, so it is not a rule for every server. It does show why a tutorial written for version 0.3 can fail against a 1.0 agent.

How do A2A and MCP work together?

An agent uses MCP for its own tools and A2A to reach other agents. The A2A project's guide describes MCP as vertical, because every connection gives one agent another tool, resource or skill, and A2A as horizontal, because it connects agents that belong to other teams or organisations.

The guide illustrates this with an auto repair shop. A customer or their assistant agent talks to a shop manager agent over A2A, and the manager hands the work to a mechanic agent, which uses MCP to call tools such as a vehicle diagnostic scanner and a repair manual database.

A hypothetical example from logistics follows the same shape. A dispatch agent at a delivery company in Pune uses MCP tools to read its order database and query a route service. A customer's own assistant agent, owned by someone else, reaches the dispatch agent over A2A: it fetches the Agent Card, sends a message asking where an order is, and follows the task until it completes. The two protocols sit at different boundaries, so neither needs to replace the other. Agents that coordinate inside one application are covered in multi-agent systems explained.

Which should you choose: A2A, MCP or both?

The choice between A2A and MCP follows where the connection sits: MCP between an agent and its tools, A2A between agents. The lines below match common reader situations.

• A single agent that needs files, databases or APIs: use MCP, which standardises how tools and data reach the agent.
• Several agents inside one application on one framework: use the framework's own hand-offs, because the A2A documentation says A2A does not specify how an agent talks to its own sub-agents.
• Agents owned by different teams, vendors or frameworks that must delegate tasks to each other: use A2A.
• An agent that other agents should be able to call and that also needs tools: use both, with A2A at the outer boundary and MCP inside.

What are the limits and risks of both protocols?

A2A and MCP have both changed fast, so tutorials for either protocol age quickly. A2A moved from 0.3 to 1.0 with renamed operations and a change of enum values to SCREAMING_SNAKE_CASE, and MCP's current revision, 2026-07-28, dropped the initialize handshake that earlier revisions used. A reader should check which version a tutorial targets.

Opacity cuts both ways. A2A lets an organisation keep its agent's internals private, but a client then judges the remote agent only by its messages and artifacts, so authentication and output checking matter. On the MCP side, the specification says there should always be a human in the loop able to deny tool invocations, and a tool that can change data deserves the same care in any protocol.

Adoption figures need attribution. The A2A project's own blog says the protocol is backed by over 150 organisations; that is the project's claim, not an independent count. Framework support also varies: Microsoft's Agent Framework 1.0 announcement of 3 April 2026 described A2A 1.0 support as coming soon, so each framework's documentation should be checked for the version it implements. The sample above uses the SDK's in-memory task store, which suits a demonstration and not a production service.

Where do A2A and MCP fit in an AI and ML programme?

Certification in Artificial Intelligence and Machine Learning is an online programme from Vishlesan i-Hub, IIT Patna, delivered on Masai's online platform, that covers Python, machine learning, deep learning, generative AI and LLMs, agentic systems and deploying models to production. Its curriculum includes a module on Generative AI, LLM Engineering and Agentic Systems and a topic on AI agents with LangChain. A reader who has built a first agent can then study MCP and A2A as the layers that connect agents to tools and to each other, and can read the agentic AI roadmap.

Frequently asked questions

What is the difference between A2A and MCP?

The Model Context Protocol (MCP) connects an AI agent to tools, data and prompts, while the Agent2Agent (A2A) Protocol connects an agent to other agents. The A2A project describes MCP as agent-to-tool communication and A2A as agent-to-agent communication, and calls them complementary rather than competing.

Who created the A2A protocol?

Google created the Agent2Agent protocol and announced it on 9 April 2025. The Linux Foundation launched the A2A project on 23 June 2025, and the A2A project's blog of 27 August 2026 says the protocol was accepted as a Growth Stage project at the Agentic AI Foundation, the Linux Foundation-directed foundation that also hosts MCP.

Do you need both A2A and MCP?

An agent needs both A2A and MCP only when it must use tools and also exchange tasks with other agents. An agent that only calls tools and data sources needs MCP, and agents from different teams or vendors that must exchange tasks need A2A. A single agent can use MCP for its own tools and expose itself to other agents over A2A, which is the combination the A2A documentation describes.

Is A2A a replacement for MCP?

No, A2A is not a replacement for MCP. The A2A documentation states that A2A is not a replacement for MCP and that the two solve different problems. MCP standardises how an agent connects to tools, APIs and resources, and A2A standardises how independent agents discover each other, delegate tasks and share results.

What is an A2A Agent Card?

An A2A Agent Card is a JSON document that an A2A server publishes to describe an agent, usually at /.well-known/agent-card.json. It lists the agent's name, supported interfaces and protocol versions, capabilities such as streaming, security schemes and skills, so that a client agent can decide whether and how to send it a task.

Which versions of A2A and MCP are current?

On 11 November 2026 the latest released A2A specification is version 1.0.0, released on 12 March 2026 and followed by a bug-fix release, v1.0.1, on 28 May 2026, and the current MCP protocol revision is 2026-07-28 according to the MCP versioning page. Both protocols have changed names and message formats between versions, so tutorials should be matched to the version they target.

Next step

Run the lakh converter agent above, then add a second skill and watch how the Agent Card changes. For a structured route into agentic systems, see the Certification in Artificial Intelligence and Machine Learning page.