MCP Governance: Why Anthropic Donated MCP to the Linux Foundation

When a technology standard is owned by a single company, every potential adopter faces the same uneasy question: what happens if that company changes direction? In December 2025, Anthropic answered that question preemptively by donating MCP governance to the Linux Foundation. Here's what happened, why it happened, and what it means for developers, enterprises, and the AI tool ecosystem.

What Happened: MCP Moves to the Linux Foundation

Alongside the November 2025 MCP spec update (version 2025-11-25), Anthropic announced the formation of the AAIF — the AI Agents Interoperability Foundation — as a new project under the Linux Foundation. Anthropic donated the MCP specification, its governance process, and the intellectual property framework to the AAIF. The spec's official home moved from Anthropic's repositories to a Linux Foundation–governed structure.

OpenAI, Google, and several enterprise software companies joined as founding or early members of the AAIF. This wasn't coincidental timing — the governance move was a prerequisite for getting competitors to formally adopt MCP rather than building competing standards. You can see the downstream effects in our coverage of what the November 2025 spec introduced.

What the Linux Foundation Is

The Linux Foundation is the world's leading organization for hosting and governing open-source and open-standards projects. Its portfolio includes Linux itself, Kubernetes, OpenTelemetry, the Open Container Initiative, and the Open SSF. They are specifically skilled at running vendor-neutral technical standards: maintaining intellectual property policies, hosting contributor license agreements (CLAs), and facilitating multi-company governance without any single company having veto power.

When enterprises evaluate infrastructure dependencies, Linux Foundation governance is a meaningful signal. It means: there's a formal IP policy, there's a contributor agreement, no single vendor can unilaterally end the project, and there's a legal framework for corporate participation.

Why Anthropic Did This

MCP's value proposition depends entirely on universal adoption. A tool protocol that only works with Claude is useful. A tool protocol that works with Claude, GPT-4, Gemini, Cursor, and every AI IDE is transformative. But OpenAI is not going to adopt a protocol that Anthropic controls — that would be handing a competitor leverage over their infrastructure.

By donating governance to the Linux Foundation, Anthropic made a calculated trade: they gave up unilateral control of MCP's roadmap in exchange for the credibility that would make competitors willing to adopt it. This is the same move Google made with Kubernetes (donating it to the CNCF), the same move IBM made with Eclipse, and the same pattern that has produced every major open infrastructure standard of the last two decades.

Put simply: Anthropic recognized that MCP's success required it to stop being Anthropic's protocol. The N×M problem MCP solves only gets solved if every AI company participates — and that only happens under neutral governance.

The AAIF: Structure and Members

The AI Agents Interoperability Foundation operates under standard Linux Foundation project governance. Key structural elements:

• Founding member: Anthropic (donated the initial spec and contributed the first technical steering committee members)
• Early adopters: OpenAI, Google, and enterprise software vendors joined as members, giving them seats on the governance body
• Technical Steering Committee (TSC): Oversees the spec roadmap and approves SEPs
• General membership: Any organization can join at various membership tiers, gaining voting rights on spec direction proportional to membership level

The SEP Process: How the Spec Now Changes

Under AAIF governance, changes to the MCP specification go through the SEP (Specification Enhancement Proposal) process. If you've worked with Python (PEPs) or Kubernetes (KEPs), this will feel familiar.

SEP Lifecycle:
1. Idea discussion  →  GitHub Issues / community forum
2. Draft SEP        →  Author writes formal proposal document
3. Public comment   →  30-day open review period
4. TSC review       →  Technical Steering Committee evaluation
5. Member vote      →  AAIF members vote on acceptance
6. Spec integration →  Merged into next spec version

The SEP document must include: the problem being solved, the proposed solution, backwards-compatibility analysis, security considerations, and reference implementation details. This is intentionally more rigorous than a pull request — it ensures that spec changes are deliberate and well-reasoned.

Smaller clarifications and bugfixes can go through a lighter process (similar to how Kubernetes distinguishes KEPs from regular PRs). But anything that changes the wire protocol, adds a new capability type, or modifies the security model requires a full SEP.

What Changes for Developers

The short answer: not much, immediately. MCP servers you built before the governance transfer continue to work — the spec didn't change at the moment of transfer, only who governs it going forward.

Practically, a few things do shift:

• Spec URL: The canonical spec now lives under an AAIF/Linux Foundation domain rather than Anthropic's GitHub.
• Contribution path: If you want to propose a spec change, you go through the AAIF process rather than opening a PR on Anthropic's repo.
• SDK stewardship: Official MCP SDKs (Python, TypeScript, Java, etc.) are maintained under the AAIF umbrella. Anthropic still contributes substantially, but other companies also maintain and review SDK code.
• More clients: AAIF membership from OpenAI and Google means MCP servers will work with more clients over time — more reason to build for MCP rather than proprietary tool APIs.

What Changes for Enterprises

This is where the governance move has its largest impact. Enterprise legal and procurement teams are cautious about infrastructure dependencies on single vendors. Linux Foundation governance changes the calculus substantially:

• IP policy: The Linux Foundation's standard IP framework means enterprises know exactly what license terms apply to the spec and reference implementations.
• Contributor agreements: Standard CLAs managed by the Linux Foundation satisfy legal requirements that ad-hoc GitHub contribution models often don't.
• No vendor lock-in risk: No single company can remove features, change licensing, or pivot the spec in a direction that harms a specific competitor or customer.
• Procurement comfort: When enterprises evaluate tools that depend on MCP, Linux Foundation governance appears in procurement checklists the same way Apache or W3C standards do.

Historical Precedent: How Standards Go Neutral

This is a well-worn path. Major infrastructure standards regularly follow the same trajectory:

The pattern is consistent: a company builds something valuable, realizes its value multiplies with broad adoption, and donates governance to enable that adoption. The company retains significant influence as a founding member and major contributor — they don't lose control entirely, they just share it.

The Bigger Picture: MCP as Infrastructure

The Linux Foundation governance move signals something important about how the industry views MCP: not as a product feature, but as infrastructure. Infrastructure standards — HTTP, TCP/IP, USB — are managed by neutral bodies because everyone needs them and no single company should control them.

MCP is positioning itself as the USB-C of AI tools: a universal connection standard that any tool can implement and any AI client can use. USB-C is governed by the USB Implementers Forum, not by Apple or Intel. MCP under AAIF governance follows the same logic.

For developers building MCP servers today, this is unambiguously good news. The servers you build are now investments in a neutral standard, not bets on Anthropic's continued success. And as more AI vendors adopt MCP, the addressable market for your MCP servers grows.

What to Watch Going Forward

• AAIF membership growth: Which AI companies and cloud providers join as members indicates MCP's trajectory as an industry standard.
• SEP activity: The first SEPs will reveal what the community wants to change — authentication improvements, streaming enhancements, new capability types.
• SDK contributions: When companies other than Anthropic start significantly contributing to the official SDKs, that's the signal that governance is genuinely shared.
• Enterprise procurement: Watch for MCP to appear in enterprise software RFPs as a required interoperability standard, similar to how OpenAPI appears today.