The State of Agentic AI Standards in 2026: MCP, A2A, WebMCP, OSI, and the Protocol Stack Taking Shape

The State of Agentic AI Standards in 2026: MCP, A2A, WebMCP, OSI, and the Protocol Stack Taking Shape

In 2023, an AI agent was a demo. In 2024, it was a framework. In 2025, it was a hundred incompatible frameworks. And in 2026, something genuinely new is happening: the agent world is growing a protocol stack, a set of open standards that determine how agents reach tools, talk to websites, talk to each other, understand business meaning, pay for things, and show their work to humans.

I watch this space from two vantage points. My weekly AI newsletter tracks the standards and protocol developments as they happen, and my day job in the lakehouse world puts me on the receiving end of them, because the single biggest consumer of agent standards is turning out to be data platforms. The agents everyone is building want, more than anything else, to query, analyze, and act on enterprise data, which means every protocol in this article eventually terminates at something I write about the rest of the week: a catalog, a table, a semantic definition.

So this is my mid-2026 map of the agentic standards territory. What each protocol actually does, stated plainly. Where each one stands right now: shipped, versioned, previewed, or aspirational. How they layer rather than compete. The honest open problems, governance, security, and sheer protocol sprawl. And a decision framework for builders who need to ship something this quarter without betting on the wrong horse.

The history of data infrastructure teaches one big lesson about moments like this, and I will lean on it throughout: standards wars end, the winners are the ones that stay neutral and layered, and the people who understood the layering early built the durable things.

Why Standards, and Why Now: The N Times M Problem

Every protocol in this article exists to kill the same monster, so let me introduce the monster properly. Call it the N times M problem. You have N agents, assistants, copilots, and autonomous workflows. You have M things they need to touch: databases, SaaS applications, websites, payment systems, other agents, and human interfaces. Without standards, every pairing is a custom integration - N times M pieces of glue code, each with its own authentication, its own data shapes, its own failure modes, each breaking whenever either side changes.

That is not an inconvenience, it is a scaling wall: the glue grows quadratically while the value grows linearly, and by late 2024 every serious builder had hit it.

Standards convert N times M into N plus M. Each agent implements a protocol once. Each tool or counterparty implements it once. Any agent can then reach any tool, and the glue evaporates. This is the oldest trick in computing: it is what TCP did for networks, what HTTP did for documents, what SQL did for queries, what USB did for peripherals, and, in my corner of the world, what Arrow did for in-memory data, Parquet for files, Iceberg for tables, and the Iceberg REST protocol for catalogs. The agent ecosystem is simply the newest domain to rediscover that agreements beat features.

What makes 2026 the turning point is that the agreements stopped being proposals and started being versioned, governed, shipped standards with adoption numbers. The consensus that has emerged is a layered stack, with each layer answering a different question, and the fastest way to understand the space is to walk the layers. That is the structure of everything that follows: tools, then the web, then agent-to-agent, then semantics, then payments, then the human interface, with the cross-cutting problems of identity and security woven through.

Three Years in Fast Forward: How We Got Here

A compressed timeline sets the stage, because the speed of this standardization is itself the story, and each date below marks a layer locking into place.

• Late 2024: Anthropic introduces the Model Context Protocol, and the initial reaction is polite interest - one vendor's integration scheme among many. The design choice that ages best is the humility: MCP standardizes plumbing and stays out of opinions about agent architecture, which is exactly what lets everyone adopt it.
• Early 2025: MCP adoption crosses the tipping point as the other model providers and the major frameworks embrace it - the moment the ecosystem realizes a tool built once can serve every agent. Server counts go vertical, and "MCP server" enters the vocabulary of teams that had never shipped an integration before.
• April 2025: Google introduces A2A with dozens of partners, explicitly positioned as MCP's complement rather than competitor - tools versus peers - and the layered-stack framing enters the discourse.
• Mid to late 2025: the institutional phase. Google donates A2A to the Linux Foundation within months of launch. IBM's rival agent-communication effort merges into A2A rather than fighting it. Snowflake launches the Open Semantic Interchange with the BI and data tooling world aboard, naming semantics as the missing layer for trustworthy data agents. The payments flags plant in a rush: mandates, checkout protocols, machine-native micropayments. And enterprises stop piloting and start deploying, which converts every standards question from theoretical to budgetary.
• Early 2026: the shipping phase. The OSI specification goes live under Apache 2.0 in January with a public repository and working group. Google ships the WebMCP preview in Chrome Canary in February, developed with Microsoft on a W3C track, extending the stack to the browser. Enterprise supporters of the layered stack pass the hundred mark.
• April to June 2026: the maturity markers. A2A reaches version 1.0 with signed Agent Cards, 150-plus production organizations, and SDKs across five languages. Data platforms operationalize the stack - managed MCP servers, MCP governance acquisitions, semantic layer roadmaps, and the Apache Polaris community votes to bring an OSI-aligned semantic specification into the open catalog world. The stack stops being a diagram and becomes a deployment.

Eighteen months from one vendor's protocol to a multi-foundation, multi-layer standards stack with version numbers and adoption counts. For comparison, the web took most of a decade to travel the equivalent distance. Whatever else is true of the agent era, its standardization clock runs fast, which raises the stakes of getting the layering right the first time.

MCP: The Tool Layer That Won

Start at the foundation, because one layer of this stack is no longer contested. The Model Context Protocol, introduced by Anthropic in late 2024, answers the first question every agent asks: how do I reach tools and data? And in the eighteen months since, it has become the closest thing the agent world has to a settled standard.

The design is deliberately boring, which is a compliment. An MCP server wraps some capability - a database, a file system, a SaaS API, a search index - and exposes it through a standard interface of tools the agent can invoke, resources it can read, and prompts it can use. An MCP client, living inside the agent or its host application, discovers what a server offers and calls it. JSON-RPC carries the messages, with a streamable HTTP transport for remote servers and OAuth-based flows handling authorization. One protocol, and any compliant agent can use any compliant server. The USB-C analogy the ecosystem adopted early remains the right one: a universal port for AI capabilities, dull by design, transformative in aggregate.

The 2026 status is broad, deep, and institutional. The specification has continued to revise on a steady cadence, with the late-2025 revision now the widely supported baseline across enterprise implementations. Every major model provider and agent framework speaks it. The server ecosystem runs to the thousands, spanning every database, developer tool, and SaaS platform that matters, with registries and directories maturing from lists into infrastructure.

And the clearest adoption signal is who now operates managed MCP surfaces: the data platforms. Snowflake runs managed MCP servers exposing governed query and search tools, and acquired a company specifically for enterprise MCP governance - agent identities, permissions, and audit trails across tools. Dremio exposes its lakehouse through MCP so agents query governed Iceberg data with the same access controls humans get. When the most conservative buyers in software - enterprise data platforms - operationalize a protocol and build governance products around it, the standardization argument is over.

The honest critiques have shifted accordingly, from "will it win" to the problems of winning. Context bloat, where agents drown in tool definitions from too many connected servers, is driving work on better discovery and selective loading. Security researchers keep demonstrating that a tool interface is an injection surface - more on that below. And governance remains the structural question: MCP is an open specification with open process, but stewardship still centers on Anthropic, and the ecosystem periodically debates whether the tool layer's constitution should live at a neutral foundation the way the agent-to-agent layer's now does. Watch that conversation, because the precedents from my world - formats thriving after donation to neutral homes - all point one direction.

A2A: Agents Talking to Agents, Now at 1.0

One layer up sits the question MCP deliberately does not answer: how do agents find and work with each other? That is the Agent-to-Agent protocol, A2A, and its past year is the fastest maturation story in this article.

The design mirrors how the web solved service discovery. Every agent publishes an Agent Card, a machine-readable description of its capabilities, supported task types, input formats, and authentication requirements. A client agent discovers a remote agent through its card, then delegates tasks over a JSON-and-HTTP protocol with support for long-running work, streaming results, and multi-turn exchanges. The framing the community settled on is exactly right: MCP connects agents to tools, A2A connects agents to peers. A tool is invoked and returns. A peer is delegated to, and negotiates.

The institutional trajectory is the story. Google introduced A2A in April 2025 with dozens of launch partners, then donated it to the Linux Foundation within months, placing it under neutral governance with founding participation from Amazon, Cisco, Google, Microsoft, Salesforce, SAP, and ServiceNow. IBM's competing Agent Communication Protocol merged into A2A in August 2025, consolidating the layer instead of fragmenting it. And in April 2026, A2A reached version 1.0 - a stable production standard - shipping alongside signed Agent Cards for verifiable identity.

The adoption numbers at the one-year mark: over 150 organizations running it in production, SDKs across five languages, native support in essentially every major agent framework - LangGraph, CrewAI, LlamaIndex, Semantic Kernel, AutoGen, Google's ADK, Microsoft's - and general availability inside the big cloud agent platforms.

My assessment: A2A executed the open-standard playbook almost flawlessly - propose broadly, donate quickly, absorb rivals, version deliberately - and it is now the presumptive answer at its layer for enterprise multi-agent systems. The unsettled edges are real but peripheral: a decentralized alternative vision built on W3C decentralized identifiers continues to develop for those who find A2A's model too web-conventional, and the deeper question of what agents should say to each other - the semantics of delegation - remains above the protocol, which standardizes the envelope rather than the meaning. Envelope first is the right order. It is also not the finish line, which brings us to semantics shortly.

WebMCP and the Agentic Web: Teaching Sites to Speak Agent

The third layer addresses the messiest surface agents touch: the web itself. Agents have been using websites the hard way - screenshotting pages and simulating clicks - an approach that is brittle, slow, and adversarial to sites that never consented. The 2026 development is the emergence of a consensual, structured alternative.

The headline is WebMCP. In February 2026, Google shipped an early preview in Chrome Canary of a protocol for structured agent interaction with websites, developed jointly with Microsoft through the W3C. The design has two halves: a declarative API through which ordinary HTML forms and page elements become agent-usable capabilities, and an imperative JavaScript API through which sites expose dynamic functionality as callable tools. The name is the strategy: it extends the MCP mental model to the browser, making a website, in effect, an MCP server that any visiting agent can discover and use, with the site rather than the agent defining what is offered. For site owners, that flips the agent relationship from scraping-by-force to capability-by-consent. For the stack, it fills the web-shaped hole between MCP's APIs and the human-shaped web.

Around WebMCP sits a supporting cast of smaller conventions maturing in parallel. The llms.txt convention gives sites a way to publish agent-oriented content maps, agents.md is emerging as guidance for AI coding assistants within repositories - a convention now reaching even the Apache data projects I cover - and Web Bot Auth work in the identity space aims to let legitimate agents authenticate themselves to sites rather than masquerading as browsers. None of these is finished. Together they sketch the agentic web's social contract: sites declare what agents may do, agents identify themselves honestly, and the DOM-scraping arms race gets replaced by an interface both sides maintain on purpose.

Status honesty: this is the youngest layer in the stack. WebMCP is a preview in one browser channel with a standards-track ambition, not a deployed norm, and the economic questions - what happens to sites whose business model assumed human eyeballs - are unresolved and larger than the technology. But the direction has the right participants - the browser vendors and the W3C - and the right