Capabilities

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.

Claire Nakamura

Technical Writer, Frontier AI Coverage

Published 8 min read
A programmer with headphones focuses on coding at a computer setup with dual monitors.
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

Close-up of colorful programming code displayed on a monitor screen.

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?

Two developers programming at desks with large monitors in an office.

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.

What Changes and What Does Not?
QuestionBefore the moveAfter the move
Who hosts the project?AnthropicLinux Foundation fund
Who leads the spec?MaintainersSame maintainers
Is the license different?OpenOpen
Do my servers need changes?NoNo
Can rivals shape the roadmap?InformallyThrough 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?

Lines of source code displayed in a dark code editor.

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?

Detailed view of network cables plugged into a server rack in a data center.

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:

  1. Pick one internal, low-risk data source.
  2. Expose it as a read-only tool with a narrow description.
  3. Test it with two different MCP clients.
  4. Log every call the model makes.
  5. 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.

Do I need to change my existing MCP servers?
No. The move to the Agentic AI Foundation changed who hosts the project, not the protocol. Anthropic says governance stays unchanged and the maintainers continue to lead. Your current servers keep working, though you should follow spec releases for future changes to authorization and transports.
Is MCP only for Anthropic's Claude models?
No. MCP is an open protocol, and Anthropic lists support in ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code. A server you write once can be reached by clients built on different vendors' models, which is the main reason developers adopt it.
Does neutral governance make MCP more secure?
Not by itself. A foundation changes who steers the spec, not how your server is built. Security still depends on narrow tool scopes, read-only defaults, logging, and human review before any write action. Treat every tool you expose as a permission you are granting a model.

Written by

Claire Nakamura

Technical Writer, Frontier AI Coverage

8+ years experience

Claire Nakamura started as a developer relations engineer at two developer-tooling companies before moving into full-time technical journalism. She spends most of her working week with API documentation, model cards, and changelogs that most outlets skip past, and she is the person on staff most likely to have actually run the eval a press release is citing. At Emergent Wire she covers developer-facing AI tooling, agent frameworks, and the practical gap between a model's stated capabilities and what shows up in a production integration.

Credentials

  • Former developer relations engineer, developer-tooling sector (6 years)
  • Hands-on tester of API-based AI tools and agent frameworks
  • Regular contributor on model card and changelog analysis