The companies building the most powerful AI systems in the world have started agreeing on something unusual. They don't just want to compete — they want to own the layer above the competition.
In December 2025, OpenAI, Anthropic, and Block showed up together under a Linux Foundation announcement for something called the Agentic AI Foundation (AAIF).
At the time, it looked like just another consortium. It wasn't. The AAIF introduced a new umbrella for "agentic AI" projects, with early contributions including Model Context Protocol (MCP) from Anthropic, AGENTS.md from OpenAI, and Goose from Block. Platinum members also include Amazon Web Services, Bloomberg, Cloudflare, Google, and Microsoft — making this not a three-company handshake but an industry-wide coordination effort. That combination alone was unusual: direct model competitors aligning in a shared foundation, alongside a fintech company, under neutral governance. Since then, the foundation has expanded and the intent has become clearer.
The agent layer needs a standard — and they want to define it early.
What actually happened — and why it matters now
The original Linux Foundation announcement wasn't symbolic. It introduced concrete building blocks with real adoption numbers behind them.
Anthropic → MCPOpenAI → AGENTS.mdBlock → Goose
MCP — open-sourced by Anthropic in November 2024 — had, within one year, reached over 97 million monthly SDK downloads and more than 10,000 published servers. It now has first-class client support across ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot, and VS Code.
AGENTS.md was released by OpenAI in August 2025 — not mentioned in the original draft — and has already been adopted by more than 60,000 open-source projects and agent frameworks, according to OpenAI's own announcement. Goose, Block's open-source agent framework, serves as a reference implementation for MCP and has been used by thousands of Block engineers weekly.
What looked like experiments at launch now looks like the beginnings of a stack. The question is who gets to define the defaults — and those defaults are already being written.
The speed of MCP's adoption alone should give pause to anyone inclined to dismiss this as vaporware. When a protocol goes from internal experiment to the de facto standard across five of the world's largest AI platforms in twelve months, you're not watching a standards discussion — you're watching infrastructure happen in real time.
What's actually new here
The important shift is not the existence of the foundation. It's the alignment across competitors. OpenAI and Anthropic are competing at the model layer. Block operates in payments and financial infrastructure. The Linux Foundation provides governance but not product direction. Yet they are converging on the same layer: agent orchestration, context sharing, and tool execution.
That convergence suggests something deeper than coordination. The model layer is stabilizing. Differentiation is moving up the stack. The next battle is about controlling how agents behave and interact — and whoever defines those defaults wins distribution without having to win every inference call.
To understand what's at stake, consider what protocols actually do when they win. HTTP didn't just connect computers — it determined the shape of the web. TCP/IP didn't just route packets — it defined what the internet could and couldn't be. MCP, if it achieves the same kind of lock-in, won't just connect AI agents to tools. It will determine which business models are easy to build and which require fighting the grain of the infrastructure.
"Just as APIs standardized how apps communicate, MCP has the potential to standardize how AI agents integrate with corporate systems. For an agent to make effective decisions, it requires more than just access — it needs the right context. That means awareness of the current state, the desired state, and the runtime environment in which it's operating." — Conor Sherman, CISO perspective via SDxCentral, January 2026
Why this matters to developers
If you're building anything AI-native, this layer is becoming unavoidable. The optimistic case: real interoperability across models and tools, agents that plug into shared ecosystems, less glue code and fewer one-off integrations. The pessimistic case: open standards that encode the assumptions of dominant players, products shaped by decisions you didn't make, and lock-in happening one layer higher than before.
The Kubernetes parallel is worth taking seriously. When Kubernetes became widely adopted, it unlocked enormous power but also exposed developers to infrastructure complexity they weren't meant to manage. The response wasn't to turn everyone into a Kubernetes expert — it was to introduce platform teams, DevOps roles, and abstractions that absorbed that complexity. MCP's trajectory looks similar: a powerful standard that will require its own class of specialists to deploy safely and at scale.
Gartner's 2025 Software Engineering Survey projects that by 2026, 75% of API gateway vendors and 50% of iPaaS vendors will have MCP features built in — which means the protocol is on track to become infrastructure the way REST is infrastructure. You don't choose whether to use it. You just do.
IBM's Kate Blair, who leads the company's BeeAI and Agent Stack initiatives — both contributed to the Linux Foundation — put it plainly: the protocols being built now will determine whether 2026 is the year multi-agent systems actually move into production or stay stuck in the lab. That's not a prediction; it's a timeline with a known set of dependencies, most of which run through the AAIF.
What's questionable
Not everyone is taking this at face value. Kyle Wiggers at TechCrunch notes that MCP co-creator David Soria Parra framed the goal explicitly: "The main goal is to have enough adoption in the world that it's the de facto standard." That's honest. But it also tells you something about the difference between a community standard and a vendor-neutral one.
Simon Willison, co-creator of Django, captured the skeptical view directly after the AAIF launch: MCP is barely a year old, still turbulent, and the Linux Foundation's model typically suits mature technologies — not protocols still finding their footing. Whether this is visionary infrastructure stewardship or premature institutionalization is a question that won't be answered for years.
A few things remain genuinely unclear. Who ultimately controls the evolution of MCP? How neutral will governance be in practice when the companies funding the foundation are also the primary beneficiaries of its defaults? Will smaller contributors meaningfully influence direction, or simply ratify decisions already made upstream?
There's a familiar pattern here. Large companies supporting "open" initiatives that standardize ecosystems around their own primitives. That doesn't make this illegitimate — the web itself was built this way. But it means this isn't just collaboration. It's coordination. And coordination, as any antitrust lawyer will tell you, is a word worth watching carefully.
Why each sponsor is putting weight behind this
This isn't philanthropy. Each company is buying influence over a layer that could define how AI systems are built and monetized for the next decade.
OpenAI: The API Economy Play
More standardized tooling means more surface area where OpenAI models get called. Interoperability drives API usage. API usage drives revenue. The math is not complicated.
Anthropic: The Governance High Ground
Neutrality is distribution. Donating MCP makes Claude a default participant in agent ecosystems while letting Anthropic claim the governance high ground. Both things are true simultaneously.
Block: The Payments Rails Bet
If agents become economic actors — and they will — Block wants to be the rails they transact on. Square and Cash App are already in the payments stack. Goose puts Block in the agent stack too.
Each sponsor is investing in the same thing: owning the default pathways through which AI systems operate. Not by locking developers in directly — but by shaping the environment everyone builds within. The primitives they donated to AAIF are already the starting point. That's the trade: donate the primitives, influence the standard, benefit from adoption.
The deeper play for OpenAI is worth noting separately. The company has been the most aggressive adopter of MCP despite not creating it — incorporating it as the foundation for the Apps ecosystem in ChatGPT, open-sourcing Codex CLI (which has helped merge more than two million public pull requests on GitHub), and co-founding AAIF. This is a company that understands platform ubiquity matters more than protocol ownership.
What they're actually contributing
None of the sponsors have disclosed specific dollar contributions. That's because the real investment isn't cash — it's infrastructure and intellectual property. Each company contributed a core piece of how they believe agents should work, and those contributions are now being developed under the foundation.
The code is open. The direction is nominally shared. But the starting point — the default way of doing things — came from these companies. They didn't just fund the foundation. They seeded it with their worldview.
"We're all better off if we have an open integration center where you can build something once as a developer and use it across any client. Donating MCP to AAIF signals that the protocol won't be controlled by a single vendor." — David Soria Parra, MCP co-creator and lead core maintainer, via TechCrunch, December 2025
That statement is both sincere and strategic. The goal of preventing single-vendor control is real. So is the goal of making MCP the universal standard — which, if achieved, makes the companies that designed its primitives the permanent reference point for how the whole industry works. Those two goals aren't in tension. They're the same goal, pursued through the same mechanism.
The bigger picture: follow the incentives, not the narrative
The story here isn't that "the agent layer is solidifying." It's that the companies funding this effort all benefit if agents become the dominant interface, interoperability is defined early, and their assumptions become the default. That's a completely rational set of incentives. It's also exactly the kind of coordination that shapes entire technology generations before most people notice it's happening.
IBM's prediction — that 2026 is when multi-agent systems come out of the lab and into real life — aligns with the AAIF's timeline almost exactly. The MCP Dev Summit North America is scheduled for April 2026. The first major release of Google's A2A protocol is imminent. The race to define the interoperability layer is not a future event. It is happening now, in committee meetings and GitHub pull requests, by people whose names you will not see in the headlines.
Protocols don't announce themselves as power moves. They arrive as conveniences. They spread as best practices. They calcify as infrastructure. By the time you notice the lock-in, it's already three layers below you.