New MCP Spec Ships: Connectors No Longer Need to Maintain Session State, Claude's Directory Passes 950 Servers

What does "Stateless Core" specifically change, and how does it relate to a problem developers previously had to deal with?

Under the old spec, MCP was a bidirectional, stateful design, meaning servers had to continuously track the state of each connection (what step this connection is currently at, what context was left over from the previous interaction). This design was relatively natural for traditional server architectures that maintain long-lived connections, but it also meant servers couldn't easily deploy on "spin up and tear down" serverless environments — because serverless instances are short-lived and can't hold state over the long term.

The new spec changes the protocol to a request/response model, where each interaction is an independent request that doesn't depend on the state of a previous connection. This means servers no longer need to run continuously just to maintain state, and can deploy directly on serverless or edge computing infrastructure, scaling elastically with traffic. For developers, this removes the burden of having to design a state-management scheme themselves, directly lowering the technical bar for building and maintaining an MCP Server.

Why is this update described as "one of the most significant spec releases to date," and what's that claim based on?

That assessment is backed by concrete numbers: MCP's monthly SDK downloads have surpassed 400 million, a 4x increase this year, meaning MCP is no longer an experimental, niche protocol but a widely adopted infrastructure standard underpinning production environments. Once a protocol's adoption reaches this scale, early design choices made for the sake of rapid iteration (like stateful connections) start to reveal their limitations at scale — which is why, at this stage of a protocol's evolution, you tend to see a major, rebuild-from-the-ground-up change rather than incremental patching.

This update also folding production-standard authentication like OAuth 2.0/OIDC directly into the protocol reflects the same context: early in a protocol's design, the authentication mechanism may not have faced much real enterprise-scenario stress testing, but with millions of users and 950 servers now in the picture, the ability to connect to an enterprise's existing identity systems (Entra, Okta) shifts from being a nice-to-have to a necessary requirement.

What does folding MCP Apps and Tasks into a "standardized extension framework" actually mean, and how is that different from being usable before?

MCP Apps (letting connectors render interactive UI directly in the conversation, so users don't have to switch tabs) and Tasks (tracking long-running work) already existed before this spec update, but previously, adding these advanced capabilities to the protocol meant "stacking" them on top of the core with no formal, versioned specification to follow — different developers could implement them in inconsistent ways.

The new spec folds both into a "versioned extension framework," meaning they now have a clearly defined spec version and formal compatibility guarantees, and developers can implement them according to this framework's definitions instead of figuring it out independently. The practical significance of this shift: these advanced capabilities move from being "a capability different developers experiment with on their own" to "a standard feature with a shared language across the protocol ecosystem." For developers looking to wire together multiple MCP servers and ensure consistent behavior across them, this lowers the risk of stepping on landmines during integration.

If my organization is considering turning an internal system into an MCP connector wired into Claude, how should this spec update factor into evaluation priority?

If the focus is "should we start this project," the Stateless Core design this update provides means lower build and maintenance costs than before — especially if the organization's concern was the operational complexity of connection-state management, this new spec offers a direct technical fix for that. Enterprise-managed auth, letting an organization provision access all at once through an existing identity provider instead of configuring each user individually, also lowers the friction of rolling this out internally.

If the focus is "should we upgrade our existing MCP Server to the new spec," a more practical approach is to first confirm your current server's usage scale and pain points. If the current pain point is exactly connection-state management or identity-integration complexity, the return on upgrading is fairly direct. If your current server is small in scale, stable, and has no immediate need for scaling or enterprise identity integration, it's reasonable to place the upgrade lower in priority and first watch how other early adopters' implementations play out — this is, after all, a major change spanning the protocol's core design and requires some migration work.