Enterprise Autonomy
Menu
ENTERPRISE AUTONOMY · PROTOCOLS · November 15, 2026

When Do You Need MCP, A2A, or Both?

MCP connects an agent to the tools and data it uses and A2A connects an agent to another agent it delegates to, so the choice follows from whether a workflow crosses a tool boundary, an agent boundary, or both.

Leon Grbes · 5 min read
Contributing writer

Diagram of two agents. A maintenance agent on the left connects downward through MCP to a maintenance system and a work-order service. An inventory agent on the right connects downward through MCP to the ERP. A single highlighted A2A link runs horizontally between the two agents, labeled as a task handed from one agent to the other.

The Model Context Protocol (MCP) connects an agent to the tools and data it uses, and the Agent2Agent protocol (A2A) connects one agent to another agent it hands work to. An enterprise needs MCP where its agents must reach systems, A2A where work passes between agents that are built, owned or run separately, and both where one workflow does both. The two are not competitors, and neither is required for every design.

The protocols are often discussed as if they were rival standards for the same job. Their own documentation says otherwise, and the difference is easiest to see by looking at what each one actually specifies.

What MCP specifies

MCP was open-sourced by Anthropic in November 2024 as a standard for connecting AI assistants to the systems where data lives. In December 2025 Anthropic donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation.

The current specification, dated 2026-07-28, describes three roles. A host is the AI application. A client is a connector inside the host. A server is a service that provides context and capabilities. Messages are JSON-RPC 2.0. Servers can offer resources (context and data), prompts (templated messages and workflows) and tools (functions for the model to execute). Clients can offer elicitation, which lets a server ask the user for more information.

The specification defines two standard transports: stdio, for a server the client launches as a local subprocess, and Streamable HTTP, for a server reached over the network. Custom transports are permitted if they keep the message format. Authorization is optional; where it is used over HTTP, it is based on OAuth 2.1, with the MCP server acting as a resource server.

In enterprise terms, an MCP server is a wrapper around a system or a set of operations: the ERP's inventory lookup, the ITSM platform's ticket creation, a query against the data warehouse. The agent discovers what the server offers and calls it. MCP has nothing to say about a second agent.

What A2A specifies

A2A was announced by Google in April 2025, described at launch as complementing MCP. In June 2025 the Linux Foundation launched a project to host it, calling it "an open protocol created by Google for secure agent-to-agent communication and collaboration." In August 2026 it was accepted as a Growth Stage project at the same Agentic AI Foundation that hosts MCP.

The specification, at version 1.0.0, is built around two objects. An Agent Card is a JSON document an A2A server publishes, with a standard discovery location at /.well-known/agent-card.json, describing the agent's identity, capabilities, skills, endpoint and authentication requirements. A Task is the unit of work one agent hands another, with its own identifier and lifecycle. The specification defines protocol bindings for JSON-RPC, gRPC and HTTP/REST.

The specification describes the agents on either side as "independent, often opaque." That word carries the design. The agent sending a task works from the receiving agent's Agent Card, not from knowledge of its tools, prompts or memory. The receiving agent accepts the task, works on it, and reports status and results.

That opacity is the clearest guide to when A2A is worth its cost.

Choosing by boundary

The A2A specification's own appendix on MCP describes how the two fit: an A2A client agent asks an A2A server agent to perform a task, and the server agent "might use MCP to interact with several underlying tools, APIs, or data sources" to complete it. One protocol runs between agents; the other runs from each agent down to its systems. MCP is how an agent reaches a system; A2A is how an agent reaches another agent whose insides it cannot see.

That gives a practical test. Look at a workflow and ask which boundaries it crosses.

MCP is how an agent reaches a system; A2A is how an agent reaches another agent whose insides it cannot see.

Workflow crosses What it needs Hypothetical example
Agent to systems only MCP, or direct calls through the integration layer One agent reads an ITSM ticket, checks a CMDB record and updates the ticket
Agent to agent, same team and runtime Usually neither; an internal call is enough Two steps of one workflow, written and deployed together
Agent to agent across teams, vendors or runtimes A2A, or another documented interface A maintenance agent asks an inventory agent owned by the supply chain team
Both MCP below each agent, A2A between them The case above, where each agent also reaches its own systems

The second row is the one most often skipped. Two agents built by the same team, in the same runtime, under the same identity, can call each other the way any two modules do. Adding A2A there adds discovery, a task lifecycle and a network hop that solve no problem the team has. A2A starts to pay for itself when the receiving agent belongs to someone else: another business unit, a software vendor, a partner. Then the opacity is a feature. The supply chain team can change how its inventory agent works without the maintenance team noticing, as long as the Agent Card and the task contract hold.

The first row has a similar caveat. MCP standardises how an agent discovers and calls tools. It does not replace the integration layer the enterprise already runs, and it does not decide which operations an agent may call. An MCP server placed in front of the ERP is still a new path into the ERP, and it belongs under the same review as any other.

What neither protocol decides

Both protocols move requests and results; neither decides whether an action should happen. Neither holds a supervisor's approval, enforces a spending limit, or keeps the record an auditor will ask for. The MCP specification says as much in its security section: the protocol "cannot enforce these security principles at the protocol level," and implementors are expected to build consent and authorization flows themselves.

This is why the publication's Governed AI Workflows benchmark does not require A2A. Its workflow includes a handoff between a maintenance agent and an inventory agent, and it accepts any documented interface for that handoff, recording which one was used. What it tests is what happens around the protocol: whether the work order waits for approval, stops on denial, and escalates when the inventory agent does not answer. A system can speak both protocols correctly and fail all three checks.

Both protocols move requests and results; neither decides whether an action should happen.

The choice of protocol, then, is a smaller decision than it looks. It follows from where the boundaries in a workflow fall, and in particular from who owns the agent on the other side. The larger decision is what governs the action once the request arrives, which is where the definitions in the glossary begin.

THE NEWSLETTER

New research, benchmark results and reporting, by email.

No more than one email a week. Unsubscribe from any email. See the privacy notice.