Standards rarely make the news, and that is usually a good sign — the ones that matter tend to disappear into the plumbing. The Model Context Protocol is doing exactly that, only faster than almost anything before it. MCP has now reached roughly 97 million monthly SDK downloads with more than 5,800 servers, hitting in about 16 months a scale that took the React front-end framework roughly three years. If you run a small team that is starting to wire AI agents into your own systems, this is the layer you will be building on — whether you ever read its spec or not.
What MCP Actually Is
In plain terms, MCP is a common way for an AI assistant to talk to your tools and data. Before it existed, every integration was bespoke: connect a chatbot to your invoicing system, your calendar, your document store, and each one was a separate, brittle piece of glue. MCP standardises that handshake, so a tool you expose once can be used by any compatible assistant.
The comparison doing the rounds is the “USB-C of AI tools”, and it is a fair one. You no longer need a different cable for every device; you build to one connector and it works across the ecosystem. That ecosystem is now large and, crucially, vendor-neutral. Support is built directly into Claude Desktop, Cursor, GitHub Copilot and Windsurf, while OpenAI and Google have both committed to supporting it. It is maintained as an open standard under the Linux Foundation, which matters if you are wary of betting on a single supplier.
97Mmonthly SDK downloads — a scale reached in roughly 16 months, against the three years it took React.
What the Next Release Changes
The headline is the release candidate for the next specification, with the final version due to be published on 28 July 2026, succeeding the current spec dated November 2025. The changes are not cosmetic. The most consequential is a move to a stateless protocol core, alongside a clutch of additions aimed squarely at production use:
- Stateless core. The protocol no longer assumes a long-lived session is held open between client and server, which makes servers simpler to scale and more resilient.
- Extensions framework. A formal way to add capabilities without forking the standard or breaking compatibility.
- Tasks. First-class support for longer-running work, rather than only quick request-and-response calls.
- MCP Apps. A route to richer, application-style integrations on top of the protocol.
- Authorisation hardening. Tighter, clearer rules for how access is granted and verified.
- A formal deprecation policy. Old features now get retired predictably, so you are not surprised by sudden breakage.
For a leader scoping this work, the 2026 roadmap frames the direction as deliberately enterprise-ready, and CData’s read of the year ahead agrees: the protocol is maturing from a clever developer convenience into something you can responsibly build a business process on.
Why Statelessness and Auth Hardening Are the Quiet Wins
The two changes worth dwelling on are the ones that sound the most technical. A stateless core means each request carries what it needs, rather than relying on a fragile open connection. In practice, that makes deployments cheaper to host, easier to recover when something falls over, and far simpler to put behind ordinary web infrastructure. For a small team without a dedicated platform engineer, that is the difference between an integration that survives a server restart and one that does not.
Authorisation hardening is the other half of the trust equation. As soon as an agent can act on your systems — read a client file, raise an invoice, update a record — the question stops being “is this clever?” and becomes “who is allowed to do this, and how do I prove it?”. Clearer, formalised authorisation rules are precisely what a professional-services firm needs before letting an assistant near sensitive client data. Pair that with a formal deprecation policy and you get something rare in this space: a moving target you can actually plan around.
The Practical Takeaway
You do not need to adopt the release candidate the day it lands. The sensible move for a small team is to treat MCP as the default integration layer for any new AI tooling you commission, and to ask suppliers a single blunt question: does this speak MCP? If it does, you are buying into an open, broadly supported standard rather than a proprietary dead end. Hold off on building bespoke connectors you would only have to rip out later, note the 28 July 2026 specification date as the point at which the stateless core becomes the baseline, and scope any agent-meets-client-data work around the new authorisation model from the start. The plumbing is settling. Build on the standard, not around it.
