A year ago, the Model Context Protocol was one company's idea for connecting AI models to tools. This month, it stopped belonging to that company.

On 9 December 2025, Anthropic donated MCP to the Agentic AI Foundation, a new directed fund under the Linux Foundation, which it co-founded with OpenAI and Block. If you build anything that connects AI to real systems, that's a quiet but important piece of news. Here's what happened, why it matters, and what it does (and doesn't) change for developers.

First, a 30-second refresher on MCP

MCP is an open protocol that lets AI applications talk to external tools and data in a standard way. An MCP server exposes capabilities, like "search the docs", "query this database" or "create a ticket". An MCP client, inside an AI app or coding agent, discovers those capabilities and lets the model call them.

The usual analogy is USB-C. Before it, every device had its own cable. Before MCP, every AI tool had its own way of plugging into GitHub, Slack, your database or your app. With MCP, you build the connector once and any compatible client can use it.

Anthropic introduced it in November 2024. Through 2025 it spread fast: OpenAI adopted it in March, and today it's supported across a wide range of assistants, coding agents and editors. Framework-specific servers appeared too, such as Laravel Boost for Laravel apps.

What actually happened

• Who: Anthropic, the company that created MCP.
• What: donated the protocol to the Agentic AI Foundation.
• Where: the foundation is a directed fund under the Linux Foundation, co-founded by Anthropic, OpenAI and Block.
• When: 9 December 2025.
• Why it matters: MCP is now governed as an open standard by a neutral organisation, rather than owned by a single AI company.

Why neutral governance is a big deal

An open specification and an open standard are not quite the same thing. Anyone could read and implement MCP from day one. But as long as one company owned it, every competitor adopting it had to trust that the owner wouldn't steer it in a direction that suited only themselves.

Moving it to a neutral home changes that conversation. This pattern has played out before in our industry. Kubernetes was created at Google and handed to the Cloud Native Computing Foundation, part of the Linux Foundation, and it became the default way to run containers across every major cloud. Node.js found a neutral home in a foundation too. Neutral governance is often what turns "a good technology from one vendor" into "the thing everyone builds on".

The fact that OpenAI co-founded the foundation is the signal to notice. Competitors sharing a standard is how ecosystems grow; competitors each pushing their own protocol is how developers end up writing the same integration three times.

What changes for developers

If you build MCP servers

Nothing breaks. The protocol you implemented last week is the same protocol today. What changes is confidence: an MCP server you build for your product or internal system is more likely to keep working across clients, including ones that don't exist yet.

If you've been holding off on exposing your API or internal tools to AI agents because the standards felt unsettled, this is a reasonable moment to stop waiting.

If you use AI coding tools

You probably won't notice anything directly. Indirectly, it's good news: the connectors you set up (for your issue tracker, database, docs or framework) are more likely to work across Claude Code, ChatGPT, Copilot, Cursor and whatever you use next year. Less lock-in, more choice.

If you lead a team

Open governance makes MCP an easier conversation with security and procurement teams. "We're adopting an open standard under the Linux Foundation" lands differently than "we're adopting a vendor's protocol".

What doesn't change

A neutral owner doesn't make your MCP servers secure. That part is still on you, and it's where I'd focus attention:

• Least privilege. An MCP server with full database write access gives every connected agent full database write access. Expose the smallest useful set of tools, read-only where possible.
• Prompt injection. Data an agent reads through a tool (an issue, an email, a web page) can contain instructions aimed at the model. Treat tool output as untrusted input.
• Third-party servers. Installing an MCP server is installing software that an AI can drive. Review it like any other dependency.
• Human approval for anything destructive or expensive, regardless of which client is calling.

My take

Standards rarely make headlines, and this one won't trend for long. But I think this is one of the more important developer stories of the year. A year ago, connecting AI to your systems meant picking a vendor and hoping. Now there's a shared plug with a neutral owner, and that's usually the moment an ecosystem starts to grow up.

The official MCP site is the best place to start if you want to build a server of your own.

Are you running any MCP servers in your workflow yet? I'm curious which integration people found most useful first: docs, database, issue tracker, or something else.