MCP moves to neutral ground
The Model Context Protocol (MCP) is entering a new phase. Anthropic is donating the open source standard to the Agentic AI Foundation, which will be managed by the Linux Foundation. The move puts MCP on the same governance footing as Kubernetes, SPDX, GraphQL, and the CNCF stack — infrastructure projects maintained in the open rather than controlled by a single vendor.
The shift is a response to how quickly MCP has been adopted. The 2025 Octoverse report shows 1.13M public repositories importing an LLM SDK, up 178% year over year, with 693k new AI repositories created. Agentic tools like vllm, ollama, continue, aider, ragflow, and cline are becoming standard parts of the developer stack. MCP itself hit 37k GitHub stars in under eight months.
The problem MCP solves
Before MCP, connecting LLMs to external systems was a mess of incompatible integrations. OpenAI's function calling was a breakthrough, but by early 2023 developers were still stitching together bespoke extensions, IDE plugins, and platform-specific agent frameworks. Every provider had its own integration story with different semantics, authentication flows, and failure modes.
Nick Cooper, an OpenAI engineer and MCP steering committee member, summed up why those earlier attempts stalled: “All the platforms had their own attempts like function calling, plugin APIs, extensions, but they just didn’t get much traction.”
The root issue was an n×m integration problem. Every model client (n) had to integrate separately with every tool, service, or system (m). Five clients talking to ten systems meant fifty bespoke integrations. That was not just a tooling challenge but an innovation challenge — and in regulated industries like finance, healthcare, and security, developers got proprietary plugin ecosystems with unclear trust boundaries instead of secure, auditable, cross-platform options.
How MCP emerged
Engineers across Anthropic, GitHub, Microsoft, and elsewhere kept running into the same wall. Inside Anthropic, internal prototypes kept converging on similar patterns for requesting data, invoking tools, and handling long-running tasks. David Soria Parra, a senior engineer at Anthropic and one of MCP's original architects, described the protocol as a way to standardize patterns that teams were reinventing anyway.
That early internal traction was strong. Anthropic's Jerome Swanwick recalled an internal hackathon where “every entry was built on MCP … went viral internally.” When Anthropic released MCP publicly alongside reference servers, external developers understood the value immediately.
Why it took off
MCP adoption was immediate. Developers building AI-powered tools had already felt the pain the protocol solved. Den Delimarsky, a principal engineer at Microsoft and core steering committee member focused on security and OAuth, said: “It just clicked. I got the problem they were trying to solve; I get why this needs to exist.”
Within weeks, contributors from Anthropic, Microsoft, GitHub, OpenAI, and independent developers were expanding the protocol. Over nine months, the community added:
- OAuth flows for secure, remote servers
- Sampling semantics for consistent model behavior when tools are invoked or context is requested
- Refined tool schemas
- Consistent server discovery patterns
- Expanded reference implementations
- Improved long-running task support
Long-running task APIs were critical. Builds, indexing operations, deployments, and other multi-minute jobs could now be tracked predictably, without polling hacks or custom callback channels — essential for the long-running AI agent workflows emerging today.
Delimarsky's OAuth work was an inflection point. Before it, most MCP servers ran locally, which limited enterprise use and caused installation friction. OAuth enabled remote MCP servers and gave enterprises a familiar, proven security model without proprietary token formats or ad-hoc trust flows, making adoption inside existing authentication stacks significantly easier.
The MCP Registry, developed in the open with contributions from Anthropic, GitHub, and others, provided a discoverability layer for developers and governance control for enterprises. Toby Padilla, who leads MCP server and registry efforts at GitHub, described it as a way to ensure “developers can find high-quality servers, and enterprises can control what their users adopt.”
No single company drove MCP's trajectory. Cooper put it plainly: “I don't meet with Anthropic, I meet with David. And I don't meet with Google, I meet with Che.” The work was about the protocol, not corporate boundaries.
What Linux Foundation governance changes
As adoption accelerated, neutral governance became necessary. Openness drove initial adoption, but once multiple LLM providers, tool builders, and enterprise teams depended on MCP, shared stewardship was the natural next step.
Linux Foundation backing offers developers four concrete benefits:
Long-term stability
A protocol is only as strong as its longevity. Neutral governance reduces risk for teams building deep integrations on MCP.
Equal participation
Cloud providers, startups, and individual maintainers get equal contribution rights and transparent evolution processes.
Compatibility guarantees
As more clients, servers, and agent frameworks rely on MCP, compatibility becomes as important as the protocol itself.
The safety of an open standard
With AI increasingly part of regulated workloads, neutral governance makes MCP a safer bet for enterprise adoption.
The Agentic AI Foundation's stated intention is to bring together multiple model providers, platform teams, enterprise tool builders, and independent developers under a shared, neutral process. For developers operationalizing AI — not just experimenting with it — that shared stewardship is what turns a popular protocol into durable infrastructure.
What MCP gives developers in practice
The frequent question about MCP is straightforward: what does adopting it actually buy you? In concrete terms, the protocol delivers value in several distinct ways.
One integration, many consumers
Expose a tool once and use it across AI clients, agents, shells, and IDEs. This removes the need to write bespoke function-calling adapters for each model provider — a single server works everywhere.
Deterministic tool calls
MCP's schema-based approach makes tool interaction debuggable and testable. It feels closer to working with a formal API contract than to coaxing behavior out of a prompt.
Built for agent workflows
Agent-based development has shifted into mainstream practice. GitHub's Octoverse data shows more than 1 million agent-authored pull requests from the Copilot coding agent alone in its first five months, alongside rapid growth in AI projects such as vllm and ragflow, and a surge in local inference tools. Agents need structured, repeatable ways to invoke tools and retrieve context — which is precisely what MCP provides.
Enterprise-grade remote execution
With support for OAuth and remote servers, MCP extends naturally to enterprise environments, regulated workloads, multi-machine orchestration, and shared internal tools.
A rapidly expanding server ecosystem
Community and vendor-maintained MCP servers are appearing weekly. Developers can already connect to issue trackers, code search tools, repositories, observability platforms, internal APIs, cloud services, and personal productivity applications. As Soria Parra noted, the protocol's utility cuts both ways: not only can LLMs call tools through MCP, but developers can also use models to better understand their own complex systems.
Familiar developer patterns
MCP aligns with how software is already built — JSON Schema-based interfaces, reproducible workflows, containerized infrastructure, CI/CD pipelines, distributed systems, and local-first testing. The protocol deliberately mirrors established practices from API design and systems engineering, favoring predictable, contract-based interactions over opaque model behavior. Most developers don't want magic; they want systems that behave consistently.
The road ahead
The Linux Foundation move marks the start of a new phase for MCP, with expectations of broader contributions, more formal governance, and deeper integration into agent frameworks and cross-platform tooling. Given the 36 million new developers GitHub gained this year alone, shared standards for AI tooling are increasingly necessary.
MCP is positioned as a stable, open protocol for building agents and tools without vendor lock-in or proprietary extensions. The next generation of software will be defined not just by the models themselves, but by how those models connect to existing systems — and MCP is becoming the standard layer for that connection. With its new home in the Linux Foundation, stewardship of that standard now rests with the community.
