The State of MCP in H1 2026: What Actually Changed

TL;DR:

• Anthropic no longer owns MCP. In December 2025, Anthropic transferred the Model Context Protocol to the Agentic AI Foundation, a new directed fund under the Linux Foundation co-founded with Block and OpenAI and backed by Google, Microsoft, AWS, Cloudflare, and Bloomberg. The protocol a chat-assistant company wrote for itself in late 2024 is now governed the way a shared standard is governed.
• The wire format has moved five times in twenty months, and it is about to move again. Revisions shipped on 2024-11-05, 2025-03-26, 2025-06-18, and 2025-11-25; a 2026-07-28 release candidate, locked in May 2026, removes the session handshake entirely and makes the protocol stateless at the transport layer.
• Cross-vendor adoption is real, confirmed straight from the protocol's own steward rather than a vendor's marketing line. Anthropic's own December 2025 numbers cite more than 10,000 active public MCP servers and 97M+ monthly SDK downloads, with ChatGPT, Cursor, Gemini, Microsoft Copilot, and VS Code already on the client list.
• Nobody publishes a live count of how many MCP servers exist right now. The official MCP Registry ships discovery, not a dashboard, so every server-count figure in circulation — including Anthropic's own — is a dated snapshot, not a running total.
• A production server can run a year behind the spec and still work fine. Scrapeless's own hosted MCP endpoint, checked live while writing this, still negotiates the original 2024-11-05 handshake and now serves 21 tools, up from 19 at launch — exactly what the protocol's backward-compatible versioning is built to allow, at least until the stateless revision ships.
• Free to start. New Scrapeless accounts include free MCP runtime — sign up at app.scrapeless.com.

---

A protocol that outran the company that wrote it

An agent connecting to a Model Context Protocol server today opens with a handshake Anthropic designed by itself, alone, in November 2024. Eighteen months later, Anthropic does not govern the document that defines that handshake, and the handshake itself is scheduled for removal in the next revision. Neither fact changes what happens when the agent calls a tool. That gap — between how much the protocol's governance and wire format have moved and how little of it disturbs a working integration — is the actual state of MCP in the first half of 2026.

MCP launched as Anthropic's answer to the M-by-N integration problem: every agent that wanted to search the web, read a file, and query a database needed a separate adapter for each, and swapping the model meant rebuilding all three. A single client–server contract, built on JSON-RPC, was the fix. What has changed since is not the core idea. It is who controls it, how often the specification underneath it is rewritten, and how unevenly the ecosystem has absorbed both.

From Anthropic's spec to a foundation's standard

On December 9, 2025, Anthropic handed the Model Context Protocol to the Agentic AI Foundation (AAIF), a new directed fund under the Linux Foundation. The foundation was co-founded by Anthropic, Block, and OpenAI, with Google, Microsoft, AWS, Cloudflare, and Bloomberg named as supporting companies in the announcement transferring MCP's governance. MCP joined Block's goose and OpenAI's AGENTS.md as one of the foundation's three founding projects — a detail worth sitting with: the protocol's own creator and one of its most consequential rivals became co-stewards of the same governance body.

The same announcement is where most of the adoption numbers people cite trace back to: more than 10,000 active public MCP servers, 97M+ monthly SDK downloads across Python and TypeScript, more than 75 MCP-powered connectors in Claude's own directory, and a client list that already read ChatGPT, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code. Those are Anthropic's own figures, dated to a specific announcement, not an independent census — a distinction the next section returns to.

Governance maturity shows up in the process, not just the org chart. Under the foundation, MCP now runs a formal deprecation lifecycle — a feature moves through Active, Deprecated, and Removed states with a minimum twelve-month gap between phases — and the foundation's own account of that shift notes that Standards-Track proposals now need matching test cases in a conformance suite before they can reach Final status. That is a materially slower, more accountable process than one company shipping a changelog, and it is the trade every vendor-protocol-to-foundation-standard handoff makes.

Five revisions, one compatibility promise, one big exception

MCP's own versioning policy is deliberately conservative: the protocol version is a date string, and it only advances when a change breaks backward compatibility. Judged against that rule, MCP has been unusually busy.

Revision	Shipped	What it actually changed
2024-11-05	Nov 2024	Original release — JSON-RPC 2.0 base, tools/resources/prompts, stdio and HTTP+SSE transports
2025-03-26	Mar 2025	OAuth 2.1 authorization framework, Streamable HTTP transport (replacing HTTP+SSE), JSON-RPC batching, tool annotations
2025-06-18	Jun 2025	Batching removed again, structured tool output, servers reclassified as OAuth resource servers, elicitation, mandatory MCP-Protocol-Version header
2025-11-25	Nov 2025	OpenID Connect discovery, tool-calling inside sampling, experimental Tasks, formalized governance and working groups
2026-07-28 (release candidate)	Locked May 21, 2026; final Jul 28, 2026	Protocol goes stateless — the session ID header and the initialize/initialized handshake are both removed

Two things in that table are worth pausing on. First, JSON-RPC batching was added in March 2025 and taken back out three months later — the spec has reversed itself, not just extended itself, which is the honest sign of a standard still finding its final shape rather than one converging smoothly. Second, the upcoming release is not incremental the way the others were. Making the protocol stateless means any request can land on any server instance behind a plain load balancer, which is a real operational win — but it also means the handshake every existing client and server relies on today is being deleted, not deprecated, in the release candidate's own change notes. Roots, Sampling, and Logging move to Deprecated in the same revision, each with a stated replacement, under the twelve-month removal window the foundation's lifecycle policy now guarantees.

The adoption number nobody can actually check

The 10,000-server, 97M-download figures above are real and first-party, and they are also seven months old by the time this is published, sourced to a single announcement rather than a live count. The protocol's own current introduction page still names Claude, ChatGPT, Visual Studio Code, Cursor, and MCPJam as supporting clients as of this writing, which confirms the breadth held — it does not update the count. The official MCP Registry is built to answer "does this server exist and what does it expose," not "how many servers exist today," and its own interface ships no summary statistic. Any number claiming to describe "the MCP ecosystem right now" is either restating that December 2025 snapshot or coming from a third party running its own crawl with its own definition of what counts as an active server. Neither is a reason to stop citing the real figure — it is a reason to say plainly which moment in time it describes, instead of letting a seven-month-old number read as a live one.

What one production server actually looks like

Reading the ecosystem-level numbers is one thing; running a real server is another, and the two do not have to agree on which spec revision is "current." Scrapeless's own hosted MCP endpoint at https://api.scrapeless.com/mcp still negotiates protocol version 2024-11-05 on today's handshake — the very first revision — while reporting 21 callable tools spanning Google search and trends, direct page scraping, and a full cloud-browser action set built on the same Scraping API surface Scrapeless also exposes over plain REST. That is two tools more than the 19 the server shipped with at its Scrapeless MCP Server launch in mid-2025 — real, if modest, growth in surface area with zero required change on the client side, which is precisely what the protocol's backward-compatible versioning is designed to deliver. It also means the honest answer to "which MCP spec version does this server speak" is never "whatever's current" — it is whatever a live initialize call actually returns, and that number is worth reading off the running instance rather than assumed from a reference post.

That gap between spec churn and server behavior is not a Scrapeless quirk; it is close to the median case in mid-2026. A server built against the original handshake keeps working against clients that speak the same revision, and version negotiation is explicitly built to let both sides agree on one shared version rather than force an upgrade. The place this stops being free is the stateless release: a server or client hard-coded to expect a session ID and an initialize round-trip will not simply keep working once a peer on the other end drops both, which makes 2026-07-28 the first MCP revision in the protocol's life that is worth watching on a calendar rather than shrugging off as routine housekeeping.

Where the integration work actually happens

The clearest evidence that MCP became infrastructure rather than a chat-app feature is not the download count — it is where the same server surface keeps turning up. Scrapeless's own MCP coverage has grown to more than twenty published posts, and the pattern across them is the same server plugged into a different host each time: a LangChain agent binding the tool list directly to a chat model, a Databricks Mosaic AI agent reaching the same tools through a Unity Catalog connection, an AWS Strands agent loop calling them mid-reasoning, a terminal coding agent adding web access with one config block, and a single-binary Rust agent runtime wiring in the identical tool set through a four-line TOML block. None of those integrations rewrote the server. Each one is the same 21 tools, discovered the same way, bound into a different framework's own tool-calling convention — which is the entire pitch of a protocol over a pile of bespoke SDKs, working as advertised rather than as a slide.

That breadth is also why the mechanics of the protocol and the choice between a tool call and a REST endpoint are worth reading separately from this piece rather than re-argued here: this is a market-level view of where the protocol stands, not a repeat of how the handshake works or which contract fits a scheduled pipeline versus an autonomous agent. Five use cases already documented — creator research, review sentiment, local lead generation, cross-marketplace pricing, and profile discovery — all reduce to the same discover-then-extract prompt against the same tool list, which is the ecosystem's real center of gravity: one server, read once, reused everywhere an MCP client shows up.

What the growth numbers don't show

None of the above is a reason to treat MCP as a solved, static thing. A few honest limits belong in the same picture as the growth:

• More connected servers is not automatically better. Scrapeless's own ranking of the field flags that an agent's tool-selection accuracy degrades once it holds somewhere past five to seven connected servers at once — the fix is picking servers by workflow fit, not by how many a registry search turns up.
• Governance now moves slower than code. A conformance suite and a twelve-month deprecation window are what a real standard requires, and they are also friction a single company shipping its own changelog never had to clear.
• "Current spec" is not one fixed thing. With five live-in-the-wild revisions and a sixth about to finalize, the only reliable answer to "what version does this integration speak" is reading the initialize response of the actual running client and server, not assuming either one tracks the newest dated revision.

Conclusion

MCP's first year was a single company proving a protocol could work. Its second has been a foundation, backed by that company's own competitors, proving the protocol can survive changing hands, changing its wire format five times, and still leaving most running integrations untouched. The stateless release due at the end of July 2026 is the first revision in that run worth calendaring rather than skimming, precisely because it breaks the one thing every prior revision preserved. Everything else — the server count, the client list, the twenty-plus ways one MCP server has already been wired into agent frameworks, terminal tools, and data platforms — is less a headline number than a protocol quietly becoming the plumbing nobody has to think about, until the day the plumbing changes shape.

Ready to Put MCP to Work?

Join our community to see how other developers are wiring MCP-connected agents into production: Discord · Telegram.

Sign up at app.scrapeless.com for free MCP runtime, connect the hosted endpoint to the client you already run, and read the current tool list straight off the live handshake before you build on it. Full setup details are in the Scrapeless documentation, and plan pricing is on the pricing page.

FAQ

Q: Did Anthropic give up control of MCP?

Yes, in the sense that governs how the spec changes. In December 2025, Anthropic transferred MCP to the Agentic AI Foundation, a Linux Foundation directed fund it co-founded with Block and OpenAI, backed by Google, Microsoft, AWS, Cloudflare, and Bloomberg. Anthropic remains a founding member and still ships its own MCP clients and servers, but the protocol's specification now moves through the foundation's working groups and conformance process rather than Anthropic alone.

Q: Will my existing MCP integration break?

Not from anything shipped so far — every revision through 2025-11-25 has been backward compatible by design, and clients and servers negotiate a shared version at connect time. The 2026-07-28 release candidate is the exception: it removes the session-ID header and the initialize/initialized handshake outright, so an integration hard-coded to expect either one will need an update once that revision finalizes, not before.

Q: How many tools does the Scrapeless MCP server expose right now?

A live tools/list call against https://api.scrapeless.com/mcp returns 21 tools today — two search tools, three stateless scraping tools, and sixteen browser-automation tools — up from 19 at the server's mid-2025 launch. Read the count off the running endpoint rather than any single reference post, since the number has changed before.

Q: Is there an official count of how many MCP servers exist?

Not a live one. Anthropic's December 2025 donation announcement cited more than 10,000 active public servers, but that is a dated snapshot from one announcement, not a running total. The official MCP Registry is built for discovering and verifying a specific server, and its own interface does not publish a summary count.

Q: Should an agent connect to every MCP server it can find?

No. Tool-selection accuracy drops once an agent holds too many connected servers at once — practitioner guidance generally puts the useful ceiling somewhere around five to seven. Pick servers by which workflow they uniquely unblock, not by how many a registry search returns.