[ Article ]•Agent Systems & APIs•

Aug 28, 2026

•7 min read

MCP Went Stateless: Inside the 2026-07-28 Spec and the Roadmap That Follows It

Most protocol revisions add features. The Model Context Protocol’s 2026-07-28 revision removed one — and it happens to be the one every existing MCP server was built around.

The initialize/initialized handshake is gone. So is Mcp-Session-Id. The protocol core is now stateless: each request is self-contained, carrying its own protocol version, client identity, and capabilities. On August 22, 2026, lead maintainers David Soria Parra and Den Delimarsky published a roadmap covering what lands next.

If you operate an MCP server, this is the migration you cannot skip. Here is what actually changed and what it costs you.

What Happened

MCP’s original transport model was stateful. A client opened a session with initialize, the server issued an Mcp-Session-Id, and every subsequent request carried that ID back. Simple to reason about, and painful to operate.

That session ID forced sticky routing. Requests had to land on the instance that held the session, which meant either a shared session store or a gateway doing deep packet inspection to figure out where a JSON-RPC body should go. Horizontal scaling fought the protocol the whole way.

The 2026-07-28 revision deletes the premise. From the specification, the base protocol is now defined by stateless, self-contained requests with per-request capability negotiation.

A request now looks like this:

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search

{"jsonrpc":"2.0","id":1,"method":"tools/call",
 "params":{"name":"search","arguments":{"q":"otters"},
 "_meta":{"io.modelcontextprotocol/clientInfo":{"name":"my-app","version":"1.0"}}}}

Everything the server needs is in that one request. Any instance behind a plain round-robin load balancer can serve it.

Why It Matters

Three operational properties fall out of the change.

Horizontal scaling becomes ordinary. No shared session store, no sticky sessions, no affinity rules. MCP servers scale like any stateless HTTP service.

Gateways stop parsing bodies. The new Mcp-Method and Mcp-Name headers mean gateways, WAFs, and rate limiters can route and meter on headers instead of inspecting JSON payloads. Per-tool rate limiting becomes a load-balancer config line rather than an application concern.

Cold starts stop being fatal. Serverless and autoscaled deployments no longer need to reconstruct session state that a previous instance owned.

The tradeoff is real: if your server stored application state behind a session ID, that state now has nowhere to attach. The spec’s guidance is to mint an explicit handle from a tool and have the model pass it back as an argument. State becomes part of your domain model instead of a transport side effect — more explicit, and more work if you leaned on sessions.

What Changed, Precisely

Multi Round-Trip Requests

Removing held-open streams breaks server-initiated requests. elicitation/create, sampling/createMessage, and roots/list all depended on the server calling back to the client mid-flight.

Multi Round-Trip Requests (MRTR) replaces the pattern by inverting it. Instead of the server pushing a request down an open stream, it returns a result saying it needs more:

Server responds with resultType: "input_required" describing what it needs.
Client retries the original call, supplying answers in inputResponses.

User confirmations and missing parameters still work. They just cost an extra round trip instead of a persistent connection.

Cacheable List Results

tools/list, prompts/list, resources/list, and resources/read now carry ttlMs and cacheScope metadata, letting clients decide how long to hold results instead of re-fetching on every reconnect. With deterministic ordering, this also stabilizes upstream prompt caches — a direct token-cost win for clients that reconnect often.

Authorization Hardening

The auth changes are the ones to read closely if you run MCP in an enterprise:

RFC 9207 issuer validation. Authorization servers must return the iss parameter and clients must validate it before redeeming an authorization code. This closes an authorization-server mix-up hole.
Issuer-bound client credentials. Credentials no longer travel across issuers.
application_type in registration, which fixes the long-standing rejection of localhost redirects for desktop and CLI clients.
Dynamic Client Registration is formally deprecated in favor of Client ID Metadata Documents (CIMD). DCR still works, but new work should target CIMD.

A Formal Extensions Framework

Optional functionality now lives in named, opt-in extensions requiring explicit support from both sides. Tasks (io.modelcontextprotocol/tasks) moved out of the experimental core into an official extension, gaining poll-based tasks/get, a new tasks/update, and change notifications via an opt-in subscriptions/listen stream. MCP Apps covers inline interactive UI, and Enterprise Managed Authorization covers org-level policy.

A Real Deprecation Window

The spec commits to a twelve-month minimum deprecation window. Roots, Sampling, and Logging are deprecated but functional; the legacy HTTP+SSE transport gets a one-year offramp. You have time — but the clock started July 28.

What Developers Should Do

Audit for session assumptions first. The failure mode is not a compile error; it is a server that works in local single-instance testing and breaks under a load balancer.

# The three things that will bite you
grep -rn "Mcp-Session-Id\|sessionId" ./src
grep -rn "initialize\b\|initialized\b" ./src
grep -rn "elicitation/create\|sampling/createMessage\|roots/list" ./src

Then, in order:

Move session state into explicit handles. A tool returns a handle; the model passes it back. If state cannot be modeled that way, it probably belongs in your own datastore keyed by an authenticated identity, not by a transport session.
Convert server-initiated calls to MRTR. Any code path that interrupts the model for input needs the input_required / inputResponses shape.
Set ttlMs and cacheScope on list endpoints. Cheap to add, immediately useful to clients.
Fix authorization before the transport. Add iss validation and plan the CIMD move now rather than during the DCR sunset.
Upgrade the SDK. TypeScript, Python, Go, and C# are Tier 1; Rust is in beta. Migration involves breaking changes, particularly anywhere you touched session identifiers.

Where the Protocol Goes Next

The August 22 roadmap names five priority areas:

Area	What it covers
Agentic messaging primitives	Maturing Tasks (SEP-2663), server-initiated events via webhooks and channels, subscriptions, progress notifications
HTTP-native transport unification	Extending Streamable HTTP to work over stdio for local servers
Agent identity & enterprise security	DPoP (Demonstrating Proof of Possession), Workload Identity Federation
Improved primitives	Standardized tool result handling, progressive discovery for large tool catalogs
SDK developer experience	Ergonomics and specification conformance

Two of these deserve attention. Progressive discovery targets a problem teams are hitting now — tool catalogs too large to dump into a context window. And DPoP plus Workload Identity Federation signals that agent identity is being treated as infrastructure rather than an application concern, which matters given the agent authorization failures disclosed this month.

Note the direction: server-initiated events are coming back as webhooks and channels, not as resurrected sessions. Push semantics without transport state.

Limitations and Open Questions

The roadmap does not give a date for the next specification release, and several named items — webhooks, channels, DPoP — are in-progress or proposed rather than settled. Treat them as direction, not schedule.

The stateless model also shifts work onto server authors. Sessions were a convenient place to hide state, and removing them exposes how much state a given server actually held. Some servers will find that migration mechanical; the ones that treated the session as an application context will not.

For teams building on Anthropic’s own stack, the computer use, Skills API, and Files API GA release covers the layer that sits above this protocol work.

Conclusion

MCP traded transport convenience for operational sanity. A session ID is easy to implement and expensive to run at scale; self-contained requests invert that. The twelve-month deprecation window means nothing breaks tomorrow — but every server built on the old model now carries a migration it will eventually have to pay for.

Start with the session audit. Everything else follows from what it finds.