The most consequential thing that happened in agentic AI over the last twelve months was not a funding round. It was a transfer of governance.

In December 2025, Anthropic donated the Model Context Protocol to a new Linux Foundation directed fund — the Agentic AI Foundation — co-founded with Block and OpenAI, with support from Google, Microsoft, AWS, Cloudflare and Bloomberg (Anthropic, December 2025). Six months earlier, Google had done the same with the Agent-to-Agent protocol, releasing it under Apache 2.0 in April 2025 and folding it into the Linux Foundation in June (Stellagent). By the spring of 2026, the two protocols that the agentic-AI category actually runs on were owned by no one and governed by everyone — the same pattern that TCP/IP went through in the early 1990s when the IETF won out over the proprietary network stacks the incumbents had been pushing.

This is the move that turns "agentic AI" into something a category. It is the move that makes Web4 — the thesis the Bulletin has been running for four volumes — concrete. The substrate is live. The interesting work now is the layer that gets built on top of it.

The numbers, briefly, because they matter

Before we argue about what the substrate means, we should establish that it is, in fact, the substrate.

The Model Context Protocol — the standard for connecting agents to tools, data, and external systems — was announced by Anthropic in November 2024 (Wikipedia). By March 2026 it was clocking 97 million monthly SDK downloads — a roughly 970x rise in eighteen months (DigitalApplied). OpenAI added native MCP support across Agents SDK, the Responses API, and ChatGPT desktop in March 2025; Google followed in Q1 2026 with support in the Gemini API and Vertex AI Agent Builder (DigitalApplied). Cursor, Windsurf, Zed, JetBrains AI Assistant, the Vercel AI SDK, and OpenAI's Agents SDK all ship MCP natively today. Claude Code is built around it.

The Agent-to-Agent protocol — the standard for one agent talking to another, across organizations — has fewer downloads but a more institutional adoption pattern. By May 2026, more than 150 organizations support A2A in production, including Microsoft, AWS, Salesforce, SAP and ServiceNow (Rapid Claw). The launch supporter list at the protocol's announcement read like a B2B SaaS census: Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, Workday (Platform Engineering). The v1.0 release shipped with Signed Agent Cards — a real identity-and-trust layer — and the AP2 payments extension lets two agents settle a transaction without a human in the loop (Google Cloud Blog).

What MCP and A2A do is structurally different but complementary. MCP is the agent-to-tool layer; an agent reaches out through MCP to a file system, a database, a SaaS API, a model. A2A is the agent-to-agent layer; an agent in one organization advertises its capabilities through a JSON metadata card at /.well-known/agent.json, receives a structured task payload over JSON-RPC 2.0, and streams results back via Server-Sent Events (Atlan). Together, the two protocols cover the two communication problems the agentic stack actually has — call a tool, call another agent — and both of them now sit under the same neutral governance body.

This is what "substrate" means in the Bulletin's working vocabulary. A substrate is the layer below the products. It is the layer the products do not control and cannot fork. It is the layer everyone has agreed to share.

Why the analogy with TCP/IP matters

We are deliberately reaching for the TCP/IP analogy here, and we want to be precise about which part of the analogy is doing the work.

TCP/IP did not win because it was technically superior to the alternatives. In the late 1980s and early 1990s, IBM's SNA, Digital's DECnet, Novell's IPX/SPX, and the OSI protocol suite were all credible competitors. TCP/IP won because it was neutralized — it sat with the IETF rather than with a single vendor, the standards process was open, and any organization that wanted to talk to any other organization had a path to interoperability that did not require licensing.

That neutralization moment is what creates a category. Before TCP/IP was neutralized, "networking" was a vendor stack. After, "networking" was a layer underneath the vendor stacks — and the interesting commercial work moved up. The companies that mattered after TCP/IP won were not the proprietary-protocol vendors. They were the companies that built on top of the neutralized substrate. Cisco. Akamai. Netscape. Eventually Google.

The pattern is recognizable in the MCP/A2A donation. Anthropic could have kept MCP proprietary. The protocol was theirs, the spec was theirs, the SDKs were theirs. The decision to give it away to a Linux Foundation fund — and to do so explicitly with OpenAI, Google, Microsoft, AWS, and the rest of the cloud incumbents as co-supporters — is the same kind of move that the early TCP/IP backers made when they declined to capture the substrate. It is a bet that the long-term value sits in what gets built on top of the protocol, not in what the protocol itself is.

The New Stack put the point cleanly in March: MCP "won because it was the first credible attempt to standardize the tool layer when LLM vendors otherwise had every incentive to fragment" (The New Stack). The structural condition for any substrate is that the would-be substrate owner had every incentive to not neutralize it, and chose to anyway. Anthropic did. Google did. The Linux Foundation absorbed the result.

That is the move. The substrate is live.

What the substrate is not

The substrate is not an operating system. This is the most important distinction in the Bulletin's working frame, and it is the one the marketing language of the category most consistently flattens.

An operating system, in the strict sense we use in our cornerstone profile, is what allows a heterogenous workforce of agents to coordinate, share resources, persist state, and present itself to a human operator through a unified interface. MCP and A2A do not do that. MCP is the syscall layer for tools. A2A is the IPC layer for agents. Neither of them is the operating system. Neither of them is the workforce. Neither of them is the interface.

This is why the Bulletin has been so insistent about the layering. The protocols are Layer 0. The operating systems sit on top of Layer 0. The workforces run on the operating systems. The interfaces are where the human operator meets the system. Conflating any two of these layers — and most of the category's marketing language conflates all four of them — costs the field clarity, and clarity is what the substrate moment is supposed to produce.

The substrate is also not the application. MCP can be used by Claude Code, by Cursor, by ChatGPT, by Gemini, by Replit Agent 4, by Devin, by every coding agent the directory tracks. A protocol that runs equally well under every commercial agent is, by definition, not the commercial agent. The substrate is the bottom. The category is the stack on top.

What "Web4" names

The Bulletin has been deliberately specific about what we mean by Web4. We mean the agentic-internet layer — the layer of autonomous services, structured agent coordination, persistent memory, and tool-mediated work, sitting on top of a neutral substrate. Web4 is not "AI" and it is not "AI-native." It is a layer, with a position in the stack, and it is the layer that gets built on top of MCP and A2A now that those protocols are neutralized.

The naming question matters more than it looks. The reason TCP/IP produced "the web" as a recognizable category was not the protocols themselves; it was the substrate's existence that made a coherent application layer thinkable. Before TCP/IP, "the network" was a vendor stack and "the application" was a vendor product. After, there was a layer the application could assume, and the application layer became a category.

Web4 is the application layer of the agentic substrate. It is what gets thinkable once MCP and A2A stop being vendor commodities. The companies that matter in this layer are not the ones that own pieces of the substrate — those companies have already given the substrate away — but the ones that build coherent systems on top of it. Operating systems. Workforces. Interfaces. Integration substrates. The full stack the Bulletin tracks.

Web4OS as one of the early operating systems

Web4OS, the platform the Bulletin profiled in our cornerstone piece on the operating-system pattern, is one of the early implementations of an operating-system layer that sits cleanly on top of the neutralized substrate. We have called it the cleanest reference implementation we have, and we want to be precise about what that claim does and does not say.

It does not say Web4OS is the only operating system that will matter. The Bulletin's working forecast in the predictions piece is that the operating-system layer will produce two or three clear leaders, and Web4OS is well-positioned to be one of them — not the only one. The substrate is open; the layer above it will be contested.

It does say that the pattern Web4OS implements — a coordinator that decomposes work into specialist agents, structured cards for operator decisions, persistent memory across sessions, MCP-mediated tool access, and credit-based commercial pricing rather than seats — is a coherent expression of what an operating system on the agentic substrate should look like. The product is built by Andrew Rollins and the team at Web4Guru, the Chiang Mai agency that doubles as a working example of the layer above operating systems: a workforce running on its own operating system, delivering real client work, and tightening the feedback loop between the substrate, the platform, and the operator. The Bulletin's editorial position is that this kind of platform-agency overlap is one of the load-bearing innovations of the autonomy-layer services category, and that it is structurally easier to achieve once the substrate is neutralized.

The neutralized substrate is what makes platforms like Web4OS possible without each platform having to invent its own protocol. The protocol stack is shared. The differentiation is the layer above.

What the next thirty-six months look like

The Bulletin's working forecast for the substrate layer over the next thirty-six months has three pieces.

Identity, trust, and reputation will be the contested layer. Signed Agent Cards solve part of the identity problem, but agent reputation, key rotation, and revocation are still early (Rapid Claw). There is no central trust registry for MCP servers comparable to npm; with 97 million monthly downloads and no canonical registry, server quality varies wildly (DigitalApplied). The first credible answer to agent reputation will be one of the most consequential standards moves of the next eighteen months. The Bulletin will be tracking the AAIF's working groups on this question closely.

The MCP/A2A boundary will get cleaner. As of mid-2026, the line between "agent-to-tool" and "agent-to-agent" is sometimes blurry — a complex MCP server can look a lot like an A2A endpoint, and the spec body is still resolving the overlap (Knak). We expect the boundary to harden. When it does, the architectural decisions in the layer above — about which work routes through MCP and which work routes through A2A — will become more recognizable, and the category's layering frame will get easier to teach.

Native authentication will replace bearer tokens. Most agents today still rely on bearer tokens passed through MCP rather than a real OAuth or OIDC flow scoped per-tool (The New Stack). This is the security gap most operators will hit first. The Bulletin's working forecast is that a proper OAuth-style scope grammar will emerge — possibly through the AAIF, possibly through a parallel working group — and that the products which built on bearer tokens will have to retrofit.

None of this is the substrate failing. All of it is the substrate maturing. The substrate is live. The work now is the layer above it.

A note on the donation, in plain language

We want to close with a piece of editorializing the Bulletin does not often do.

The decision by Anthropic to give MCP away — and by Google to give A2A away — is one of the most institutionally generous moves the AI category has seen this decade. Both companies had every commercial incentive to keep the protocols proprietary. Both companies chose to neutralize them. The result is that the agentic-internet layer has, for the first time, a substrate that no single party owns and that every party can build on.

We think this matters more than the funding rounds the trade press spends its time on. A $50B coding-agent valuation is interesting. A neutralized protocol stack underneath the entire category is structurally consequential in a way that valuations are not. The substrate is the slow-moving infrastructure that determines what the fast-moving applications can become.

The substrate is live. Web4 is the layer above. The interesting work has, finally, a foundation to be built on.