MCP Just Dropped Sessions: The Biggest Spec Change Since the Protocol Launched

The Model Context Protocol — the standard that lets AI assistants talk to external tools and data — landed its 2026-07-28 specification, and it is the largest revision since MCP launched. The headline change is architectural: MCP is now stateless at the protocol layer. Sessions are gone, the connection handshake is gone, and every request now stands on its own.

If you have ever deployed an MCP server behind a load balancer, this is the release you have been waiting for.

What actually changed

Area	Before	Now
Sessions	Stateful session held per connection	Removed — every JSON-RPC request is self-contained
Connection setup	Mandatory initialize / initialized handshake	Dropped — identity and capabilities ride in a _meta object on each request
Capability discovery	Negotiated once at handshake time	On demand via a server/discover call
Authorization	Looser	OAuth 2.1 and OpenID Connect alignment with strict issuer validation
Evolution	Ad hoc	Governed extensions framework plus a formal deprecation policy

Why "stateless" is the whole story

The spec's own framing is the clearest: "Any compatible server instance should be able to handle a self-contained request." That single sentence deletes a pile of infrastructure that every production MCP deployment has been carrying.

Under the old model, a session lived on one server process, which forced operators into sticky load-balancer routing, shared Redis session stores, and request-body inspection at the gateway just to send a request back to the machine that remembered it. None of that is needed when the request carries its own context. You can scale MCP servers the way you scale any other stateless HTTP service — add instances, kill instances, deploy mid-conversation.

The tradeoff is real but modest: every request now carries more overhead, since protocol version, identity and capabilities travel with it instead of being agreed once. For most deployments that is a good trade — a slightly fatter request against an entire class of infrastructure that disappears.

Three features are being retired

Removal is not immediate. Under the new policy any deprecated feature stays functional for at least 12 months, with a public registry tracking timelines — these are eligible for removal after July 28, 2027.

Feature	Why it's going	Move to
Roots	Coupled clients and servers to filesystem assumptions that "don't generalise to remote or cloud environments"	—
Sampling	Reversed the trust boundary by having servers call the client's LLM	Direct LLM API integration
Logging	Made redundant by existing tooling	stderr or OpenTelemetry

HTTP+SSE transport and Dynamic Client Registration are also proposed for deprecation. The Sampling removal is the philosophically interesting one — it was the feature that let a server reach back and invoke the client's model, and the spec is explicit that this pointed the trust arrow the wrong way.

Two new extensions ship with it

The extensions framework is not theoretical; two arrive with the release.

MCP Apps lets a server define an interactive HTML interface that renders inside the chat in a sandboxed iframe, communicating back over JSON-RPC. That turns an MCP server from something that returns text into something that can present a real UI — a meaningful expansion of what a tool integration can be.

Tasks standardises long-running asynchronous work with durable task IDs, so a client can poll progress and supply input mid-flight rather than holding a request open. For agent workloads that run for many minutes, this is the piece that was missing.

Who governs MCP now

MCP is administered by the Agentic AI Foundation, a Linux Foundation directed fund. Its platinum membership reportedly includes Anthropic, OpenAI, Google, Microsoft and Block — which is worth pausing on, because those same labs have been conspicuously split elsewhere. OpenAI, Google and Anthropic all sat out the Nvidia-led Open Secure AI Alliance days earlier.

The pattern that emerges: the frontier labs will co-govern the protocol layer — the wiring everyone needs to agree on — while declining to join coalitions that touch how their models are secured or released. Standards are shared infrastructure; safety posture is competitive positioning.