Hook
Eighty-five percent of enterprises are running AI agent pilots. Five percent have shipped one to production. That gap — 80 points of pure, unfunded intent — is the most mispriced number in tech right now, and I pulled it straight out of a Cisco RSA slide that almost nobody in this industry bothered to read.
Last week, MCP Dev Summit Toronto wrapped. 15,930 public MCP servers spread across four registries. 500 million SDK downloads a month. TELUS, a full year in production. Accenture, 200,000 users. A keynote floor stacked with Anthropic, Google, Okta and the Linux Foundation — all smiling, all shipping their own little layer of what everyone keeps calling "the agent stack."
And not one of them shipped the thing that actually matters. Not one. The stack has four layers — tools, communication, payments, identity — and it has no referee. No coordinator. No meta-layer that can enforce a single policy across all four.
I don" — that's the whole sentence in my notebook, and it means everything: I don't care how big the keynote was. I care that the missing layer is where the money is.
Context
Let me lay the stack out flat, because if you're a trader and you can't name these four acronyms by Q4, you're trading blind.
MCP — Model Context Protocol — is Anthropic's. It solves Agent-to-Tool, the vertical axis. Under the hood it's boring on purpose: JSON-RPC 2.0 over stdio or Streamable HTTP. No new compute paradigm, no clever math, no novel consensus. Its entire value is network effect — 15,930 servers and 500 million monthly SDK downloads.
A2A — Agent-to-Agent — is Google's. It solves the horizontal axis, agent talking to agent, and MCP explicitly does not cover it. 150-plus organizations, now parked under Linux Foundation governance for neutrality.
AP2 covers payments. An agent initiates a payment on a user's behalf, under an authorization model that is still, frankly, being invented in public.
XAA is Okta's — identity. Agent SSO, 25-plus early adopters, shipping August 2026.
Four orthogonal layers. Four different owners. Zero shared coordination structure. Johns Hopkins literally titled its workshop "Tool Integration versus Agent Communication" — the word "versus" is the entire story. The stack is at war with itself, politely, on stage.
I've watched this movie before. The 2017 break didn" — the Parity multisig freeze — taught me nothing about MCP specifically, but it taught me everything about what happens when infrastructure layers mature unevenly and nobody owns the seams. I spent 48 hours tracing those transaction hashes by hand and published the breakdown before the official reports landed. Speed wins. But the second lesson, the one I only absorbed years later, is that the seam is always where the value hides — and this stack is 90% seam.
Core
Now the actual analysis.
Let me give you the maturity ladder first, because it's the cleanest signal in the whole dataset:
- MCP: scale phase. TELUS one year in production, Accenture at 200k users.
- A2A: production phase. 150-plus orgs, Linux Foundation backing.
- XAA: POC-to-production transition. 25-plus early adopters, not yet battle-tested.
- Coordinator layer: research / blank.
The coordinator layer is a void, and voids get filled — usually by whoever is already standing next to them.
Here's the tell. Google's Daryl Ducharme gave a talk titled "One Router for Your Agent's MCP Servers." Read that title again. It's an engineering workaround dressed up as a product. When your protocol stack can't manage itself, you build a single router by hand. That router is a symptom, not a feature — the router is what a missing standard looks like when a cloud vendor gets impatient.
And this is where I break from the polite version of this story. Every analysis I've read frames the coordinator gap as "the protocol community's responsibility." I think that's wishful. The protocol community can't ship a coordinator because the missing layer is strategically useful to the layer owners. Anthropic owns tools. Google owns communication and payments. Okta owns identity. If a neutral coordinator appears, it flattens all four into commodities. Nobody sitting on top of a layer wants that. That's not a conspiracy — it's just incentive, and incentive doesn't need a memo to travel.
Now the number everyone is quoting wrong: 500 million monthly downloads. That's SDK downloads — not developers, not production calls. CI/CD pipelines, Docker images, dependency trees; each one inflates that counter. I've run these dashboards. Download counts are a vanity metric dressed as adoption, and anyone pricing a token off "500M downloads" is buying a rounding artifact.
The real adoption signal is the registry count — 15,930 public servers across four registries. Registries are the discovery layer, and discovery layers are rent. Whoever controls the registry controls trust. That's the quiet business model nobody on that stage said out loud.
Then there's security, and this is where the crypto crowd should be wide awake.
Every new protocol layer adds a trust boundary, and there is no meta-layer to enforce policy across them. That's not my opinion — that's CrowdStrike's entire reason for showing up. They built a talk around "insider threats in the agent tech stack" because they can see what I see: more layers, more seams, more attack surface. Prompt injection riding in through MCP tool calls. XAA identity theft enabling lateral movement — an agent that can act as you across ten apps is a beautiful thing right up until someone steals that agent's identity. AP2 turning a clever prompt injection into actual money leaving an actual account.
Based on my audit experience tracing those Parity contracts years ago, I'll tell you the pattern never changes: the failure is never in the well-tested core. It's in the handshake between two components that each assumed the other was checking something. Four protocols, four handshakes, nobody checking.
Which brings me to the part the blockchain-native readers already saw coming: AP2 is where crypto rails and the agent economy collide, and almost nobody is framing it that way. An autonomous agent that can pay — recurring subscriptions, API metering, machine-to-machine settlement — is exactly the use case stablecoins were built for. Not the ideology version. The survival version: the rail that already settles in seconds, doesn't close for the weekend, and doesn't care what your local currency did overnight. The agent economy doesn't need a new payment rail. It needs the rail that already works when the banks don't.
Here's the trap, though. The 85%/5% gap. Everyone reads it as "enterprises are stuck on integration complexity." I read it as possibly worse: enterprises may simply not have found a high-value agent use case yet, and the coordinator gap is a convenient scapegoat. Attributing an 80-point gap to a single missing layer is the kind of clean story analysts adore and reality rarely delivers. Both things are probably true — and the second one is the one that kills the bull case if it turns out to be dominant.
Let me put the impacted-industry map down, because this is where positioning happens in a sideways tape:
| Sector | Displacement | Augmentation | Window | Trigger | |---|---|---|---|---| | Software integration / iPaaS | Medium | High | 6–18 mo | API → MCP server migration | | Enterprise identity / IAM | Low | High | 12–24 mo | Agent SSO, delegated auth | | Customer service / ticketing | High | High | 12–24 mo | Autonomous + human escalation | | Enterprise IT ops | Medium | High | 12–24 mo | K8s sandboxes, tool governance | | Cybersecurity | Low | High | 6–18 mo | Agent threat detection | | Finance / payments | Medium | High | 18–36 mo | AP2 agent payments |
The row that should terrify legacy middleware is software integration. MCP servers replace traditional API adapters. A2A replaces point-to-point integration. XAA replaces classic SSO. The entire enterprise integration layer is being rewritten in agent-native protocols, and the incumbents — the MuleSofts, the Boomis, the API gateways — are the ones who haven't noticed yet.
And the second-order effect nobody in this report mentioned, the one I flag because I actually trade the infrastructure trade: compute. An agent that plans, calls tools, talks to other agents, and loops — that's not one inference call, that's dozens per task. Agent-to-production flips inference from human-triggered to machine-triggered and high-frequency. That's not a linear compute story. That's the most under-modeled demand curve in the entire stack, and it is completely absent from every summary I've read. The K8s sandbox execution and execution-layer gateways people mentioned are the footprint of that demand — isolated containers spinning up per tool call, per agent, per loop.
I don" — again, shorthand for the thing I keep telling my readers: stop counting keynote slides, start counting containers.
Contrarian
Here's the angle I haven't seen anyone publish, and it's the one I'm actually positioning around.
The coordinator layer will not come from the protocol community. It will come from cloud vendors — or from crypto.
The report frames the gap as a governance question for the Linux Foundation and the IETF. I think that's the polite fiction. AWS, Azure, and GCP already run the agent runtime. They already own the K8s sandbox, the gateway, the observability. A coordinator layer is just orchestration plus policy plus telemetry — which is exactly what a cloud control plane already is. The moment one of them ships "Agent Orchestration, managed," the coordinator gap closes with vendor lock-in attached, and the open-protocol dream quietly becomes a managed-service SKU.
And there's a second candidate the entire analysis missed: OpenAI. The largest model vendor is completely absent from this report, and that absence is itself the loudest signal in the document. Whichever way OpenAI leans on agent protocols — compatibility with MCP or a competing spec — reshapes the whole board. Betting on a winner without pricing the biggest player's position is how you get run over in the dark.
Takeaway
So watch the seams, not the keynotes. Watch for a formal coordinator-layer proposal out of the Linux Foundation in H2 2026. Watch XAA's adoption curve and its first security incident — identity always breaks before it scales. Watch whether a cloud vendor ships a managed coordinator and turns the open stack into a rental. And watch OpenAI, because the strongest variable in this whole equation hasn't said a word yet.
The stack has four layers and no referee. Someone is going to get paid to be the referee — and it won't be the people who wrote the protocol.
