MCP Under the Linux Foundation: What Developers Should Do in 2026
The Model Context Protocol now sits in a neutral foundation. Here is what that changes for teams building agents, what it does not, and how to plan around it.
In this story 9 sections
The Model Context Protocol (MCP) is an open standard that lets AI apps connect to tools and data through one common interface. Since December 2025 it has lived under the Linux Foundation's Agentic AI Foundation. For developers, that means neutral governance, no change to the spec's maintainers, and lower lock-in risk when building agent integrations.
This explainer is for engineers and technical leads who are deciding whether to build agent integrations on MCP. Emergent Wire tests AI claims against results, so we looked at what the foundation move actually changes in practice. The short version is that it changes who owns the standard far more than it changes your code.
What Is the Agentic AI Foundation?
The Agentic AI Foundation (AAIF) is a directed fund under the Linux Foundation, announced December 9, 2025. It hosts three founding projects: Anthropic's Model Context Protocol, Block's goose agent, and OpenAI's AGENTS.md. Its stated aim is to help agentic AI develop transparently and collaboratively through neutral, open governance.
The Linux Foundation's announcement lists eight platinum members: Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. That roster matters. It puts direct competitors at the same table, which is rare for a protocol that sits between models and the tools they use.
The word agentic itself is slippery, and we have argued before that agentic AI became 2026's most overused term. Here it simply means software where a model chooses and calls tools to finish a task. MCP is the plumbing for that tool calling.
How MCP Works in Plain Terms
MCP defines how an AI application, called the client, talks to a separate program, called the server. The server exposes tools, data, or prompts. The client discovers what is available and lets the model use it. Before MCP, each pairing of app and tool needed its own custom connector.
A concrete example makes this clearer. Suppose you write one MCP server that reads your company's ticketing system. Any MCP-capable client can now query it without new code. You write the integration once, and the client side is somebody else's job.
Here are the core pieces a developer touches:
- Tools, which are functions the model can call.
- Resources, which are data the model can read.
- Prompts, which are reusable templates the user can invoke.
- Transports, which define how client and server exchange messages.
None of these change because of the foundation move. Your existing servers keep working. What changes is who can propose and approve changes to the spec itself.
What Changes and What Does Not?
Ownership changes. Engineering does not, at least not immediately. In Anthropic's announcement of the donation, the company states that the protocol's governance model will remain unchanged, with maintainers continuing to prioritize community input and transparent decision-making.
The table below separates the real shifts from the assumed ones.
| Question | Before the move | After the move |
|---|---|---|
| Who hosts the project? | Anthropic | Linux Foundation fund |
| Who leads the spec? | Maintainers | Same maintainers |
| Is the license different? | Open | Open |
| Do my servers need changes? | No | No |
| Can rivals shape the roadmap? | Informally | Through foundation membership |
The last row is the real story. A standard owned by one lab is a standard that lab can steer. A standard hosted in a neutral fund is harder for any single member to bend toward its own product.
That said, neutral hosting is not a guarantee of good design. Standards bodies move slowly, and working groups can stall. Developers should watch the pace of spec releases, not only the press releases.
How Big Is MCP's Reach Today?
Anthropic reports more than 10,000 active public MCP servers and over 97 million monthly SDK downloads across Python and TypeScript. It also lists support in ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code. These are vendor figures as of December 2025, so treat them as a floor for adoption claims, not an audit.
Download counts also overstate real usage. Automated builds, mirrors, and test pipelines inflate them. A better signal is client support. When rival products all ship an MCP client, building one server that reaches all of them becomes a sound bet.
The multi-vendor picture fits a wider trend. Models from rival labs now show up on each other's clouds, as we covered in our look at OpenAI models arriving on Google Cloud. Buyers want portable tooling, and an open protocol is one way to get it.
Should You Build on MCP Now?
Yes, for most tool-integration work. MCP is supported across ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code, according to Anthropic, so one server can reach many clients. Hold off only if you need guarantees the spec does not yet give, such as strict authorization models or audited enterprise controls.
Security deserves its own warning. An MCP server hands a model the power to act on real systems. A badly scoped tool can read data it should not, or change records without review. Nothing in the foundation move fixes that. Your design does.
We have seen the gap between a standard's promise and a production integration come down to scoping. Teams that start with narrow, read-only tools learn fast and break little. Teams that expose write access on day one tend to spend weeks on cleanup.
Follow these steps for a safe first build:
- Pick one internal, low-risk data source.
- Expose it as a read-only tool with a narrow description.
- Test it with two different MCP clients.
- Log every call the model makes.
- Add write actions only after a human review step exists.
Where MCP Still Falls Short
MCP solves discovery and connection. It does not solve judgment. A model can still pick the wrong tool, pass a bad argument, or loop on a failing call. The protocol carries the request faithfully, whether or not the request makes sense.
Context load is the next problem. Each connected server adds tool descriptions to the model's prompt. Connect twenty servers and the model spends a large share of its context window reading menus before it does any work. Accuracy often drops as the menu grows, because the model has more near-duplicate options to choose between.
Authorization is the third gap. Early MCP servers often ran with broad credentials, since that was easiest. Production teams now need per-user permissions, audit trails, and clear limits on what a tool can touch. These are active areas of spec work, and a neutral foundation gives rival vendors a formal place to argue them out.
The honest summary is that MCP is a good connector and an incomplete safety system. Treat it as one layer in a stack that also includes access control, monitoring, and human review.
How to Prepare Your Team for Spec Changes
Standards evolve, and MCP will too. The cheapest protection is to isolate protocol details behind a thin layer in your own code. When the spec changes, you update one module instead of every server.
These habits keep upgrades painless:
- Pin the SDK version and upgrade on a schedule.
- Keep tool logic separate from protocol handling.
- Write tests that call each tool through a real client.
- Subscribe to the project's release notes and changelog.
- Document which clients your team has verified.
Reading changelogs is dull work, but it pays. The details that break integrations rarely appear in announcements. They show up in a one-line note about a renamed field or a deprecated transport. Teams that read those notes ship fewer surprises.
Finally, plan for the possibility that you will run more than one protocol. Agent tooling is still young, and rival conventions exist alongside MCP. A thin adapter layer costs little today and saves a rewrite if the landscape shifts.
What About Cost and Model Choice?
Tool calling adds tokens. Every tool description, every call, and every result counts against your bill. That makes pricing part of the architecture decision, not an afterthought.
Cheaper flagship models change the math on how many tool calls an agent can afford. Our analysis of flagship pricing and unit economics walks through how per-token price shifts the cost of a long agent run. A protocol that works across vendors lets you swap models when prices move, without rewriting your integrations.
That portability is the practical payoff of neutral governance. You are not betting on one lab's roadmap. You are betting on a shared interface that several labs have an interest in keeping stable.
Conclusion: Treat MCP as Shared Infrastructure
The move to the Agentic AI Foundation makes MCP safer to depend on, not easier to secure. Ownership is now neutral, the maintainers are unchanged, and the biggest clients already speak the protocol. Your servers need no changes today.
The next step is small. Build one read-only server against a low-risk data source, test it in two clients, and log the calls. At Emergent Wire, we judge a standard by what survives contact with a real integration, and that first small build will tell you more than any announcement.