On December 9, 2025, three companies that compete for the same developers, the same enterprise budgets, and the same frontier model benchmarks made an unusual decision. They gave away their most strategic agent infrastructure to a neutral foundation.
Anthropic donated the Model Context Protocol — the universal standard for connecting AI agents to tools and data. OpenAI contributed AGENTS.md — the instruction format that tells coding agents how to work in a repository. Block contributed goose — an open-source agent framework that runs locally on developer machines. Together, these three projects form the foundation of the newly created Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation.
The numbers tell the scale: 97 million monthly SDK downloads for MCP. More than 10,000 published MCP servers. AGENTS.md adopted by over 60,000 open-source projects. Goose attracting thousands of developers as a reference implementation.
Most people read this as corporate altruism. It isn't. It's a calculated strategic move that reveals something fundamental about how agent infrastructure is evolving — and who's actually betting on it.
Why You Donate Your Crown Jewels
Here's the contrarian read: these donations aren't about openness. They're about velocity through standardization.
Consider what happens when a protocol stays proprietary. Adoption requires trust. Trust requires the belief that the owner won't change the rules, introduce breaking changes to disadvantage competitors, or sunset the project entirely. Every enterprise architect evaluating MCP had to ask: "What happens if Anthropic changes direction?" Every developer adopting AGENTS.md had to wonder: "Will OpenAI eventually use this to lock me into their ecosystem?"
Those questions are adoption friction. And friction is the enemy of infrastructure. TCP/IP didn't become the backbone of the internet because it was technically superior to OSI — it won because nobody owned it. HTTP didn't become the web's transfer protocol because it was elegant — it won because CERN released it royalty-free. Linux didn't dominate servers because it was the best kernel — it won because no company could kill it.
The pattern is consistent: infrastructure that succeeds at scale is infrastructure that no single entity controls.
The AAIF co-founders understood this. Mike Krieger, Anthropic's Chief Product Officer, put it plainly: "Donating MCP to the Linux Foundation as part of the AAIF ensures it stays open, neutral, and community-driven as it becomes critical infrastructure for AI." That last phrase — "critical infrastructure" — is doing heavy lifting. They're acknowledging that MCP has crossed the threshold from product to platform, and platforms can't be owned.
The Three Projects and What They Actually Do
MCP: The Connective Tissue
Anthropic open-sourced the Model Context Protocol in November 2024. In just over a year, it became the de facto standard for connecting AI agents to external systems — databases, APIs, file systems, code repositories. Think of it as a USB port for AI: any agent can connect to any tool as long as both sides speak MCP.
The adoption curve has been remarkable. Claude, ChatGPT, Gemini, Microsoft Copilot, Cursor, VS Code — virtually every major AI platform now supports MCP natively. The November 2025 spec release added asynchronous operations, server identity, and official extensions. The SDK sees 97 million monthly downloads across Python and TypeScript. An official MCP Registry now helps developers discover available servers.
MCP matters because it solves the N×M integration problem. Without it, every agent-to-tool combination requires a custom integration. With N agents and M tools, that's N×M connections. MCP reduces it to N+M — each agent implements one client, each tool implements one server. This is the same reduction that made JDBC transform database connectivity and that made HTTP transform web services.
AGENTS.md: The Instruction Layer
OpenAI released AGENTS.md in August 2025 as a simple but powerful idea: a markdown file at the root of a repository that tells coding agents what they need to know about the project. Think of it as a README, but written for machines instead of humans.
The format is intentionally minimal — standard Markdown, no required fields, no schema. It covers things like build commands, test instructions, code conventions, and security guidelines. In monorepos, nested AGENTS.md files provide subproject-specific instructions, with the nearest file taking precedence.
What started as a convenience has become a convention. Over 60,000 open-source projects now ship AGENTS.md files. The format emerged from collaboration across the agent ecosystem — OpenAI Codex, Google's Jules, Cursor, Amp, and Factory all contributed. The repository on GitHub has over 22,000 stars.
AGENTS.md matters because it addresses a real gap in agent-first development: agents need structured context, and context delivery needs to be standardized. Without a predictable place for instructions, every agent invents its own discovery mechanism. With AGENTS.md, any agent can walk into any repository and immediately understand the project's conventions.
Goose: The Reference Implementation
Block's goose is the least known of the three but arguably the most practical. It's an open-source, local-first agent framework that combines language models, extensible tools, and MCP-based integration. Think of it as a reference architecture: a working example of how to build an agent that actually does useful work.
Goose runs locally on developer machines, can work with any LLM that supports tool calling, and uses MCP for all its integrations. Block has been using it internally at scale — their principal engineer Brad Axen described thousands of engineers using it daily. By donating it to the AAIF, Block is positioning goose as the canonical "how to build a production agent" example that anyone can fork, study, and adapt.
The Governance Architecture
The AAIF isn't just a press release. It has real structure. The foundation operates as a directed fund under the Linux Foundation, which brings decades of governance experience from stewarding projects like the Linux Kernel, Kubernetes, Node.js, and PyTorch.
The Governing Board includes Platinum members from Amazon, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Each appoints a representative. But crucially, the board handles strategic decisions — budget, member recruitment, project approval — while individual projects maintain full autonomy over technical direction. MCP's maintainers still run MCP. AGENTS.md's maintainers still run AGENTS.md. The Linux Foundation provides the neutral umbrella, not the technical steering.
This governance structure solves the trust problem definitively. As the Linux Foundation's Mike Dolan noted, contributing to the foundation means transferring assets — trademark, GitHub account — that could restrict the community. "A single company cannot 'take it back' later," he wrote. Google made the same move with A2A in June 2025, donating its agent-to-agent communication protocol to the Linux Foundation after 100+ companies had already adopted it.
What the Consolidation Actually Means
Here's what most commentary missed: the AAIF isn't three random projects joining forces. It's the complete agent stack — instruction (AGENTS.md), connectivity (MCP), and execution (goose) — moving to neutral governance simultaneously.
Combine this with Google's A2A protocol donation (agent-to-agent communication) and Cisco's AGNTCY contribution (agent discovery, identity, and observability), and you have the full protocol stack settling into community ownership:
- AGENTS.md — how agents understand your project
- MCP — how agents connect to tools and data
- A2A — how agents talk to each other
- AGNTCY — how agents are discovered, identified, and observed
- goose — a reference implementation showing how to build an agent that uses all of the above
Every layer of the agent protocol stack is now governed by a vendor-neutral foundation. The protocol wars are over. The infrastructure is settled. What comes next is adoption and differentiation on top.
Why the Competitive Landscape Just Shifted
Most people think open-sourcing infrastructure levels the playing field — everyone gets the same tools, so competition moves elsewhere. That's half right. The more interesting effect is what it does to where competition happens.
When the protocol layer is neutral, vendors can't compete on lock-in. Anthropic can't make MCP work better with Claude by withholding features from OpenAI. OpenAI can't make AGENTS.md a ChatGPT-only format. The differentiation shifts upward — to model quality, agent orchestration, domain-specific tooling, and the harness engineering that determines how well agents actually perform in production.
This is good for the ecosystem and uncomfortable for vendors. It means the moat you thought you had — owning the standard — is gone. The new moat is execution: who builds the best agents on top of shared infrastructure?
For developers, it's unambiguously positive. You can now build agent-first systems on a stack where no single company can pull the rug out. Your MCP servers will keep working regardless of which AI platform wins. Your AGENTS.md files will be readable by any coding agent. Your agent frameworks can interoperate through standardized protocols instead of fragile custom integrations.
The Real Winner: The Linux Foundation Playbook
The Linux Foundation has now executed the same playbook three times in AI: accept a corporate project, provide neutral governance, and watch adoption accelerate. A2A in June. MCP, AGENTS.md, and goose in December. The pattern is working.
The foundation brings something no single company can: credible neutrality. When Anthropic says "MCP is open," enterprises still hesitate. When the Linux Foundation says "MCP is governed under AAIF," procurement teams relax. The trust transfer is real and measurable — Gartner analyst Jim Scheibmeir noted that the donation will be "a net positive for the protocol's future" and predicted increased enterprise adoption in 2026.
Gartner separately predicts that 40% of enterprise applications will feature task-specific AI agents by 2026. Those agents need standards. Those standards need governance. And governance needs to be neutral. The AAIF is the institutional answer to that requirement.
What This Means for You
If you're building agent-first software, the infrastructure layer just became a solved problem. Here's what to do about it:
- Adopt MCP without hesitation. The protocol is now neutral, governed, and adopted by every major platform. Building custom agent-to-tool integrations instead of MCP servers is technical debt you'll regret.
- Add AGENTS.md to every repository. It takes 30 minutes, works across all major coding agents, and dramatically improves agent effectiveness. Think of it as documentation that actually gets read — because the reader is a machine that never skips sections.
- Study goose as architecture, not just code. Whether or not you use it directly, Block's framework demonstrates how to structure a production agent that's local-first, MCP-native, and model-agnostic. The patterns matter more than the implementation.
- Stop worrying about protocol lock-in. The stack is settled. Your energy should go into what sits on top — the harness, the context engineering, the verification systems that determine whether your agents produce reliable results. That's where competitive advantage lives now.
- Contribute back. These are now community projects. If you find bugs, file issues. If you build useful MCP servers, publish them. If you have opinions on AGENTS.md's evolution, join the discussion. The infrastructure is only as good as the community maintaining it.
The Bigger Picture
The AAIF marks a turning point in how the industry thinks about AI infrastructure. For the past two years, the assumption has been that the company with the best model would also own the ecosystem around it. OpenAI would own the agent format. Anthropic would own the tool protocol. Google would own inter-agent communication.
That assumption was wrong. The most competitive companies in AI just demonstrated that they understand something their critics don't: infrastructure value compounds through adoption, not through ownership. The more people build on MCP, the more valuable Claude becomes — not because Claude is the only model that works with MCP, but because MCP makes the entire ecosystem richer, and a richer ecosystem drives more usage of all models.
This is the same logic that drove Google to open-source Kubernetes, Facebook to open-source React, and Microsoft to acquire GitHub and then make its core features free. Open infrastructure creates larger markets. Larger markets create more value for everyone — including the companies that donated the infrastructure in the first place.
The agent era's foundational layer is now open, neutral, and community-governed. The question isn't whether agents will be built on shared standards. They will be. The question is what you'll build on top of them.