MCP Goes Stateless: What Anthropic’s New Protocol Core Changes for Server Builders
The 2026-07-28 spec drops the session handshake and makes every request self-describing. Here is what that means if you run, build or route MCP servers.
MCP has just had its biggest rewrite since it launched. The fifth spec release, MCP 2026-07-28, turns the protocol from a bidirectional, stateful connection into a plain request/response protocol — and Anthropic announced this week that support is rolling out across Claude products, with the connectors directory already listing more than 950 servers. If you have ever fought with sticky sessions, load balancers or a Lambda that forgot who it was talking to, this release is for you.
What actually changed
The old MCP assumed a conversation: the client called initialize, the server answered with its capabilities, both sides agreed on a protocol version, and from then on every message was tied to that session through an Mcp-Session-Id header. That worked fine for a local stdio server. It worked badly for anything behind a round-robin load balancer, on serverless infrastructure, or at the edge, where request two might land on a machine that never saw request one.
- MCP client
- Had to run the initialize/initialized handshake before doing anything else, then quote the session id on every request.
- Load balancer
- Round-robin routing broke sessions: needed sticky routing or shared session storage as a workaround.
- Server A
- holds sid 7f3aThe only instance that knows this session's protocol version, client identity and capabilities.
- Server B
- unknown sessionReceives a request quoting a session id it never issued and cannot answer it.
- Mcp-Session-Id
- retired in 2026-07-28Minted by the server on initialize; the client sent it back on every subsequent request.
- initialize
- The old opening handshake: negotiate protocol version and capabilities before the first real call.
- tools/call + session id
- Meaningless to any instance that did not see the initialize — the reason serverless MCP was painful.
- MCP client
- No handshake. Optionally calls server/discover to look up capabilities, then just sends requests.
- Load balancer
- Plain round-robin. Can route and meter on the Mcp-Method and Mcp-Name headers without parsing the body.
- Instance A
- statelessReads everything it needs from the request itself. Fine on Lambda, Workers or the edge.
- Instance B
- statelessSame code, same answer — no memory of earlier requests required.
- Instance C
- statelessCold-started a second ago and still answers correctly.
- _meta and headers
- Protocol version, client identity and capabilities travel in _meta; Mcp-Method and Mcp-Name ride as HTTP headers.
- Self-describing request
- If a tool needs continuity, it returns a handle the client passes back — state lives in the data, not the transport.
The new core simply removes the conversation. The initialize/initialized handshake and the Mcp-Session-Id header are gone. Instead, every request carries the protocol version, the client identity and the client capabilities inside its _meta field. Any request can land on any server instance, and the server has everything it needs to answer it.
The pieces that make stateless work
- Optional discovery — a client can call server/discover to learn what a server offers, but it does not have to. It is a lookup, not a handshake.
- Routing headers — HTTP requests now carry Mcp-Method and Mcp-Name headers, so gateways, WAFs and metering layers can route on the header instead of parsing the JSON body.
- Explicit handles instead of sessions — if a tool genuinely needs continuity, it returns a handle in its result and the client passes it back as an argument on the next call. State lives in your data, not in the transport.
- Cache hints — tools/list, prompts/list and resources/list responses now include ttlMs and cacheScope, so clients stop re-fetching lists that have not changed.
- One notification stream — the various server-to-client notifications collapse into a single subscriptions/listen stream for clients that want to be told when things change.
But my server needed to ask the user something
This was the obvious objection. Server-initiated requests — elicitation, confirmations, mid-call questions — relied on an open stream back to the client. Stateless kills that stream, so the spec replaces it with Multi Round-Trip Requests, or MRTR. A tool that needs input returns resultType: "input_required" with a description of what it needs; the client answers by retrying the same call with the answers in inputResponses. Two ordinary HTTP requests, no persistent connection, same outcome.
// first call
POST /mcp Mcp-Method: tools/call Mcp-Name: delete_branch
{ "params": { "name": "delete_branch", "arguments": { "branch": "main" } } }
// server: not so fast
{ "resultType": "input_required",
"inputs": [{ "id": "confirm", "prompt": "Delete main? This cannot be undone." }] }
// retry with the answer
{ "params": { "name": "delete_branch",
"arguments": { "branch": "main" },
"inputResponses": { "confirm": true } } }Long-running work follows the same logic. Tasks, previously experimental, graduates to an official extension, io.modelcontextprotocol/tasks, built around polling: start the job, poll tasks/get, and the server can push progress with tasks/update. Nothing has to stay open while the job runs.
Extensions and auth, tightened up
Three official extensions ship alongside the core: MCP Apps for server-rendered UI that renders inline in the client, Tasks for async operations, and Enterprise Managed Auth for provisioning connectors org-wide through an identity provider. Claude already supports MCP Apps and enterprise-managed auth, and recently added observability dashboards for connector developers plus MCP tunnels, a research preview for reaching servers on private networks.
Authorization was hardened at the same time, mostly to line up with what enterprise IdPs like Entra and Okta expect:
- Clients must validate the iss parameter (RFC 9207) before redeeming an authorization code
- Client credentials are bound to the authorization server that issued them — no reuse across servers
- Dynamic Client Registration is deprecated in favour of Client ID Metadata Documents, though DCR keeps working; a new application_type parameter fixes the localhost-redirect rejection that bit desktop clients
What is deprecated, and how long you have
Roots, Sampling and Logging move to deprecated status, as does the legacy HTTP+SSE transport. The spec also introduces a formal deprecation policy: a twelve-month minimum window before anything deprecated is removed, so nothing you run today stops working next quarter. The Tier 1 SDKs — TypeScript, Python, Go and C# — support the new spec now, and the Rust SDK is in beta.
Why this matters
MCP passed 400 million monthly SDK downloads this year, four times where it started the year, and it is now the default way agents reach applications. At that scale the stateful model was the thing holding deployment back: you could not just drop a server on Cloudflare Workers or Lambda and put it behind a normal load balancer without a session-affinity workaround. Now you can. Servers get simpler, gateways get cheaper to run, and the whole thing behaves like the rest of the HTTP world instead of an exception to it.
If you build MCP servers, the practical move is short: upgrade the SDK, delete the session plumbing, return handles where you truly need continuity, and switch any elicitation to MRTR. If you only use them, expect connectors to get faster and flakier-in-fewer-ways as the ecosystem moves over. Full details are in the MCP 2026-07-28 spec announcement and Anthropic’s rollout post.
