LetterMCP

A2A Protocol and MCP Interoperability in Enterprise Stacks

Two protocols solve different layers of agent coordination in enterprise systems.

· 9 min read · Updated
Cover illustration for “A2A Protocol and MCP Interoperability in Enterprise Stacks”
Agentic AI Foundations · September 25, 2026 · 9 min read · 1,990 words

A single enterprise today rarely runs one AI agent. It runs a system of them: an analytics agent pulling numbers, a governance agent checking policy, a workflow orchestrator stitching the output together. None of them can talk to each other, or to the tools they depend on, without someone writing custom code to bridge the gap, and that integration surface grows faster than any engineering team can hand-code it.

Why agent stacks fragment without shared protocols

The failure mode has two distinct shapes, and most integration efforts stall because teams treat them as one problem instead of two. The first is horizontal fragmentation: agents built by different teams or vendors talk to each other over incompatible channels, custom REST, gRPC, proprietary WebSocket implementations, so every single agent-to-agent pairing needs its own adapter built from scratch. The second is vertical fragmentation: the same external tool, a CRM, a database, an internal API, gets accessed by different agents through entirely different methods, one over REST, another through an SDK wrapper, a third with direct SQL, which makes reusing a capability across agents practically impossible. The Berkeley MAST study backs this up with hard numbers: researchers annotated execution traces across seven open-source frameworks and found multi-agent LLM systems failing at high rates, with specification and design issues plus inter-agent misalignment accounting for roughly four in five of those failures. The models are not the bottleneck. Coordination and integration are. Left unaddressed, the result is glue code that is brittle, expensive to maintain, and invisible to the governance teams who are supposed to be overseeing it.

MCP exists to solve one half of this problem, the vertical half. It gives any MCP-compatible agent one model-agnostic interface to any MCP-compatible tool or data source, so you don't need a custom connector per tool. Underneath, it runs on JSON-RPC 2.0, and its client-server architecture is modeled on the Language Server Protocol. MCP servers publish a manifest describing the tools they offer, each tool's function, and its input and output schema, so an agent can find out what it can do without having to know how the tool is built. As of the 2025-03-26 specification, Streamable HTTP is the standard transport for production deployments: a single /mcp endpoint handling ordinary HTTP POST and GET requests, which lets MCP servers run as Kubernetes pods or serverless functions behind standard load balancers, with no sticky-session infrastructure required; stdio stays in the spec for local development work. MCP also manages context, memory, prior outputs, tool results, so an agent has the right information in front of it at the right moment. BCG describes it as a "USB-C port for AI agents," and that image holds up: one standard interface, regardless of which model or which tool sits on either end.

The governance behind MCP is as deliberate as its design. Anthropic introduced the protocol in November 2024 and donated it to the Linux Foundation's Agentic AI Foundation (AAIF) on December 9, 2025, with Anthropic, Block, and OpenAI as co-founding participants, and Google, Microsoft, AWS, Cloudflare, and Bloomberg backing the effort. A2A, by contrast, solves the half of the problem MCP was never built for: how one agent delegates a task to another, discovers what that other agent can do, and manages a shared task lifecycle across framework and organizational boundaries. MCP handles vertical connectivity, agent to tool. A2A handles horizontal coordination, agent to agent. Agents publish discoverable Agent Cards that describe their capabilities, so if one agent wants to delegate work to another, it can first negotiate a shared task lifecycle with it.

MCP and A2A in production architecture

Diagram: MCP vs. A2A: Two Protocols, Two Layers. Visualizes: Visualize the two-layer architecture where MCP and A2A solve distinct, non-overlapping problems in a multi-agent stack.

A2A was built on HTTP, Server-Sent Events (SSE), and JSON-RPC, standards that were already embedded in enterprise IT stacks. At its center are Agent Cards: JSON files published at a well-known URL that advertise an agent's name, description, service endpoint, supported modalities, and authentication requirements, giving an orchestrator agent a way to discover what a remote agent can do without any prior bilateral setup. A2A runs on a client-remote model: the client agent delegates work, the remote agent does the task on its own and hands back results, without ever getting access to the client's internal context. That boundary is deliberate: each party's internal state stays opaque to the other, and that is what makes cross-organizational deployment possible. A2A joined the AAIF on August 17, 2026, so it now sits under the same Linux Foundation governance umbrella as MCP, with adoption already spanning a large number of organizations at the time of that announcement.

Most production multi-agent systems run MCP and A2A at the same time, much like a web service uses both a database driver and HTTP without choosing between them, so you can expect dual deployment as the baseline, not an advanced configuration. The pattern in practice: an orchestrator agent delegates a task via A2A to a specialist agent, and that specialist agent then turns around and uses MCP to call the specific tool it needs to get the job done. The two protocols interlock cleanly because they are built to operate at different layers.

SAP has published the clearest enterprise example of this architecture running in production. SAP uses MCP so its Joule Agents can get semantically enriched access to SAP's business capabilities and domain knowledge, including content it pulls from the SAP Knowledge Graph. For interoperability with outside vendors and third-party agents, SAP's preferred approach is A2A, chosen specifically to keep enterprise-grade security, governance, and controlled access intact. Joule acts as an A2A client and sends requests out to external agents, and those external agents then use MCP internally to consume their own tools, so you get the vertical and horizontal layers kept separate and independently governable. SAP routes A2A traffic through its Agent Gateway, or through SAP Integration Suite delegating to that gateway, and it routes MCP traffic through the MCP Gateway inside SAP Integration Suite, so each protocol gets its own governed point of entry, but the Agent Gateway itself had not reached general availability as of mid-2026.

Other enterprise vendors are building the same pattern. Salesforce Agentforce uses A2A to enable cross-ecosystem agent collaboration. ServiceNow Now Assist made both A2A and MCP available in the Zurich Patch 4 release. Google's Agent Development Kit ships native A2A integration, and it also supports MCP. A third protocol in this landscape, ACP (Agent Communication Protocol, from IBM and AGNTCY), also sits under AAIF governance, and it appeals to teams that want minimal friction with HTTP toolchains already in place. A joint MCP/A2A interoperability specification is in progress, but at present an A2A agent cannot natively delegate to an ACP agent and get a response back inside one unified task lifecycle. For teams building this out, the practical sequence is to start with MCP, wiring up internal tools and knowledge bases first, then bring in A2A once cross-departmental and cross-organizational agent collaboration is actually needed, which lowers deployment risk while still getting value out the door faster.

Why governance does not come automatically with interoperability

The properties that make MCP and A2A so useful, cutting friction, enabling dynamic discovery, crossing organizational lines, are the same properties that remove the implicit checkpoints enterprise security programs have relied on for years. Before MCP existed, if you wanted to connect an agent to a tool, a developer had to write custom integration code, someone had to approve the deployment, and an engineering team could at least see the connection along the way. That friction functioned as a control, even when nobody designed it that way. Strip the friction out and that control disappears with it.

An agent operating inside a governance perimeter can delegate a task to an external agent operating entirely outside it, and there may be no audit record anywhere showing what was communicated or what was authorized.

Neither protocol closes this gap on its own. AAIF governance covers the standards themselves, not enterprise authorization policy, so if you implement MCP or A2A, the actual authorization patterns are up to you. That keeps the protocols simple, but enterprise teams have to carry a heavy share of the responsibility. The permission chain problem that follows is structural: in a multi-agent system where one agent delegates to another, permission chains can slip past individual agent controls entirely, and neither protocol specification addresses that gap natively.

The shadow agent problem that results from all this is visible in survey data. A 2026 CISO AI Risk Report found that most enterprise security leaders surveyed lack full visibility into their own AI identities, and most had found shadow agents running on their networks with persistent privileged access that nobody had signed off on. Interoperability made these systems powerful. It did not make them accountable on its own, and that distinction is the whole reason governance has to be built deliberately rather than assumed.

The security threats specific to agent-interoperability protocols that enterprises need to understand before scaling

Diagram: Four MCP Security Threat Classes. Visualizes: Show the four distinct threat classes introduced by MCP's architecture, as a ranked or stepped list with a one-line mechanism for each: (1) Tool poisoning — agent reads a silently modified…

MCP runs through nearly every significant AI agent security incident documented in 2026, and the threat classes it introduces, tool poisoning, authentication gaps, confused deputy attacks, and overprivileged credentials, differ from traditional API security because MCP blends instructions together with data in a way that ordinary perimeter controls were never built to catch.

An agent reads an MCP tool's natural-language description to decide how and when to call that tool, and that text can get silently modified while the tool's name and its user-facing summary stay exactly the same. You could rewrite its system prompt and not redirect the agent's behavior any more effectively, because the vulnerability sits in the trust boundary between the tool registry and the agent itself, not inside any single system.

Authentication gaps occur at scale, not as isolated misconfigurations. A scan from February 2026 found more than 8,000 MCP servers exposed on the public internet, and Trend Micro found hundreds of those with no client authentication and no traffic encryption. That is a systemic deployment pattern, not a handful of edge cases.

Confused deputy attacks exploit a gap between who is asking and who is acting. The MCP server carries out actions using its own elevated privileges rather than the privileges of the person making the request, so a user without database admin access can ask the agent to run a query, and the server, which does have admin access, complies without checking who actually asked. The requesting identity and the executing identity are decoupled, and that decoupling is the vulnerability.

Overprivileged credentials round out the fourth class. MCP servers frequently store credentials, API keys, and database passwords in plaintext configuration files, and every client that connects to that server inherits the exact same privileged access as every other client. One compromised credential exposes everything that server touches.

These are not abstract risks. As of May 2026, at least seven confirmed high- or critical-severity CVEs span major MCP-integrated platforms, including MCP Inspector, LiteLLM, Cursor IDE, LibreChat, and Windsurf. Cursor IDE's parent company, Anysphere, became a SpaceX subsidiary following SpaceX's August 14, 2026 acquisition, with OpenAI announcing a proposed November 12, 2026 cutoff of its model-supply contract to the product. Windsurf was rebranded as Devin Desktop on June 2, 2026. In April 2026, OX Security disclosed a systemic flaw in the STDIO transport used across Anthropic's official MCP SDKs for Python, TypeScript, Java, and Rust: parameters get passed directly to the host operating system's shell without any input sanitization, so any process command executes on the host regardless of whether it initializes a valid MCP server at all. Microsoft documented an active attack pattern exploiting MCP inside production enterprise finance workflows as recently as June 2026.

The risk compounds when agents are chained together. The NSA has documented that cascading prompt injections can propagate malicious content across chained MCP connections, so if one tool description gets poisoned or one server gets compromised, it will not stay contained to one agent, it can travel through every agent downstream that trusts the one before it.

Sources

  1. Agent Interoperability Protocols: MCP, A2A, OSI Explained [2026]
  2. Google A2A Protocol in 2026: Adoption, Hype, and Reality
  3. A2A and MCP Protocol Integration Guide | Meta Intelligence
  4. Agent-to-Agent Communication Protocol Standards: A2A, MCP, ACP, and ANP | Zylos Research
  5. blog.modelcontextprotocol.io
  6. blog.modelcontextprotocol.io
  7. linuxfoundation.org
  8. practical-devsecops.com

More in Agentic AI Foundations