In March 2026, Model Context Protocol crossed 97 million installs. Shortly after, the Linux Foundation announced it would take MCP under open governance — removing it from Anthropic's sole stewardship and placing it in the same neutral infrastructure category as Linux, Kubernetes, and OpenAPI.
This post examines what that transition actually means: the governance mechanics, what changes for developers, and where the hype ends and the substance begins.
Photo by Ferenc Almasi on Unsplash | AI agent infrastructure is becoming neutral shared infrastructure
TL;DR
- MCP moves from Anthropic-managed to Linux Foundation open governance
- 97 million installs as of March 2026 — every major AI provider now ships MCP support
- Open governance means no single company controls the protocol's direction
- For developers: the MCP server ecosystem becomes more stable and vendor-neutral
- The governance shift won't change your day-to-day workflow immediately — but the long-term direction is clear
Why the Linux Foundation?
The Linux Foundation is the most trusted neutral ground in the software industry. Beyond the Linux kernel, it already stewards Kubernetes, Node.js, OpenAPI Specification, and dozens of other critical infrastructure projects. The pattern is consistent: take a technology that has grown beyond any single company's ownership, place it under a vendor-neutral governance structure, and let the industry build on a shared foundation.
The reasoning for MCP is straightforward. Anthropic created MCP in November 2024, but by March 2026 it had been adopted by OpenAI, Microsoft, Google, GitHub, NVIDIA, and essentially every major AI tooling company. At that point, Anthropic continuing to manage the protocol unilaterally created an uncomfortable dynamic: competitors were, in effect, building on infrastructure controlled by a rival.
The Linux Foundation transfer removes that friction. MCP becomes community property, governed by an advisory council with cross-company representation. Specification changes go through an open RFC process, not internal Anthropic engineering decisions.
The closest precedent is what happened to Swagger when it became the OpenAPI Initiative. That neutralization turned a useful format into a universal standard. MCP is following the same path.
What 97 Million Installs Actually Means
The install number needs context. MCP is not a utility library or a CLI tool — it's an agent connectivity protocol. Every install represents a client or server that connects AI models to external tools, data, or APIs using a standardized transport layer.
The trajectory: MCP launched in November 2024. It hit 97 million installs 16 months later. That growth was driven not by hobbyist experimentation but by production integrations — Claude Desktop, Cursor, GitHub Copilot, VS Code extensions, and enterprise AI platforms all shipping MCP as a core connection mechanism.
The April 2026 Claude Code update raised MCP result sizes to 500,000 characters via _meta["anthropic/maxResultSizeChars"]. That change was driven by real usage hitting the previous limits. At 97 million installs, MCP is being used in production at a scale that generates meaningful engineering feedback.
Open Governance: What Changes Before and After
The governance shift has concrete implications across several dimensions:
| Area | Before (Anthropic-managed) | After (Linux Foundation) |
|---|---|---|
| Spec changes | Anthropic internal decision | Open RFC process + advisory council |
| Primary contributors | Anthropic engineers | Any company or individual |
| Competitor trust | "Building on a rival's protocol" | Neutral shared infrastructure |
| Enterprise adoption speed | Requires careful legal review | Faster approval as Foundation standard |
| Security auditing | Anthropic-led | Industry-wide coordinated disclosure |
| Long-term continuity | Tied to Anthropic's business | Community-owned public good |
The most practically significant change is enterprise adoption speed. IT governance teams at financial institutions, healthcare organizations, and government agencies have established processes for approving Linux Foundation standards. They have no equivalent fast path for proprietary protocols managed by a startup — regardless of how widely adopted that protocol may be. The governance transfer effectively removes an approval bottleneck for a large class of potential MCP deployments.
What This Means for Building MCP Servers
The governance transition is the news, but the developer opportunity has been building for months.
MCP servers can already be built and deployed by anyone. The practical MCP introduction covered building a Python FastMCP server in under 30 minutes. What changes with open governance:
More clients to serve. As neutral-standard status accelerates enterprise adoption, the universe of MCP clients grows. A server you build today that works with Claude Desktop will increasingly work with every MCP-compatible platform — no client-specific integration work required.
More stable targets. Protocol changes through an open RFC process are slower and more predictable than changes driven by a single company's roadmap. Servers built against the current MCP spec face less risk of breaking changes.
A formal registry path. Open governance structures typically develop official package registries. When an MCP server registry launches under Linux Foundation auspices, discoverability and distribution become significantly easier.
A quick start if you haven't built an MCP server yet:
uv init my-mcp-server
cd my-mcp-server
uv add "mcp[cli]"
NVIDIA's Agent Toolkit and GitHub Copilot's agent mode both use MCP as their integration layer. The neutralization of the standard means those integrations rest on a more durable foundation — and that building against MCP today carries less long-term risk than it did when Anthropic was the sole steward.
MCP Support Across Major AI Tools (April 2026)
| Tool | MCP Support | Notes |
|---|---|---|
| Claude Desktop / Claude Code | Native | Creator, 500K result size extension |
| GitHub Copilot | Native | MCP servers in agent mode |
| Microsoft Copilot 365 | Supported | Azure-based MCP integration |
| Cursor | Native | Direct MCP server registration in IDE |
| NVIDIA Agent Toolkit | Supported | Enterprise AI pipeline integration |
| OpenAI (ChatGPT) | Supported | Adopted as plugin successor |
| Google Gemini | Supported | Vertex AI integration |
| Windsurf | Native | Multi-agent worktree support |
"Native" indicates MCP is the core connection mechanism for the platform. "Supported" indicates MCP connectivity is available but may not be the primary integration layer.
A Sober Assessment: What's Overstated and What Matters
What's overstated:
The governance transfer does not change MCP's technical capabilities today. If you build an MCP server this week, you'll use the same SDK, the same transport protocol, the same tool schema format you would have used yesterday. "Linux Foundation" is partly a marketing signal, and the immediate practical impact on individual developers is limited.
What genuinely matters:
Long-term continuity. Regardless of how Anthropic's business trajectory evolves, MCP's future is no longer tied to a single company's decisions. This matters for anything you build that has a multi-year lifespan.
Security governance at scale. Alongside industry movements like OpenAI's agent security bug bounty, open governance creates the structure for coordinated vulnerability disclosure and industry-wide security auditing of the protocol spec.
Accelerated standardization across verticals. The companies most constrained by "proprietary protocol" procurement rules are also the ones with the largest AI deployment budgets. Removing that friction opens MCP to markets where it previously faced institutional resistance.
The honest timeline: the governance shift's effects will take 6–12 months to show up meaningfully in developer experience. Formal advisory structures need to form, RFC processes need to run, and enterprise procurement cycles need to turn over. But the direction is set.
MCP is on the path to becoming infrastructure in the same category as HTTP or REST — the connectivity layer you use without thinking about it. The Linux Foundation transition is the formal moment that path became irreversible.
Photo by Patrick Martin on Unsplash | Building MCP servers now positions you well for where the ecosystem is heading
References:
- Linux Foundation to Host Model Context Protocol | Linux Foundation (March 2026)
- MCP Reaches 97M Installs, Moves to Open Governance | Anthropic (March 2026)
- MCP GitHub Organization | modelcontextprotocol (April 2026)
- Model Context Protocol | Wikipedia (April 2026)
Related posts:
- MCP (Model Context Protocol): Connecting AI Agents to Your Tools — A 2026 Practical Intro — Start here to build your first MCP server
- Claude Code April 2026 Update: /powerup, MCP 500K, Session Stability — What MCP 500K means in production
- NVIDIA Agent Toolkit: Building Enterprise AI Agent Pipelines — MCP in enterprise AI pipelines