The MCP protocol has received its largest update since release, removing sessions and initialization handshakes in favor of stateless HTTP. The change aims to simplify remote server deployment but may cause chaos during the coexistence of old and new protocols.
SynthePulse Insight · AI deep reading
Version 1 · 1 source
The biggest update since MCP's release: removing handshake and session, each request carries full context independently. This solves horizontal scaling pain points, but at the cost of externalized state management, migration chaos, and new security challenges.
MCP released the final specification on July 28, 2026, which officials call the biggest update since its release. The core change is removing sessions and initialization handshake; each request must carry full context independently, allowing remote servers to run like traditional stateless HTTP services, using round-robin scheduling without configuring session affinity.
This change stems from the gap between original design and actual deployment: MCP was initially a desktop app communicating via stdio, with low handshake cost; but for remote horizontal scaling, sessions require affinity, shared storage, or MCP-aware gateways, becoming an operational burden. Capability negotiation was exchanged once at connection, making caching difficult to infer.
Maintainers implemented 'pay-as-you-go complexity' through six specification enhancement proposals: protocol version and client capabilities are passed via _meta, and a new server/discover method supports on-demand queries. But developer Román Moskalenko warns that the coexistence phase of old and new protocols will be very chaotic, with potentially higher failure rates.
After statelessness, servers that need to remember information adopt explicit handle patterns, like basket_id for shopping carts: the tool generates a handle included in the result, and the model passes it back as a parameter on the next call. Handles are visible to the model and can be combined across tools, but they appear in prompts and logs, so they must be bound to the authenticated principal and have permissions verified each time; they cannot be treated as authorization credentials.
For caching, list and read results must include ttlMs and cacheScope (referencing HTTP Cache-Control) as freshness hints, not promises. Servers must return entries in a deterministic order to improve prompt cache hit rates, potentially reducing latency or token costs.
Protocol statelessness only guarantees routability, not determinism: different versions or replicas with downstream data may return different responses. Application state (like shopping carts, task records) still requires external storage; the protocol no longer manages state, but state has not disappeared.
Extensions get namespaced identifiers: official extensions are under io.modelcontextprotocol, third parties use reverse domain names, with separate repositories and release cycles. The Tasks feature was released as an experimental core feature on November 25, 2025, but due to design issues, it was redesigned as an extension; moving out of core is a breaking change, but subsequent evolution uses feature flags or versioning to avoid breaking again.
The feature lifecycle policy defines three states: 'active', 'deprecated', and 'removed'. From deprecation, there is at least a 12-month transition period; it can be shortened only if there is an active security risk, but 90 days is the minimum. Public registries list deprecated features, and standard tracking proposals must pass conformance tests to reach 'final' status.
For developers needing to justify integration to platform review committees, written deprecation guarantees are more valuable than any feature.
Systems based on the experimental Tasks API must migrate to the new lifecycle; servers that previously sent requests to clients must switch to a multi-turn request pattern, where the server returns the needed content and the client retries. Servers must verify echoed requestState to prevent authorization impacts; one-time workflows need independent replay tracking.
Deprecations are migration guides, not seamless replacements: client-mediated sampling does not require provider credentials, while directly calling provider APIs makes the server the credential holder and billing party; stderr and OpenTelemetry cannot provide structured log stream alternatives for remote clients.
On security, Mcp-Method and Mcp-Name headers allow gateways to rate-limit or authorize without inspecting the body, but this only holds under transport validation rules; backends reject mismatched headers, and intermediate nodes must ensure protocol version support checks, otherwise headers may mask actual calls.
Maintainers set a ten-week validation period and provide beta SDKs for Python, TypeScript, Go, and C#. The migration path is: clients first probe with server/discover, fall back to initialize when encountering older servers, enabling a negotiable transition rather than forced synchronous switching.
The release candidate window is the best time to sort out session dependencies and test; production deployment can proceed after approval and SDK stabilization. Ultimately, the protocol layer will naturally align with industry-mature operational systems, benefiting everyone from server developers to platform teams and gateway providers.
But statelessness is not free: externalized state management, migration chaos, and new security challenges coexist. Developers must weigh pros and cons and plan migration carefully.
This article is based on InfoQ's translation and compilation of a The New Stack article, making it a secondary source. Key facts (like release dates and protocol changes) come from the original article, but some details (like developer comments) are paraphrased and not first-hand verified.
MCP's biggest update simplifies the protocol through statelessness, solving horizontal scaling pain points, but shifts state management and security responsibilities to developers, and brings migration chaos. Explicit handles and extension mechanisms provide new paradigms, but security and compatibility must be handled carefully.
Primary report
Primary source