Every enterprise architecture decision carries the same hidden question: can I bet my organisation’s infrastructure on this technology, or will a single vendor’s pivot leave me rebuilding from scratch?
For the Model Context Protocol (MCP), that question had an uncomfortable answer through most of 2024. MCP was Anthropic-created and Anthropic-controlled. Smart technology, credible team, but single-vendor risk baked into the foundation.
That changed in December 2025. Anthropic donated MCP to the Linux Foundation and established the Agentic AI Foundation (AAIF) as the governance body. If you’re evaluating whether to build on MCP long-term, this changes the calculus entirely.
Here’s what you need to know: what the AAIF is, who co-founded it, how the SEP process stops unilateral spec changes, and what the IBM ACP and Google A2A merger means for the protocol landscape. Plus, how to use AAIF membership as a practical procurement signal. For a broader overview of how MCP works architecturally, see our MCP guide.
Why did Anthropic hand MCP to the Linux Foundation?
MCP was publicly released in November 2024 as an open standard for connecting AI models to external tools and data sources. Within 14 months it had crossed 10,000 active public servers, 97 million monthly SDK downloads, and adoption by ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code. It was already widely deployed infrastructure.
That scale created a governance problem. A protocol controlled by a single commercial vendor carries four specific failure modes: a unilateral breaking spec change that invalidates downstream deployments; vendor abandonment without community continuity; a licensing change affecting commercial use rights; protocol forking that fragments the ecosystem. That’s a lot to bet on one company’s goodwill.
The Linux Foundation donation addresses all four. In the Linux Foundation model, financial membership and technical control are structurally separated. Dues-paying members fund the foundation; Technical Committees — not the funders — set protocol roadmaps. No single company, including Anthropic, can unilaterally change, fork, or abandon MCP under this stewardship.
Anthropic’s own language is direct: the move was to ensure MCP “remains a neutral, open standard” with “vendor-neutrality and long-term independence under the same neutral stewardship that supports Kubernetes, PyTorch, and Node.js.”
MCP co-creator David Soria Parra put the goal plainly: “We’re all better off if we have an open integration centre where you can build something once as a developer and use it across any client.” The governance donation converts that ambition from a brand promise into a structural protection. If you’re running a technical procurement review, that distinction is what matters. For a deeper look at the M+N integration model that makes MCP valuable at scale, see the architecture overview.
What is the Agentic AI Foundation (AAIF) and who controls it?
The AAIF is not a standalone organisation. It is a directed fund under the Linux Foundation — the same structural model used by the Cloud Native Computing Foundation (CNCF), which governs Kubernetes. It was formed on 9 December 2025.
Platinum founding members are Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Gold members at launch included Cisco, IBM, JetBrains, Salesforce, SAP, Shopify, Snowflake, Twilio, and over a dozen others.
Worth pausing on that list. OpenAI — Anthropic’s direct commercial competitor — co-founded the same governance body. Competing commercial interests at the same neutral table makes unilateral protocol capture structurally difficult. No single member benefits from breaking what its rivals also depend on.
The AAIF Governing Board handles strategic investment, budget, and project approval. Individual projects — including MCP — maintain full technical autonomy. A Technical Committee with one representative from each Platinum member reviews new project proposals and holds publicly recorded biweekly meetings.
The founding projects are MCP (from Anthropic), Goose (from Block), and AGENTS.md (from OpenAI). The portfolio also includes UTCP and, through the A2A/ACP merger, the unified agent-to-agent protocol.
Jim Zemlin, Executive Director of the Linux Foundation: “Project roadmaps are set by technical steering committees, and no single member gets unilateral say over direction.”
For some context on adoption pace: according to the AAIF’s own Q1 update, within three months of launch, 97 new companies joined as Gold and Silver members — more than double the joining rate CNCF achieved at its own founding. The CNCF now counts nearly 800 members.
How does the IBM ACP and Google A2A merger change the agent protocol landscape?
Before August 2025, two separate agent-to-agent protocols were competing for adoption. Here’s the sequence.
IBM launched the Agent Communication Protocol (ACP) in March 2025 as part of its BeeAI platform — a REST-based architecture designed for simplicity and developer accessibility. Google announced the Agent-to-Agent Protocol (A2A) in April 2025, designed for enterprise-scale task delegation and coordination. In June 2025, Google donated A2A to the Linux Foundation; over 100 companies including Microsoft, AWS, Salesforce, and SAP signed on as supporters.
In August 2025, ACP merged with A2A. The reasoning was simple: both protocols addressed agent-to-agent communication, and maintaining two competing standards would fragment the ecosystem. ACP contributed developer-friendly REST patterns; A2A contributed enterprise-scale features and adoption base. The result is a unified protocol — referred to as A2A by the Linux Foundation and Google — now governed under the AAIF alongside MCP.
One disambiguation worth making. Two protocols carry the “ACP” abbreviation. The AAIF-governed A2A is the result of the IBM ACP and Google A2A merger. The JetBrains Agent Client Protocol, at agentclientprotocol.com, is an entirely separate IDE-focused standard. JetBrains is an AAIF Gold member, which compounds the confusion, but the two protocols are unrelated.
When you encounter “A2A” in current enterprise documentation, it refers to the unified post-merger protocol.
MCP and A2A are complementary, not competing. MCP governs the vertical tool-integration layer (LLM ↔︎ tool); A2A governs the horizontal agent-coordination layer (agent ↔︎ agent). In Google’s reference architecture, each A2A-capable agent also runs as an MCP client to access its own tools. Multi-agent enterprise deployments will likely use both. For how domain-specific protocols build on this foundation, see the article on vertical protocol extensions for AI agents.
What does the Kubernetes governance model tell us about MCP’s future?
The Kubernetes analogy isn’t rhetorical. It’s the structural precedent that defines what Linux Foundation stewardship means in practice.
Kubernetes was created by Google and donated to the CNCF in 2016. Today, AWS (EKS), Microsoft (AKS), and Google (GKE) all run it — and none of them can unilaterally change it. The Kubernetes Enhancement Proposal (KEP) process governs spec evolution with multi-stakeholder review. No single vendor can fork Kubernetes for competitive advantage without community endorsement.
PyTorch was created by Meta and donated to the PyTorch Foundation under the Linux Foundation. Node.js is governed under the OpenJS Foundation, also a Linux Foundation project. In each case, creator-vendor influence over the protocol is bounded by governance structure, not by continued goodwill.
The honest caveat: the analogy is instructive but not identical. Kubernetes had different competitive dynamics and a longer maturity curve. MCP is earlier in its lifecycle. The Linux Foundation precedent establishes a credible governance trajectory, not a guaranteed outcome.
Would you have delayed Kubernetes adoption waiting for it to prove itself? Organisations that standardised on Kubernetes before it cleared every governance milestone turned out to be right. The Linux Foundation model has a track record of surviving creator-vendor commercial pressure. MCP’s equivalent of the KEP process — the SEP — is the specific mechanism that provides the same structural protection. For a complete MCP architecture overview that covers the protocol’s design alongside its governance, our MCP guide brings these threads together.
What is the SEP Process and how does it protect MCP from unilateral vendor changes?
SEP stands for Specification Evolution Proposal — MCP’s formal change-control process within the AAIF. Any proposed change to the MCP specification must be submitted as a SEP, reviewed by the Technical Committee with multi-stakeholder input, and ratified before any spec change is merged. No single member, including Anthropic, can bypass this process.
MCP’s own documentation is explicit: “The Linux Foundation provides a neutral home and infrastructure that allows maintainers to operate independently, and will not dictate the technical direction of MCP.” Specification decisions are made by the maintainer community through the SEP process — not by Anthropic’s product team, and not by the AAIF Governing Board.
If you’ve worked with Kubernetes, the structural analogy is immediate. The SEP process is to MCP what the KEP process is to Kubernetes: a formal multi-stakeholder review process that prevents creator-vendor unilateral control.
The process is active. In approximately one quarter of 2025, the MCP maintainer community processed 17 SEPs with input from 58 maintainers and over 2,900 contributors. SEP-1302 formalised Working and Interest Groups; SEP-1309 addressed specification version management for SDKs in response to real-world implementation concerns.
Proposed spec changes are publicly visible through GitHub and the MCP roadmap before ratification. No surprise breaking changes. Teams running MCP-based systems can monitor the SEP pipeline and plan ahead.
What the SEP process prevents: unilateral breaking changes, feature removal, or protocol direction pivots by any single vendor. What it doesn’t prevent: protocol evolution — the spec will improve over time, but through a governed, predictable process. SEP guidelines are documented at modelcontextprotocol.io/community/sep-guidelines.
What does AAIF membership status mean for enterprise procurement decisions?
AAIF membership is a procurement signal, not a branding exercise. Reading the tier structure correctly matters for due diligence.
Platinum members — AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, OpenAI — hold the highest financial and governance commitment; each holds one seat on the Technical Committee. Gold members — IBM, Salesforce, SAP, Shopify, Snowflake, JetBrains, Cisco, and many others — signal adoption intent across the technology supply chain most organisations are already sourcing from.
When evaluating any agentic protocol, ask four questions: Who controls the specification? What process governs specification changes? What prevents breaking changes from reaching production? Which competitors and vendors have committed to the same protocol?
AAIF-governed protocols have documentable answers to all four. Specification control sits with the Technical Committee under the SEP process. And every major cloud hyperscaler — AWS, Google, Microsoft — is a Platinum member. When Anthropic, OpenAI, Google, Microsoft, and AWS all participate in the same structure, competitive dynamics enforce the neutrality. No single member benefits from breaking the protocol for others.
Swami Sivasubramanian, VP of Agentic AI at AWS: “Placing MCP in a vendor-neutral foundation ensures developers can invest confidently in this universal standard, knowing it will remain open, interoperable, and community-driven.”
Include AAIF membership status (Platinum or Gold) as an explicit criterion in enterprise AI platform RFPs and architectural reviews. Non-membership by a major vendor is a due-diligence flag — not an automatic disqualifier, but a question that deserves a direct answer. For platform-specific MCP support assessment across Google ADK, Microsoft Foundry, and JetBrains Koog, see the platform comparison article.
The decisions being made now will establish the infrastructure layer for agentic AI capabilities for years. For the full picture, see the MCP architecture overview.
Frequently Asked Questions
Is MCP still under Anthropic’s control?
No. Since December 2025, MCP governance sits with the maintainer community, guided through the SEP process under Linux Foundation stewardship. Anthropic is a Platinum AAIF member but cannot unilaterally change the specification — all changes must pass through the SEP process and Technical Committee review.
What is the difference between A2A and ACP?
Google’s A2A (announced April 2025) and IBM’s ACP (created March 2025 for the BeeAI platform) were separate agent-to-agent protocols. In August 2025, IBM ACP merged into A2A under Linux Foundation governance — combining ACP’s REST simplicity with A2A’s enterprise-scale capabilities. Current references to “A2A” describe the unified post-merger protocol. Separately, the JetBrains Agent Client Protocol (agentclientprotocol.com) is an unrelated IDE-focused standard with no connection to the AAIF-governed A2A.
Does joining AAIF mean losing intellectual property rights?
No. The Linux Foundation directed fund model allows protocol contributors to donate governance rights without surrendering IP ownership. Contributing companies retain their IP and assign specification governance rights to the Technical Committee — the same model used for Kubernetes and PyTorch.
