In 2026, AI agents can finally talk to tools and to each other through open standards rather than bespoke glue code. Two protocols dominate the conversation: MCP (Model Context Protocol) for connecting an agent to tools and data, and A2A (Agent2Agent) for connecting agents to other agents. Both are now governed by the Linux Foundation rather than any single vendor, which is the most important development of the year. Around them sit supporting standards like AGNTCY for agent infrastructure and WebMCP for the browser.

I run an AI agent platform, so interoperability is not an abstract debate for me. It decides whether the agents people run on Gravity can reach the tools and other agents they need, and whether the whole category stays plural instead of collapsing into one company's walled garden. This post is the map I wish I had had a year ago: what each protocol does, who controls it, how widely it is adopted, where fragmentation still bites, and what to ask a vendor before you commit. Every figure here is from a primary source, and I flag anything that is forecast rather than fact.

Key takeaways

  • Agent interoperability splits into two layers: agent-to-tool (an agent calling APIs, data, and functions) and agent-to-agent (separate agents discovering and coordinating with each other).
  • MCP (Model Context Protocol) owns the agent-to-tool layer. Anthropic launched it in late 2024, OpenAI and Google adopted it through 2025, and it now sits under neutral governance at the Linux Foundation's Agentic AI Foundation.
  • A2A (Agent2Agent) owns the agent-to-agent layer. Google launched it in April 2025 and donated it to the Linux Foundation in June 2025, with more than 100 companies backing it.
  • AGNTCY (from Cisco, now at the Linux Foundation) adds discovery, identity, and observability, and WebMCP extends agent tool calls into the browser as a proposed W3C standard.
  • The practical buyer takeaway: favor platforms that speak these open standards. Interoperability is the difference between renting capability and getting locked into one vendor's universe.
Two layers: agent-to-tool and agent-to-agent
Two layers: agent-to-tool and agent-to-agent

Two layers: agent-to-tool and agent-to-agent

The single most useful idea for making sense of agent standards is that interoperability happens on two different layers, and the protocols map cleanly onto them.

The first layer is agent-to-tool. A single agent needs to read your calendar, query a database, call an API, or run a function. Historically every one of those connections was a custom integration that broke when the API changed. A standard at this layer gives an agent one consistent way to discover and call tools, regardless of who built the tool. This is the layer MCP owns. If you want the deeper conceptual grounding, we cover it in how agents use tools and in AI agent integration patterns.

The second layer is agent-to-agent. A sales agent hands off to a finance agent; a research agent delegates to a browsing agent; an agent built by one company coordinates with an agent built by another. These agents are separate programs, often on different platforms, that need to discover each other, agree on what each can do, exchange messages securely, and split a task. This is the layer A2A owns, with AGNTCY adding the surrounding infrastructure. We go deeper on the coordination problem in multi-agent coordination and agent orchestration.

Keep these two layers separate in your head and the rest of this map falls into place. MCP and A2A are not competitors. They solve different problems, and a serious agent usually needs both.

MCP: the agent-to-tool standard that won

Model Context Protocol is the closest thing the industry has to a settled standard. Anthropic introduced MCP as an open standard for connecting AI applications to external systems, and within a year it went from an internal experiment to something the rest of the industry adopted rather than fought.

The adoption story is what makes MCP credible. OpenAI added MCP support across its Agents SDK, Responses API, and ChatGPT desktop in early 2025, and Google confirmed MCP support in Gemini shortly after. When two of Anthropic's largest competitors adopt your protocol instead of shipping a rival, the standards war is effectively over. The ecosystem numbers back this up: according to Anthropic, MCP now sees more than 97 million monthly SDK downloads across Python and TypeScript, and its official Registry, launched in September 2025, grew to close to two thousand server entries, a 407 percent jump from its first batch.

How MCP is now governed

The governance question matters more than any feature, because a standard controlled by one company is a lock-in risk wearing an open-source badge. Anthropic addressed this directly. Per the same announcement, Anthropic donated MCP to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. MCP joins Block's goose and OpenAI's AGENTS.md as founding projects there. Anthropic states the protocol's governance model stays community-driven, but the legal home is now neutral.

That neutrality is the whole point. A finance team can build against MCP without betting its integration roadmap on one vendor's commercial whims. For the precise line between a model, an agent, and an MCP server, our sibling explainer on AI agent versus MCP server is the clearest place to start.

A2A: agents talking to agents across vendors

If MCP is how an agent reaches its tools, A2A (Agent2Agent) is how one agent reaches another. Google launched A2A in April 2025 to let agents built on different platforms, by different vendors, discover each other's capabilities, exchange information securely, and coordinate on multi-step tasks. The problem it solves is concrete: without a shared language, an agent from one company and an agent from another have no reliable way to hand work back and forth.

A2A took the same governance path MCP did, and faster. According to the Google Developers Blog, Google donated the A2A specification, SDKs, and tooling to the Linux Foundation in June 2025, seeding a new vendor-neutral project. The founding members are a who's-who of enterprise software: AWS, Cisco, Google, Microsoft, Salesforce, SAP, and ServiceNow. Google reports that more than 100 companies now support the protocol. The protocol has continued to evolve under that governance, with later spec revisions broadening adoption further.

The strategic read is the same as with MCP. By handing A2A to a neutral foundation, Google traded sole control for broad adoption, because no enterprise wants to standardize agent communication on a protocol a single competitor can change unilaterally. A2A is the connective tissue for the multi-agent systems we describe in agent orchestration: it lets a coordinator agent delegate to specialist agents that may live entirely outside your own stack.

AGNTCY: the Internet of Agents infrastructure

MCP and A2A define how agents call tools and message each other, but a production multi-agent system needs more: a way to discover which agents exist, verify their identity, and observe what they are doing. That is the gap AGNTCY targets.

AGNTCY was open-sourced by Cisco's Outshift incubator in March 2025, with early collaboration from LangChain and Galileo. According to the Linux Foundation, the project moved under Linux Foundation governance in July 2025, with Cisco, Dell Technologies, Google Cloud, Oracle, and Red Hat as formative members. It frames its goal as the "Internet of Agents," a collaboration layer where multi-agent systems work together regardless of who built them or where they run.

Its core components fill the infrastructure gaps the two flagship protocols leave open:

Crucially, AGNTCY is positioned as interoperable with both A2A and MCP, not as a replacement for them. The Linux Foundation explicitly notes AGNTCY works alongside the A2A project and Anthropic's MCP. Think of it as the directory, identity, and monitoring layer that sits underneath agent-to-agent traffic. That observability mindset is the same one we argue for in agent monitoring and observability.

WebMCP: extending agents into the browser

The newest piece of the map is WebMCP, and it tackles a problem anyone who has watched an agent fumble through a website knows well. Today most browser agents act like a frustrated human: they read the rendered page, guess where to click, and break when the layout shifts. WebMCP proposes a cleaner path.

WebMCP is a proposed open standard, developed jointly by Google's Chrome team and Microsoft's Edge team and progressing as a W3C Community Group draft. It lets a website declare its own capabilities as structured tools, exposed through a browser-native API, so an agent can call a site's functions directly instead of scraping and clicking. A booking form, a search box, or a checkout flow can be made natively legible to agents. Google shipped an early preview in Chrome in 2026, which means it is a draft to design against, not yet a finished, broadly shipping standard.

The relationship to MCP is worth getting right, because the names invite confusion. MCP connects an agent to external tools and data over a server. WebMCP focuses specifically on making web pages usable by agents from inside the browser. They are complementary: one reaches backend tools, the other reaches the open web. We unpack the wider naming mess, including this one, in our AI agent versus MCP server explainer, and we covered Google's browser-agent push in what Google I/O 2026 means for AI agents.

Where fragmentation still remains

It would be tidy to declare interoperability solved. It is not. The standards have converged impressively at the headline level, but real fragmentation persists, and a careful buyer should price it in.

First, adoption is uneven. A protocol having a famous logo behind it is not the same as every tool you depend on actually exposing an MCP server or speaking A2A. Plenty of SaaS products still ship no agent-friendly interface at all, which forces agents back to brittle scraping or custom integrations. The standards exist; the long tail of implementations is still catching up.

Second, the layers overlap at the edges. A2A and AGNTCY both touch agent discovery and identity, and there is genuine, ongoing work to keep them interoperable rather than competing. The foundations involved frame these as complementary, but in practice teams still face real choices about which to lead with. Expect consolidation and the occasional turf overlap as the specs mature.

Third, "supports MCP" can mean very different things. One vendor exposes a rich, well-documented server; another bolts on a thin wrapper to claim the checkbox. Identity, authentication, and permission models are where this gets dangerous, since an agent with tool access is a security surface. We make that case in agent security best practices. Standards reduce fragmentation; they do not erase the gap between a checkbox and a real implementation.

Finally, none of this removes the strategic incentive for a dominant platform to keep just enough proprietary surface to make leaving painful. Open protocols are a powerful counterweight, which is exactly why neutral governance at the Linux Foundation matters so much. But buyers, not vendors, are the ones who have to insist on portability.

What buyers should actually do

Here is the practical part. If you are choosing an agent platform or tool in 2026, interoperability should be a hard requirement, not a nice-to-have. A few concrete moves:

On Gravity, this is more than a talking point. We let people prompt and run expert-built agents in about 60 seconds and pay per use, and we lean on open protocols deliberately so an agent can reach the tools and other agents a task needs without trapping you. As the giants consolidate, that portability is the thing that keeps you in control of your own stack rather than renting it back from whoever owns the most surface area.

Frequently Asked Questions

What are AI agent interoperability standards?

They are open protocols that let AI agents connect to tools and to other agents without custom, vendor-specific code. The two leading ones in 2026 are MCP, which standardizes how an agent calls tools and data, and A2A, which standardizes how separate agents discover and coordinate with each other across platforms.

What is the difference between MCP and A2A?

MCP (Model Context Protocol) connects a single agent to tools, APIs, and data sources, solving the agent-to-tool layer. A2A (Agent2Agent) connects separate agents to each other so they can discover capabilities and coordinate tasks, solving the agent-to-agent layer. They are complementary, and a serious agent system usually uses both.

Who controls MCP and A2A now?

Both sit under the Linux Foundation for neutral governance. Anthropic donated MCP to the Linux Foundation's Agentic AI Foundation, co-founded with Block and OpenAI. Google donated A2A to the Linux Foundation in June 2025. Neutral stewardship means no single vendor can change either protocol unilaterally, which reduces lock-in risk.

What is AGNTCY and how does it fit in?

AGNTCY, open-sourced by Cisco and now under the Linux Foundation, provides infrastructure for multi-agent systems: agent discovery, cryptographic identity, messaging, and observability. It is positioned as interoperable with both A2A and MCP rather than as a replacement, supplying the directory and monitoring layer underneath agent-to-agent communication.

What is WebMCP?

WebMCP is a proposed open web standard, developed by Google's Chrome and Microsoft's Edge teams as a W3C Community Group draft. It lets websites declare their capabilities as structured tools through a browser API, so agents can call a site's functions directly instead of scraping pages. An early preview shipped in Chrome in 2026.

How do interoperability standards help avoid vendor lock-in?

When an agent platform speaks open, neutrally governed protocols like MCP and A2A, your agents can reach tools and other agents without depending on one vendor's proprietary integrations. That makes it realistic to move between platforms and to mix the best agent for each task, which is the core defense against lock-in.

The bottom line

The agent interoperability picture in 2026 is clearer than it has ever been. MCP owns the agent-to-tool layer, A2A owns the agent-to-agent layer, AGNTCY supplies the discovery and identity infrastructure underneath, and WebMCP is extending tool calls into the browser. The most important fact across all of them is governance: the flagship standards now live at the Linux Foundation, not inside any single company, which is what lets you build on them without betting on one vendor's goodwill.

Fragmentation has not vanished. Adoption is uneven, layers overlap at the edges, and "supports MCP" can hide a thin implementation. So the buyer's job is simple to state and worth doing properly: favor platforms that speak these open standards by name, insist on a real exit path, and treat composability as the feature it is. That is the posture behind Gravity. Prompt an expert-built agent, get the outcome, pay for what you use, and keep your stack portable while the giants consolidate around you.

Sources