The Model Context Protocol just shipped its largest revision ever — and the direction surprised nearly everyone. Instead of adding features, the maintainers removed them: the initialization handshake is gone, session stickiness is abolished, and the protocol returns to the origin point of stateless HTTP.
Some mocked it as a regression to the stone age; others called it the leap that takes MCP from prototype to production. Behind the argument sits a more fundamental question: in production environments, who is an AI agent protocol supposed to optimize for?
A Subtractive Mega-Release
On May 21, 2026, the MCP maintainers froze the release candidate for the 2026-07-28 version and shipped the final specification on July 28. The official wording was unusually blunt: the largest revision since the protocol launched. Its core, in one sentence: MCP is now stateless at the protocol layer.
Three things happened at once:
- The initialization handshake was removed (SEP-2575). Clients used to open with an
initializecall exchanging protocol version and capability lists with the server. Those details no longer get exchanged once per connection — they now travel with every request’s_metafield. - Sessions and the Mcp-Session-Id header were removed (SEP-2567). Servers used to issue a session ID that every subsequent request had to carry, pinning the client to the instance that issued it. Now any request can land on any instance.
- A new
server/discovermethod was added: clients query server capabilities on demand at any time, rather than receiving them once at connection setup.
Before: handshake first, establish a session, then work. Now: every request carries its full context, and whoever receives it can serve it. The removed pieces were precisely what many considered MCP’s defining features. Why amputate yourself?
Why Sessions Had to Go
Understanding the revision means going back to MCP’s original design assumption. Its earliest and best-known form was desktop applications talking to local processes over standard input/output. In that world, persistent connections and handshakes were nearly free — it’s one process, and no request ever wonders which instance should serve it.
But as the ecosystem matured, more and more servers moved to remote, horizontally scaled deployments — and there, sessions became an original sin carrying two heavy taxes.
Tax one: distributed-systems complexity. Once a server issues a Mcp-Session-Id, the client is bound to the issuing instance. To scale horizontally you need session affinity, a shared session store, or a gateway doing deep packet inspection — parsing JSON bodies to route requests. An MCP server that should be an ordinary HTTP service gets saddled with a bespoke distributed-systems apparatus. The team deploying it effectively pays for problems the protocol itself created.
Tax two: capability negotiation kills caching. Because capability lists were exchanged once per connection, list results varied by connection. Cross-session or shared-middleware caching became impossible to reason about — is this tools/list result still valid for the next client? For production systems relying on caches to cut latency and token costs, that is fatal.
The maintainers’ goal was explicit, with six specification enhancement proposals (SEPs) all pointing one direction: make every request standalone. The official framing is a “pay-as-you-go complexity” principle — the core stays lean, and stateful logic appears only when a feature genuinely requires it.
Stateless Protocol, Stateful Application
The immediate objection: plenty of servers genuinely need memory — shopping carts, task state, account sessions. What happens to them?
The answer: the protocol not managing state does not mean applications can’t. When a server needs state across calls, it uses the pattern HTTP has matured for twenty years — explicit handles. A tool generates a basket_id, returns it in the result, and the model passes it back as an ordinary parameter on the next call. Account state, resource URIs, task handles, database identifiers — all travel this road.
The maintainers argue this is stronger than sessions: session state buried in transport metadata is invisible to the model, but a handle inside a tool result can be composed across tools, passed between workflow steps, and reasoned over. Handles are legible to the model; sessions are black boxes — exactly the transparency agent scenarios need.
The cost is equally explicit: handles surface in prompts, transcripts, and logs, so they must be bound to an authenticated principal and validated for permission on every use. A handle is never, by itself, an authorization credential.
The Ripple Effects of Going Stateless
The cut reaches far beyond simpler deployment; the ecosystem’s operating model changes with it:
- Deployment and gateways: remote MCP servers now run like ordinary stateless HTTP services — behind plain round-robin load balancing, three replicas, zero configuration. Rolling deployments no longer break sessions. New
Mcp-MethodandMcp-Namerequest headers let gateways rate-limit and authorize per operation without parsing request bodies — unless a caller ignores transport validation rules, a harmless-looking header cannot hide another call beneath it. - Caching: finally inferable and billable. Affected list and read results must carry
ttlMsandcacheScope(modeled on HTTP Cache-Control), so clients can retain directories for the stated interval instead of re-fetching. The spec also requires servers to return entries in deterministic order — directly serving prompt-cache hit rates, which at scale means lower latency and lower token spend. - Ecosystem layering: a lean core, extensions on their own cadence. Official extensions live in the
io.modelcontextprotocolnamespace, third-party extensions under the author’s reverse domain, each with independent repositories and release cycles. Anyone who has written Kubernetes custom resources will recognize the pattern — features mature outside the core release train. - A deprecation policy that calms the ecosystem: every feature now has a defined lifecycle — active, deprecated, removed — with a minimum 12-month transition from first deprecation marking; only active security risk shortens that, and 90 days is the hard floor. Public registries list upcoming removals. Routine for developers, but for anyone justifying MCP integration to a platform review board, a written deprecation guarantee is worth more than any new feature.
The costs are real too: systems built on the experimental Tasks API must migrate; standalone-request-mode servers move to multi-round-turn request (MRTR) mode; and sampling is the thorniest deprecation — previously, client-mediated sampling meant servers needed no provider credentials and carried no model bill; calling APIs directly makes them credential holders and bill payers. And statelessness delivers routability, not determinism: two replicas receiving identical requests may still respond differently if they run different versions or read different downstream data.
What To Do Now
The candidate is frozen, the final spec is published, the ten-week validation window is open, and beta SDKs for Python, TypeScript, Go, and C# are ready. The migration path is defined: clients probe with server/discover first and fall back to initialize when a server only supports the old protocol. This is a breaking protocol change — but with a negotiable transition path, not a forced ecosystem-wide cutover date.
- Server developers: deploy remote MCP servers as stateless HTTP services — round-robin load balancing, no session stores, gateway policies keyed on the
Mcp-Methodheader. For cross-call state, adopt explicit handles with proper permission validation. - Platform and ops teams: use the new headers for zero-parse rate limiting and authorization; add
ttlMs/cacheScopeto list and read results; audit session dependencies and test rolling deployments during the validation window — not under production traffic. - Architecture decision-makers: read this revision as a maturity signal. The protocol has started being as “boring” as HTTP — which is precisely what makes it enterprise-ready. A written deprecation guarantee, an extension evolution mechanism, and operation on commodity infrastructure are the three phrases every platform review board wants to hear.
So why did MCP “regress” to the ancient HTTP age? The answer is in the direction of evolution. A protocol designed for local processes treats sessions as features; in a remote, horizontally scaled, multi-tenant production world, sessions are a liability. Cutting them is not anchor-carving nostalgia — it is MCP finally growing into what it was always meant to be: as simple as HTTP, as scalable as HTTP.
Two years ago, MCP defined how AI connects to tools. This revision defines how the infrastructure connecting AI to tools should be operated. The first set the ecosystem’s ceiling; the second decides how far the ecosystem can go.
