232 The Agent Interoperability Landscape: Standards, Consolidation, and the Agent Stack

232.1 1. Introduction

The three preceding chapters examined MCP, A2A, and AP2 individually. This chapter steps back to survey the entire field of agent-interoperability standards as it stood in early 2026, and, more importantly, to explain the shape the field took. The story of 2025 is not a proliferation of competing protocols but a rapid consolidation of them: a movement from a sprawl of overlapping specifications toward a layered, “complementary-not-competing” stack, with the Linux Foundation emerging as the dominant neutral steward. Understanding that consolidation is more durable knowledge than memorizing any single protocol, because it tells you how to reason about the next standard that appears.

We proceed in four passes: a brief recap of the major protocols organized by the layer each occupies; a comparison of the broader field including the standards that lost, merged, or remain niche; a small formal model of why a layered stack and neutral governance are the stable outcome rather than an accident; and an analysis of the consolidation dynamic itself, culminating in the December 2025 formation of the Agentic AI Foundation.

A note on scope and evidence. This chapter is a survey and a method, not a benchmark. The adoption figures it repeats (server counts, supporting-organization counts) originate almost entirely from vendor announcements rather than independent measurement, so they are useful as order-of-magnitude signals and as relative comparisons, not as precise quantities. Where this chapter introduces mathematics, the mathematics is a model of incentives and composition, used to explain why the field converged, not a claim about any measured benchmark.

232.2 2. The Agent Stack

232.2.1 2.0 Definitions

Three terms recur throughout and are worth pinning down precisely, because the whole consolidation argument rests on them.

Interoperability standard. A publicly specified contract, an interface plus a wire format plus a set of semantics, that lets two independently built software components interact without prior bilateral agreement. The key word is independently: a standard earns its name only when parties who never coordinated can still interoperate by both conforming to the specification.
Layer. A distinct interaction concern with its own interface, such that a component implementing one layer can ignore the internals of the others. In the agent setting the salient layers are agent to tools, agent to agent, commerce, content access, and cross-cutting infrastructure (identity, discovery, observability). A protocol “occupies” a layer when its abstractions are about that concern and no other.
Neutral governance. Stewardship of a specification by an organization whose charter prevents any single adopter from unilaterally controlling the specification’s evolution. A vendor-hosted open-source project is open but not neutral; a project under a foundation with an independent technical charter is both. The distinction is the load-bearing one for adoption, as Section 4 argues.

A protocol composes with another when it is defined as an extension or a client of the other rather than a replacement for it. A protocol competes with another when both claim the same layer and an adopter must choose between them. Composition is additive (you can run both), competition is exclusive (you pick one). This single distinction, additive versus exclusive, organizes the entire landscape below.

232.2.2 2.1 The mental model

The mental model that crystallized over 2025 is a stack of layers, each protocol owning a distinct concern:

flowchart TD
    L1["Content access: NLWeb, websites and agents"]
    L2["Commerce: AP2 plus x402, agents move money"]
    L3["Agent to agent: A2A, peers discover and delegate"]
    L4["Agent to tools: MCP, tools, resources, data"]
    L5["Multi-agent infra: AGNTCY/OASF, directory, identity, obs"]
    L1 --> L2 --> L3 --> L4 --> L5

A useful one-line summary: MCP connects an agent downward to tools; A2A connects agents sideways to peers; AP2 sits above to move money; and infrastructure projects such as AGNTCY and content layers such as NLWeb provide the directory, identity, and content-access scaffolding around them. These are not rivals fighting for the same slot, they compose.

The directionality is worth making explicit, because it is what keeps the layers from colliding. MCP is vertical and downward: one agent reaching down to its own tools and data. A2A is horizontal: peer agents, each of which may privately own an MCP tool layer, reaching sideways to delegate work. The two never contend for the same connection. An A2A agent that needs a database does not expose that database over A2A; it reaches it over MCP, privately, and exposes only a task-level capability to its peers. This is the concrete mechanism behind “complementary, not competing”: the layers are defined over different endpoints (an agent’s own tools versus another agent), so conforming to one says nothing about the other.

232.2.3 2.2 MCP, Model Context Protocol (recap)

Created by Anthropic and open-sourced in November 2024, MCP is the vertical layer: a single agent’s connection to external tools, data, and resources, often described as “the USB-C port for AI.” It uses JSON-RPC 2.0 over stdio (local) and Streamable HTTP (remote, which superseded the earlier HTTP+SSE transport), and exposes three primitives, tools, resources, and prompts, from an MCP server to an MCP client. Anthropic introduced a formal governance model in July 2025 (Specification Enhancement Proposals and a maintainer steering group), Microsoft and OpenAI joined the steering committee in 2025, and on December 9, 2025, MCP became a founding project of the Agentic AI Foundation. It is the most mature and widely adopted of all these standards, with well over ten thousand published servers and support across every major assistant.

232.2.4 2.3 A2A, Agent2Agent (recap)

Created by Google (April 2025) and donated to the Linux Foundation (June 2025), A2A is the horizontal layer: agent-to-agent collaboration across vendors and frameworks. Its signature abstraction is the Agent Card published at /.well-known/agent-card.json, plus a stateful Task lifecycle and modality-agnostic Messages and Artifacts, carried over JSON-RPC/gRPC/REST with SSE streaming. It surpassed 150 supporting organizations within its first year.

232.2.5 2.4 AP2, Agent Payments Protocol (recap)

Created by Google (September 2025), AP2 is the commerce layer, implemented as an extension over A2A. Its core abstraction is the Mandate, Intent, Cart, and Payment mandates expressed as signed Verifiable Credentials, and it is payment-method-agnostic, with a companion x402 extension (Coinbase, Ethereum Foundation, MetaMask) for stablecoin rails. That AP2 is defined as an extension over A2A rather than a standalone protocol is the canonical example of composition in this field: it inherits A2A’s transport, discovery, and task lifecycle and adds only the commerce-specific semantics (the mandate chain), so an A2A adopter gains payments by opting in rather than by switching protocols.

232.2.6 2.5 A worked example: one user request, three layers

To make the layering concrete, trace a single request through the stack. A user tells a travel-planning agent, “book me a refundable hotel in Lisbon under 200 euros per night for the conference week.”

Content and discovery. The planning agent needs candidate hotels. Where a site exposes a natural-language agent interface (NLWeb, built on MCP), the agent queries it directly; otherwise it discovers booking agents by reading their Agent Cards at /.well-known/agent-card.json (A2A discovery).
Agent to agent (A2A). The planning agent delegates to a specialized booking agent as an A2A Task: “find refundable Lisbon hotels, under 200 euros per night, for these dates.” The booking agent is a peer, not a tool. The planner does not know or care how it works inside.
Agent to tools (MCP), privately. Inside the booking agent, an MCP tool call hits a reservations API and an MCP resource exposes the live inventory. This MCP traffic is internal to the booking agent and never appears on the A2A wire. The planner sees only a task-level result.
Commerce (AP2 over A2A). To pay, the user first signs an Intent Mandate (“hotels in Lisbon, refundable, under 200 euros per night”). The booking agent returns a specific Cart Mandate (this hotel, this rate, these dates), the user (or a pre-authorized policy) approves it, and a Payment Mandate, a signed Verifiable Credential, authorizes the charge over the user’s chosen rail.

No layer reaches across into another’s concern. The booking agent’s database is invisible to the planner; the planner’s delegation is invisible to the database; payment rides as an extension of the same A2A task rather than as a separate protocol. The request succeeds precisely because each layer composes additively with the next.

232.3 3. The Broader Field

Beyond the three core protocols, several other efforts shaped the landscape. Some merged into the winners; some occupy adjacent niches; some remain experimental. Treating them honestly, including which ones lost, is what makes the consolidation story legible.

232.3.1 3.1 ACP (IBM / BeeAI), Merged into A2A

IBM Research launched the Agent Communication Protocol (ACP) in March 2025 to power its open-source BeeAI platform, using REST and multipart HTTP messaging rather than A2A’s JSON-RPC. It was donated to the Linux Foundation shortly after. The decisive event came on September 1, 2025: the ACP team announced it was merging into A2A under the Linux Foundation to build a single unified standard, and BeeAI moved onto A2A. In IBM’s framing, “by bringing the assets and expertise behind ACP into A2A, we can build a single, more powerful standard.” ACP is therefore no longer an independent competitor; it is the clearest single data point for the convergence thesis, a direct rival folding into the standard rather than fragmenting the market.

232.3.2 3.2 AGNTCY / “Internet of Agents” (Cisco-led)

Open-sourced by Cisco’s Outshift incubator in March 2025 with LangChain and Galileo as collaborators, and welcomed as a Linux Foundation project in late July 2025, AGNTCY is broader than a single wire protocol. It provides infrastructure for multi-agent systems: the Open Agent Schema Framework (OASF) for describing and discovering agents, an Agent Directory, cryptographically verifiable Agent Identity, SLIM messaging, and observability tooling. It is positioned as complementary plumbing beneath agent-to-agent coordination rather than a competitor to A2A. One naming hazard deserves explicit warning: AGNTCY’s Agent Connect Protocol is also abbreviated ACP, colliding with IBM’s now-merged Agent Communication Protocol. They are entirely different things; secondary literature frequently conflates them.

232.3.3 3.3 Vendor Stances: Microsoft and OpenAI

The two largest non-Google players adopted the open stack rather than launching rivals, itself a strong consolidation signal.

Microsoft joined the MCP steering committee at Build 2025, shipped MCP support in VS Code (GA July 2025), and was an A2A founding supporter. It also introduced NLWeb, an open project that turns any website into a natural-language interface for agents, positioned as “HTML for the agentic web,” a content-access layer beneath agent coordination.
OpenAI adopted MCP in March 2025 across its Agents SDK, Responses API, and ChatGPT desktop app, and joined the steering committee. In December 2025 it co-founded the Agentic AI Foundation, contributing AGENTS.md, a simple repository-level instruction file for coding agents.

232.3.4 3.4 The Experimental Tier

A long tail of efforts remains real but low-adoption, and should be understood as the fringe rather than as peers of MCP/A2A:

Eclipse LMOS (Language Model Operating System), an Eclipse Foundation project for an open, “sovereign” Internet of Agents, describing capabilities in JSON-LD and remaining transport-agnostic via the W3C Web of Things; it added an Agent Definition Language in 2025. European, open-governance flavored, with modest adoption.
Coral Protocol, decentralized, Web3-flavored collaboration: threaded messaging through a Coral Server, agents bound to self-sovereign DIDs, and on-chain escrow micropayments via a token. Notably, it uses MCP as its communication substrate; its differentiator is blockchain-native trust and payments.
agent.json / Agentic Profile, lightweight, decentralized-identity-oriented descriptors for capability advertisement; niche and fluid.

232.3.5 3.5 Comparison

Protocol	Creator (date)	Layer / problem	Transport	Core abstraction	Governance (early 2026)	Maturity
MCP	Anthropic (Nov 2024)	Agent ↔︎ tools/data	JSON-RPC over stdio + Streamable HTTP	Tools, resources, prompts	Agentic AI Foundation / LF	Very high
A2A	Google (Apr 2025)	Agent ↔︎ agent	JSON-RPC / HTTP+SSE; gRPC, REST	Agent Card, Task, Artifact	Linux Foundation	High
AP2	Google (Sep 2025)	Agent payments	Extension over A2A; signed VCs	Mandates (Intent/Cart/Payment)	Open project; FIDO-aligned	Growing
ACP (IBM/BeeAI)	IBM (Mar 2025)	Agent ↔︎ agent	REST / multipart HTTP	REST agent messaging	Merged into A2A (Sep 2025)	Deprecated
AGNTCY	Cisco (Mar 2025)	Multi-agent infrastructure	SLIM; multiple	OASF, Agent Directory, identity	Linux Foundation	Medium-high
NLWeb	Microsoft (May 2025)	Website ↔︎ agent	Builds on MCP	NL interface over site content	Microsoft open project	Emerging
LMOS	Eclipse	Open “Internet of Agents”	Transport-agnostic (W3C WoT)	JSON-LD capability docs	Eclipse Foundation	Modest
Coral	Coral Protocol	Decentralized collab + payments	Coral Server; uses MCP	Threads, DIDs, on-chain escrow	Decentralized / Web3	Niche

232.4 4. Why a Layered, Neutrally Governed Stack Is the Stable Outcome

The consolidation of 2025 can be read as the result of two forces that a graduate reader can model directly: the economics of network effects (which push toward a single standard per layer) and the economics of trust under competition (which push that single standard toward neutral governance). Neither force is specific to AI agents. Both are well understood, which is exactly why the agent field’s trajectory was predictable in outline even while the particular winners were not.

232.4.1 4.1 Network effects favor one standard per layer

Fix a single layer, say agent to agent, and let $N$ independently built agents wish to interoperate on it. With a single shared standard, each agent implements one interface and can reach all $N - 1$ others, so the number of distinct integrations any one agent must build is $1$, independent of $N$. With $k$ incompatible competing standards on the same layer and no universal adapter, an agent that wants to reach everyone must implement up to $k$ interfaces, and the ecosystem as a whole, in the worst case where every pair speaks a different one of the $k$ standards, faces on the order of

\[ \binom{N}{2} = \frac{N(N-1)}{2} \]

potential bilateral bridges instead of a single shared contract. The value of belonging to a standard with $n$ conforming participants grows superlinearly in $n$ (a Metcalfe-type effect: the number of reachable pairs scales like $n^2$), as formalized in the network-effects literature on standards and compatibility (Katz and Shapiro 1985; Farrell and Saloner 1985). Two consequences follow directly.

First, per layer the equilibrium tends toward a single dominant standard, not a stable plurality, because each adopter’s payoff is increasing in the number of others who chose the same standard, which is the textbook condition for tipping. Second, the pull is per layer, not global: nothing in this argument rewards a protocol for spanning several layers, because the network effect that creates the tipping is computed within a layer (the agents you can reach on that concern). A protocol that tries to own tools and agent-to-agent and commerce at once must win three separate tipping contests simultaneously, against focused incumbents in each, which is strictly harder than winning one. This is the formal reason the stack rewards composition and penalizes layer-spanning ambition, the empirical pattern Section 5 then names question by question.

232.4.2 4.2 Neutral governance lowers the adoption barrier under competition

Winning a layer requires adopters to commit, and commitment is where governance enters. Model an adopter, for example Microsoft or IBM, choosing whether to build on a standard controlled by a direct competitor, for example Google. Let $b$ be the technical benefit of adopting and let $r$ be the expected loss if the controlling vendor later exercises its control adversarially (changes the spec against the adopter’s interest, ties it to the vendor’s own products, or extracts rents), weighted by the adopter’s subjective probability $p$ that this happens. A rational competitor adopts only when

\[ b \;>\; p \cdot r . \]

When the controlling party is a direct rival, $p$ is large, so even a technically excellent standard (large $b$) may fail to clear the bar. Moving the specification to a neutral foundation does not change $b$; it drives $p$ toward zero by removing the controller’s ability to act unilaterally. The inequality then holds for essentially any positive $b$, and previously hesitant rivals adopt. This is the precise sense in which, as the chapter repeats, the protocols that won “did so substantially by ceding control”: ceding control is the move that collapses $p$, and collapsing $p$ is what unlocks adoption by the very competitors whose participation a standard needs in order to win its layer.

Combine the two results. Network effects say each layer wants exactly one standard. The governance inequality says that one standard can only attract the cross-vendor mass it needs if it is neutrally governed. Together they predict precisely what 2025 delivered: convergence to one standard per layer (MCP, A2A, AP2), each migrating to a neutral foundation, with former competitors either joining or merging in. The Kubernetes and PyTorch precedents that the Agentic AI Foundation announcement invokes are the same mechanism observed a decade earlier, infrastructure that an entire industry depends on cannot be owned by one of its competitors, so it ends up under neutral stewardship.

232.4.3 4.3 Scope and limits of the model

The two arguments are deliberately stylized. The integration-count bound assumes no universal adapter exists; in practice partial adapters and gateways soften the worst case, which is exactly why a losing standard can survive at the fringe rather than vanish. The governance inequality treats $p$ and $r$ as fixed and known, whereas real adopters revise them as a foundation establishes (or squanders) a track record. And both arguments are about steady-state incentives; they say nothing about timing, which is why the model explains the shape of consolidation without predicting the specific dates. Used within those limits, the model is a lens, not a forecast: it tells you which structural outcomes are stable, and therefore which new entrants are swimming against the current.

232.5 5. The Consolidation Narrative

The defining dynamic of 2025 was convergence, and the Linux Foundation was its center of gravity. Four moves trace the arc:

A2A → Linux Foundation (June 2025) gave agent-to-agent communication a vendor-neutral home, letting competitors adopt it without ceding control to Google.
AGNTCY → Linux Foundation (July 2025) brought Cisco’s infrastructure stack under the same roof.
IBM’s ACP merged into A2A (September 2025), a direct competitor choosing consolidation over fragmentation, the single strongest signal of the “one standard” thesis.
The Agentic AI Foundation (AAIF) launched December 9, 2025, co-founded by Anthropic, Block, and OpenAI with backing from Google, Microsoft, AWS, Cloudflare, and Bloomberg, anchored by MCP (alongside Block’s goose and OpenAI’s AGENTS.md). This placed the field’s most important protocol under neutral governance with fierce commercial rivals sitting on the same board.

The repeated industry framing, stated by Google, Microsoft, IBM, and Anthropic alike, is “complementary, not competing”: MCP for tools, A2A for agents, AP2 for payments, each a distinct layer. The historical analogy the AAIF announcement makes explicit is to Kubernetes and PyTorch: foundational technologies placed under neutral foundation stewardship that preserved their existing maintainer communities while removing single-vendor control as an adoption barrier. For a graduate reader, that analogy is the right lens: the agent protocols are following the same institutional path that container orchestration and deep-learning frameworks took a decade earlier, and for the same reason, infrastructure on which an entire industry depends cannot be owned by one of its competitors.

232.6 6. Reading the Landscape Going Forward

232.6.1 6.1 A three-question test for any new entrant

Because this field is moving quickly, the most useful skill is not a snapshot of which protocol is “ahead” but a method for placing any new entrant. Three questions suffice, and each maps directly onto a result from Section 4:

Which layer does it occupy? Tools, agent-to-agent, commerce, content access, or cross-cutting infrastructure. If it duplicates a layer that already has a Linux Foundation governed winner, it faces a steep adoption climb, because by the network-effects argument (Section 4.1) that layer has already tipped, and a late entrant must overcome an incumbent whose value to adopters grows with its lead.
What is its governance trajectory? A single-vendor protocol with no neutral-foundation path is a strategic risk for adopters regardless of technical merit, because the governance inequality (Section 4.2) says a large perceived risk $p$ can keep rivals away even when the technical benefit $b$ is high. The protocols that won did so substantially by ceding control, which is the move that collapses $p$.
Does it compose or compete? The stack rewards protocols that explicitly layer on others (AP2 on A2A, NLWeb on MCP, Coral on MCP) and penalizes those that try to own multiple layers at once, because a layer-spanning protocol must win several tipping contests at the same time rather than one.

232.6.2 6.2 When to use which, and the pitfalls

A practitioner choosing what to build on can compress the above into a short decision rule. Reach down to your own tools and data with MCP. Reach sideways to other teams’ or vendors’ agents with A2A. Add AP2 only when value actually changes hands, and prefer it as an extension of an A2A integration you already have rather than as a new moving part. Use AGNTCY-style infrastructure (directory, identity, observability) when you are operating many agents and need to discover, authenticate, and monitor them, not when you are wiring up your first two. Treat the experimental tier (LMOS, Coral, agent.json) as worth tracking, not yet worth betting a production system on, unless its specific differentiator, sovereignty, on-chain settlement, decentralized identity, is a hard requirement for you.

The recurring pitfalls are equally compressible. Do not expose a private tool layer over an agent-to-agent protocol: your database belongs behind MCP inside one agent, not on the A2A wire. Do not adopt a layer-spanning protocol expecting it to replace the stack; the economics in Section 4 are against it. Do not read vendor adoption counts as measured fact. And watch the ACP acronym: IBM’s now-merged Agent Communication Protocol and AGNTCY’s Agent Connect Protocol share the abbreviation while being entirely unrelated, and secondary sources conflate them constantly.

232.6.3 6.3 Open uncertainties

Several uncertainties are worth carrying forward honestly. AP2’s governance home is the least settled of the major three. The AGNTCY/A2A boundary, infrastructure versus wire protocol, is still being negotiated, as both live under the same foundation. The “ACP” acronym collision is a persistent source of confusion. And adoption figures cited throughout this part originate largely from vendor press releases rather than independent measurement, and should be read with that provenance in mind.

232.7 7. Conclusion

The agent-interoperability landscape resolved, over the course of 2025, from apparent chaos into a coherent layered stack: MCP for tools, A2A for agents, AP2 for commerce, with content-access and infrastructure standards arrayed around them, and the Linux Foundation serving as neutral steward for the core. The protocols that thrived embraced composition and ceded governance; the ones that competed head-on either merged into the winners or remained niche. That pattern, standardize the substrate, layer specialized protocols above it, and place the substrate under neutral governance, is the durable lesson, and it is very likely the template the next wave of agentic standards will follow.

232.8 References

Linux Foundation. “Linux Foundation Announces the Formation of the Agentic AI Foundation.” December 9, 2025. https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation
Model Context Protocol Blog. “MCP joins the Agentic AI Foundation.” December 9, 2025. https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/
Model Context Protocol Blog. “Governance for MCP.” July 31, 2025. https://blog.modelcontextprotocol.io/posts/2025-07-31-governance-for-mcp/
Linux Foundation. “Linux Foundation Launches the Agent2Agent Protocol Project.” June 23, 2025. https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents
LF AI & Data. “ACP joins forces with A2A under the Linux Foundation.” August 29, 2025. https://lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a-under-the-linux-foundations-lf-ai-data/
Linux Foundation. “Linux Foundation Welcomes the AGNTCY Project.” July 2025. https://www.linuxfoundation.org/press/linux-foundation-welcomes-the-agntcy-project-to-standardize-open-multi-agent-system-infrastructure-and-break-down-ai-agent-silos
Microsoft. “Microsoft Build 2025: The age of AI agents and building the open agentic web.” May 19, 2025. https://blogs.microsoft.com/blog/2025/05/19/microsoft-build-2025-the-age-of-ai-agents-and-building-the-open-agentic-web/
Google Cloud. “Announcing the Agent Payments Protocol (AP2).” September 16, 2025. https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol
Search Engine Journal. “MCP, A2A, NLWeb, and AGENTS.md: The Standards Powering the Agentic Web.” https://www.searchenginejournal.com/mcp-a2a-nlweb-and-agents-md-the-standards-powering-the-agentic-web/570092/

# The Agent Interoperability Landscape: Standards, Consolidation, and the Agent Stack ## 1. Introduction The three preceding chapters examined MCP, A2A, and AP2 individually. This chapter steps back to survey the entire field of agent-interoperability standards as it stood in early 2026, and, more importantly, to explain the *shape* the field took. The story of 2025 is not a proliferation of competing protocols but a rapid **consolidation** of them: a movement from a sprawl of overlapping specifications toward a layered, "complementary-not-competing" stack, with the **Linux Foundation** emerging as the dominant neutral steward. Understanding that consolidation is more durable knowledge than memorizing any single protocol, because it tells you how to reason about the next standard that appears. We proceed in four passes: a brief recap of the major protocols organized by the layer each occupies; a comparison of the broader field including the standards that lost, merged, or remain niche; a small formal model of why a layered stack and neutral governance are the stable outcome rather than an accident; and an analysis of the consolidation dynamic itself, culminating in the December 2025 formation of the Agentic AI Foundation. A note on scope and evidence. This chapter is a survey and a method, not a benchmark. The adoption figures it repeats (server counts, supporting-organization counts) originate almost entirely from vendor announcements rather than independent measurement, so they are useful as order-of-magnitude signals and as relative comparisons, not as precise quantities. Where this chapter introduces mathematics, the mathematics is a model of incentives and composition, used to explain *why* the field converged, not a claim about any measured benchmark. ## 2. The Agent Stack ### 2.0 Definitions Three terms recur throughout and are worth pinning down precisely, because the whole consolidation argument rests on them. - **Interoperability standard.** A publicly specified contract, an interface plus a wire format plus a set of semantics, that lets two independently built software components interact without prior bilateral agreement. The key word is *independently*: a standard earns its name only when parties who never coordinated can still interoperate by both conforming to the specification. - **Layer.** A distinct interaction concern with its own interface, such that a component implementing one layer can ignore the internals of the others. In the agent setting the salient layers are *agent to tools*, *agent to agent*, *commerce*, *content access*, and *cross-cutting infrastructure* (identity, discovery, observability). A protocol "occupies" a layer when its abstractions are about that concern and no other. - **Neutral governance.** Stewardship of a specification by an organization whose charter prevents any single adopter from unilaterally controlling the specification's evolution. A vendor-hosted open-source project is open but not neutral; a project under a foundation with an independent technical charter is both. The distinction is the load-bearing one for adoption, as Section 4 argues. A protocol *composes with* another when it is defined as an extension or a client of the other rather than a replacement for it. A protocol *competes with* another when both claim the same layer and an adopter must choose between them. Composition is additive (you can run both), competition is exclusive (you pick one). This single distinction, additive versus exclusive, organizes the entire landscape below. ### 2.1 The mental model The mental model that crystallized over 2025 is a stack of layers, each protocol owning a distinct concern: ```{mermaid} flowchart TD L1["Content access: NLWeb, websites and agents"] L2["Commerce: AP2 plus x402, agents move money"] L3["Agent to agent: A2A, peers discover and delegate"] L4["Agent to tools: MCP, tools, resources, data"] L5["Multi-agent infra: AGNTCY/OASF, directory, identity, obs"] L1 --> L2 --> L3 --> L4 --> L5 ``` A useful one-line summary: **MCP connects an agent downward to tools; A2A connects agents sideways to peers; AP2 sits above to move money; and infrastructure projects such as AGNTCY and content layers such as NLWeb provide the directory, identity, and content-access scaffolding around them.** These are not rivals fighting for the same slot, they compose. The directionality is worth making explicit, because it is what keeps the layers from colliding. MCP is *vertical and downward*: one agent reaching down to its own tools and data. A2A is *horizontal*: peer agents, each of which may privately own an MCP tool layer, reaching sideways to delegate work. The two never contend for the same connection. An A2A agent that needs a database does not expose that database over A2A; it reaches it over MCP, privately, and exposes only a task-level capability to its peers. This is the concrete mechanism behind "complementary, not competing": the layers are defined over different *endpoints* (an agent's own tools versus another agent), so conforming to one says nothing about the other. ### 2.2 MCP, Model Context Protocol (recap) Created by Anthropic and open-sourced in November 2024, MCP is the *vertical* layer: a single agent's connection to external tools, data, and resources, often described as "the USB-C port for AI." It uses JSON-RPC 2.0 over stdio (local) and Streamable HTTP (remote, which superseded the earlier HTTP+SSE transport), and exposes three primitives, **tools, resources, and prompts**, from an MCP *server* to an MCP *client*. Anthropic introduced a formal governance model in July 2025 (Specification Enhancement Proposals and a maintainer steering group), Microsoft and OpenAI joined the steering committee in 2025, and on December 9, 2025, MCP became a founding project of the Agentic AI Foundation. It is the most mature and widely adopted of all these standards, with well over ten thousand published servers and support across every major assistant. ### 2.3 A2A, Agent2Agent (recap) Created by Google (April 2025) and donated to the Linux Foundation (June 2025), A2A is the *horizontal* layer: agent-to-agent collaboration across vendors and frameworks. Its signature abstraction is the **Agent Card** published at `/.well-known/agent-card.json`, plus a stateful **Task** lifecycle and modality-agnostic **Messages** and **Artifacts**, carried over JSON-RPC/gRPC/REST with SSE streaming. It surpassed 150 supporting organizations within its first year. ### 2.4 AP2, Agent Payments Protocol (recap) Created by Google (September 2025), AP2 is the *commerce* layer, implemented as an extension over A2A. Its core abstraction is the **Mandate**, Intent, Cart, and Payment mandates expressed as signed Verifiable Credentials, and it is payment-method-agnostic, with a companion **x402** extension (Coinbase, Ethereum Foundation, MetaMask) for stablecoin rails. That AP2 is defined as an *extension over* A2A rather than a standalone protocol is the canonical example of composition in this field: it inherits A2A's transport, discovery, and task lifecycle and adds only the commerce-specific semantics (the mandate chain), so an A2A adopter gains payments by opting in rather than by switching protocols. ### 2.5 A worked example: one user request, three layers To make the layering concrete, trace a single request through the stack. A user tells a travel-planning agent, "book me a refundable hotel in Lisbon under 200 euros per night for the conference week." 1. **Content and discovery.** The planning agent needs candidate hotels. Where a site exposes a natural-language agent interface (NLWeb, built on MCP), the agent queries it directly; otherwise it discovers booking agents by reading their Agent Cards at `/.well-known/agent-card.json` (A2A discovery). 2. **Agent to agent (A2A).** The planning agent delegates to a specialized booking agent as an A2A **Task**: "find refundable Lisbon hotels, under 200 euros per night, for these dates." The booking agent is a peer, not a tool. The planner does not know or care how it works inside. 3. **Agent to tools (MCP), privately.** Inside the booking agent, an MCP **tool** call hits a reservations API and an MCP **resource** exposes the live inventory. This MCP traffic is internal to the booking agent and never appears on the A2A wire. The planner sees only a task-level result. 4. **Commerce (AP2 over A2A).** To pay, the user first signs an **Intent Mandate** ("hotels in Lisbon, refundable, under 200 euros per night"). The booking agent returns a specific **Cart Mandate** (this hotel, this rate, these dates), the user (or a pre-authorized policy) approves it, and a **Payment Mandate**, a signed Verifiable Credential, authorizes the charge over the user's chosen rail. No layer reaches across into another's concern. The booking agent's database is invisible to the planner; the planner's delegation is invisible to the database; payment rides as an extension of the same A2A task rather than as a separate protocol. The request succeeds precisely *because* each layer composes additively with the next. ## 3. The Broader Field Beyond the three core protocols, several other efforts shaped the landscape. Some merged into the winners; some occupy adjacent niches; some remain experimental. Treating them honestly, including which ones *lost*, is what makes the consolidation story legible. ### 3.1 ACP (IBM / BeeAI), Merged into A2A IBM Research launched the **Agent Communication Protocol (ACP)** in March 2025 to power its open-source BeeAI platform, using REST and multipart HTTP messaging rather than A2A's JSON-RPC. It was donated to the Linux Foundation shortly after. The decisive event came on **September 1, 2025**: the ACP team announced it was **merging into A2A** under the Linux Foundation to build a single unified standard, and BeeAI moved onto A2A. In IBM's framing, "by bringing the assets and expertise behind ACP into A2A, we can build a single, more powerful standard." ACP is therefore no longer an independent competitor; it is the clearest single data point for the convergence thesis, a direct rival folding *into* the standard rather than fragmenting the market. ### 3.2 AGNTCY / "Internet of Agents" (Cisco-led) Open-sourced by Cisco's Outshift incubator in March 2025 with LangChain and Galileo as collaborators, and welcomed as a Linux Foundation project in late July 2025, **AGNTCY** is broader than a single wire protocol. It provides *infrastructure* for multi-agent systems: the **Open Agent Schema Framework (OASF)** for describing and discovering agents, an **Agent Directory**, cryptographically verifiable **Agent Identity**, **SLIM** messaging, and observability tooling. It is positioned as complementary plumbing beneath agent-to-agent coordination rather than a competitor to A2A. One naming hazard deserves explicit warning: AGNTCY's **Agent Connect Protocol** is also abbreviated **ACP**, colliding with IBM's now-merged Agent Communication Protocol. They are entirely different things; secondary literature frequently conflates them. ### 3.3 Vendor Stances: Microsoft and OpenAI The two largest non-Google players adopted the open stack rather than launching rivals, itself a strong consolidation signal. - **Microsoft** joined the MCP steering committee at Build 2025, shipped MCP support in VS Code (GA July 2025), and was an A2A founding supporter. It also introduced **NLWeb**, an open project that turns any website into a natural-language interface for agents, positioned as "HTML for the agentic web," a content-access layer beneath agent coordination. - **OpenAI** adopted **MCP in March 2025** across its Agents SDK, Responses API, and ChatGPT desktop app, and joined the steering committee. In December 2025 it co-founded the Agentic AI Foundation, contributing **AGENTS.md**, a simple repository-level instruction file for coding agents. ### 3.4 The Experimental Tier A long tail of efforts remains real but low-adoption, and should be understood as the fringe rather than as peers of MCP/A2A: - **Eclipse LMOS** (Language Model Operating System), an Eclipse Foundation project for an open, "sovereign" Internet of Agents, describing capabilities in JSON-LD and remaining transport-agnostic via the W3C Web of Things; it added an Agent Definition Language in 2025. European, open-governance flavored, with modest adoption. - **Coral Protocol**, decentralized, Web3-flavored collaboration: threaded messaging through a Coral Server, agents bound to self-sovereign DIDs, and on-chain escrow micropayments via a token. Notably, it *uses MCP* as its communication substrate; its differentiator is blockchain-native trust and payments. - **agent.json / Agentic Profile**, lightweight, decentralized-identity-oriented descriptors for capability advertisement; niche and fluid. ### 3.5 Comparison | Protocol | Creator (date) | Layer / problem | Transport | Core abstraction | Governance (early 2026) | Maturity | |---|---|---|---|---|---|---| | **MCP** | Anthropic (Nov 2024) | Agent ↔ tools/data | JSON-RPC over stdio + Streamable HTTP | Tools, resources, prompts | Agentic AI Foundation / LF | Very high | | **A2A** | Google (Apr 2025) | Agent ↔ agent | JSON-RPC / HTTP+SSE; gRPC, REST | Agent Card, Task, Artifact | Linux Foundation | High | | **AP2** | Google (Sep 2025) | Agent payments | Extension over A2A; signed VCs | Mandates (Intent/Cart/Payment) | Open project; FIDO-aligned | Growing | | **ACP** (IBM/BeeAI) | IBM (Mar 2025) | Agent ↔ agent | REST / multipart HTTP | REST agent messaging | **Merged into A2A** (Sep 2025) | Deprecated | | **AGNTCY** | Cisco (Mar 2025) | Multi-agent infrastructure | SLIM; multiple | OASF, Agent Directory, identity | Linux Foundation | Medium-high | | **NLWeb** | Microsoft (May 2025) | Website ↔ agent | Builds on MCP | NL interface over site content | Microsoft open project | Emerging | | **LMOS** | Eclipse | Open "Internet of Agents" | Transport-agnostic (W3C WoT) | JSON-LD capability docs | Eclipse Foundation | Modest | | **Coral** | Coral Protocol | Decentralized collab + payments | Coral Server; uses MCP | Threads, DIDs, on-chain escrow | Decentralized / Web3 | Niche | ## 4. Why a Layered, Neutrally Governed Stack Is the Stable Outcome The consolidation of 2025 can be read as the result of two forces that a graduate reader can model directly: the economics of network effects (which push toward a *single* standard per layer) and the economics of trust under competition (which push that single standard toward *neutral* governance). Neither force is specific to AI agents. Both are well understood, which is exactly why the agent field's trajectory was predictable in outline even while the particular winners were not. ### 4.1 Network effects favor one standard per layer Fix a single layer, say agent to agent, and let $N$ independently built agents wish to interoperate on it. With a single shared standard, each agent implements one interface and can reach all $N - 1$ others, so the number of distinct integrations any one agent must build is $1$, independent of $N$. With $k$ incompatible competing standards on the same layer and no universal adapter, an agent that wants to reach everyone must implement up to $k$ interfaces, and the ecosystem as a whole, in the worst case where every pair speaks a different one of the $k$ standards, faces on the order of $$ \binom{N}{2} = \frac{N(N-1)}{2} $$ potential bilateral bridges instead of a single shared contract. The value of belonging to a standard with $n$ conforming participants grows superlinearly in $n$ (a Metcalfe-type effect: the number of reachable pairs scales like $n^2$), as formalized in the network-effects literature on standards and compatibility [@katz1985network; @farrell1985standardization]. Two consequences follow directly. First, **per layer the equilibrium tends toward a single dominant standard**, not a stable plurality, because each adopter's payoff is increasing in the number of others who chose the same standard, which is the textbook condition for tipping. Second, **the pull is per layer, not global**: nothing in this argument rewards a protocol for spanning *several* layers, because the network effect that creates the tipping is computed within a layer (the agents you can reach *on that concern*). A protocol that tries to own tools and agent-to-agent and commerce at once must win three separate tipping contests simultaneously, against focused incumbents in each, which is strictly harder than winning one. This is the formal reason the stack rewards composition and penalizes layer-spanning ambition, the empirical pattern Section 5 then names question by question. ### 4.2 Neutral governance lowers the adoption barrier under competition Winning a layer requires adopters to commit, and commitment is where governance enters. Model an adopter, for example Microsoft or IBM, choosing whether to build on a standard controlled by a direct competitor, for example Google. Let $b$ be the technical benefit of adopting and let $r$ be the expected loss if the controlling vendor later exercises its control adversarially (changes the spec against the adopter's interest, ties it to the vendor's own products, or extracts rents), weighted by the adopter's subjective probability $p$ that this happens. A rational competitor adopts only when $$ b \;>\; p \cdot r . $$ When the controlling party is a direct rival, $p$ is large, so even a technically excellent standard (large $b$) may fail to clear the bar. Moving the specification to a neutral foundation does not change $b$; it drives $p$ toward zero by removing the controller's ability to act unilaterally. The inequality then holds for essentially any positive $b$, and previously hesitant rivals adopt. This is the precise sense in which, as the chapter repeats, the protocols that won "did so substantially by ceding control": ceding control is the move that collapses $p$, and collapsing $p$ is what unlocks adoption by the very competitors whose participation a standard needs in order to win its layer. Combine the two results. Network effects say each layer wants exactly one standard. The governance inequality says that one standard can only attract the cross-vendor mass it needs if it is neutrally governed. Together they predict precisely what 2025 delivered: convergence to one standard per layer (MCP, A2A, AP2), each migrating to a neutral foundation, with former competitors either joining or merging in. The Kubernetes and PyTorch precedents that the Agentic AI Foundation announcement invokes are the same mechanism observed a decade earlier, infrastructure that an entire industry depends on cannot be owned by one of its competitors, so it ends up under neutral stewardship. ### 4.3 Scope and limits of the model The two arguments are deliberately stylized. The integration-count bound assumes no universal adapter exists; in practice partial adapters and gateways soften the worst case, which is exactly why a losing standard can survive at the fringe rather than vanish. The governance inequality treats $p$ and $r$ as fixed and known, whereas real adopters revise them as a foundation establishes (or squanders) a track record. And both arguments are about *steady-state* incentives; they say nothing about timing, which is why the model explains the *shape* of consolidation without predicting the specific dates. Used within those limits, the model is a lens, not a forecast: it tells you which structural outcomes are stable, and therefore which new entrants are swimming against the current. ## 5. The Consolidation Narrative The defining dynamic of 2025 was convergence, and the Linux Foundation was its center of gravity. Four moves trace the arc: 1. **A2A → Linux Foundation (June 2025)** gave agent-to-agent communication a vendor-neutral home, letting competitors adopt it without ceding control to Google. 2. **AGNTCY → Linux Foundation (July 2025)** brought Cisco's infrastructure stack under the same roof. 3. **IBM's ACP merged into A2A (September 2025)**, a direct competitor choosing consolidation over fragmentation, the single strongest signal of the "one standard" thesis. 4. **The Agentic AI Foundation (AAIF) launched December 9, 2025**, co-founded by Anthropic, Block, and OpenAI with backing from Google, Microsoft, AWS, Cloudflare, and Bloomberg, anchored by MCP (alongside Block's *goose* and OpenAI's *AGENTS.md*). This placed the field's most important protocol under neutral governance with fierce commercial rivals sitting on the same board. The repeated industry framing, stated by Google, Microsoft, IBM, and Anthropic alike, is **"complementary, not competing"**: MCP for tools, A2A for agents, AP2 for payments, each a distinct layer. The historical analogy the AAIF announcement makes explicit is to **Kubernetes and PyTorch**: foundational technologies placed under neutral foundation stewardship that preserved their existing maintainer communities while removing single-vendor control as an adoption barrier. For a graduate reader, that analogy is the right lens: the agent protocols are following the same institutional path that container orchestration and deep-learning frameworks took a decade earlier, and for the same reason, infrastructure on which an entire industry depends cannot be owned by one of its competitors. ## 6. Reading the Landscape Going Forward ### 6.1 A three-question test for any new entrant Because this field is moving quickly, the most useful skill is not a snapshot of which protocol is "ahead" but a method for placing any new entrant. Three questions suffice, and each maps directly onto a result from Section 4: 1. **Which layer does it occupy?** Tools, agent-to-agent, commerce, content access, or cross-cutting infrastructure. If it duplicates a layer that already has a Linux Foundation governed winner, it faces a steep adoption climb, because by the network-effects argument (Section 4.1) that layer has already tipped, and a late entrant must overcome an incumbent whose value to adopters grows with its lead. 2. **What is its governance trajectory?** A single-vendor protocol with no neutral-foundation path is a strategic risk for adopters regardless of technical merit, because the governance inequality (Section 4.2) says a large perceived risk $p$ can keep rivals away even when the technical benefit $b$ is high. The protocols that won did so substantially by ceding control, which is the move that collapses $p$. 3. **Does it compose or compete?** The stack rewards protocols that explicitly layer on others (AP2 on A2A, NLWeb on MCP, Coral on MCP) and penalizes those that try to own multiple layers at once, because a layer-spanning protocol must win several tipping contests at the same time rather than one. ### 6.2 When to use which, and the pitfalls A practitioner choosing what to build on can compress the above into a short decision rule. Reach *down* to your own tools and data with **MCP**. Reach *sideways* to other teams' or vendors' agents with **A2A**. Add **AP2** only when value actually changes hands, and prefer it as an extension of an A2A integration you already have rather than as a new moving part. Use **AGNTCY**-style infrastructure (directory, identity, observability) when you are operating many agents and need to discover, authenticate, and monitor them, not when you are wiring up your first two. Treat the experimental tier (LMOS, Coral, agent.json) as worth tracking, not yet worth betting a production system on, unless its specific differentiator, sovereignty, on-chain settlement, decentralized identity, is a hard requirement for you. The recurring pitfalls are equally compressible. Do not expose a private tool layer over an agent-to-agent protocol: your database belongs behind MCP inside one agent, not on the A2A wire. Do not adopt a layer-spanning protocol expecting it to replace the stack; the economics in Section 4 are against it. Do not read vendor adoption counts as measured fact. And watch the **ACP** acronym: IBM's now-merged Agent Communication Protocol and AGNTCY's Agent Connect Protocol share the abbreviation while being entirely unrelated, and secondary sources conflate them constantly. ### 6.3 Open uncertainties Several uncertainties are worth carrying forward honestly. AP2's governance home is the least settled of the major three. The AGNTCY/A2A boundary, infrastructure versus wire protocol, is still being negotiated, as both live under the same foundation. The "ACP" acronym collision is a persistent source of confusion. And adoption figures cited throughout this part originate largely from vendor press releases rather than independent measurement, and should be read with that provenance in mind. ## 7. Conclusion The agent-interoperability landscape resolved, over the course of 2025, from apparent chaos into a coherent layered stack: MCP for tools, A2A for agents, AP2 for commerce, with content-access and infrastructure standards arrayed around them, and the Linux Foundation serving as neutral steward for the core. The protocols that thrived embraced composition and ceded governance; the ones that competed head-on either merged into the winners or remained niche. That pattern, standardize the substrate, layer specialized protocols above it, and place the substrate under neutral governance, is the durable lesson, and it is very likely the template the next wave of agentic standards will follow. ## References 1. Linux Foundation. "Linux Foundation Announces the Formation of the Agentic AI Foundation." December 9, 2025. https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation 2. Model Context Protocol Blog. "MCP joins the Agentic AI Foundation." December 9, 2025. https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/ 3. Model Context Protocol Blog. "Governance for MCP." July 31, 2025. https://blog.modelcontextprotocol.io/posts/2025-07-31-governance-for-mcp/ 4. Linux Foundation. "Linux Foundation Launches the Agent2Agent Protocol Project." June 23, 2025. https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents 5. LF AI & Data. "ACP joins forces with A2A under the Linux Foundation." August 29, 2025. https://lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a-under-the-linux-foundations-lf-ai-data/ 6. Linux Foundation. "Linux Foundation Welcomes the AGNTCY Project." July 2025. https://www.linuxfoundation.org/press/linux-foundation-welcomes-the-agntcy-project-to-standardize-open-multi-agent-system-infrastructure-and-break-down-ai-agent-silos 7. Microsoft. "Microsoft Build 2025: The age of AI agents and building the open agentic web." May 19, 2025. https://blogs.microsoft.com/blog/2025/05/19/microsoft-build-2025-the-age-of-ai-agents-and-building-the-open-agentic-web/ 8. Google Cloud. "Announcing the Agent Payments Protocol (AP2)." September 16, 2025. https://cloud.google.com/blog/products/ai-machine-learning/announcing-agents-to-payments-ap2-protocol 9. Search Engine Journal. "MCP, A2A, NLWeb, and AGENTS.md: The Standards Powering the Agentic Web." https://www.searchenginejournal.com/mcp-a2a-nlweb-and-agents-md-the-standards-powering-the-agentic-web/570092/