MCP Went Stateless: What the July 2026 Spec Changes for Agent Work

MCP just made its biggest break since remote servers launched. The July 28 spec drops sessions entirely, so any request can land on any server behind a plain load balancer. Here is what changed, what it costs to adopt, and what we are doing about it in our own fleet.

I run agents for a living, and MCP is the layer most of my work sits on. When the spec moves, my deploys move with it. The 2026-07-28 specification, published July 28, 2026 by lead maintainers David Soria Parra and Den Delimarsky, is the one I have been waiting for. It turns MCP from a stateful protocol into a stateless request and response protocol. That sounds like plumbing. In practice it decides whether your MCP servers scale like normal web services or need babysitting like chat connections.

The scale behind this is worth stating. Across the Tier 1 SDKs the project reports close to half a billion downloads a month, with TypeScript and Python each past one billion total downloads. MCP already became the default substrate for agentic workflows. This release is the maintainers doing the hard breaking work instead of papering over gaps, with a twelve month minimum deprecation window so teams can plan.

No more handshake or sessions

The headline is simple. The initialize and initialized exchange is retired, along with the Mcp-Session-Id header. Every request now travels on its own, carrying protocol version, client identity, and client capabilities in _meta. If a client wants to learn server capabilities up front, there is a new optional server/discover call. It is not required.

The payoff is operational. Any request can land on any instance behind a plain round robin load balancer with no shared storage. If you have ever run sticky sessions, held open streams, message replay, and extra routing just to keep an MCP server well behaved, you know exactly what this removes. A remote MCP server is now a normal HTTP workload.

One clarification the spec calls out directly. Dropping protocol level sessions does not force your application to be stateless. If your server needs state across calls, mint an explicit handle from a tool and have the model pass it back as an argument. The model can see the handle and thread it between tools, which works better than session state hidden in the transport.

Method and tool names move into headers

Streamable HTTP requests must now include Mcp-Method and Mcp-Name. Your gateway, rate limiter, or WAF can route and meter on those headers instead of parsing JSON bodies.

This is the change I feel most in our own setup. Our gateway already routes on paths and tokens. Header based routing means auth and rate limits happen before the body is even read. For teams running fleets across hosts, that is fewer moving parts and cleaner logs. The broader point from the Cloudflare writeup of the same release is the same. MCP servers can now run in just a Worker, with no stateful infrastructure behind them, which cuts cost and failure modes at once.

Multi round trip requests replace held open streams

Some tool calls need something mid call, like a confirmation or a missing parameter. The old answer was server initiated requests over a held open stream. The new answer is Multi Round Trip Requests, called MRTR. The server returns resultType: input_required with the questions it needs answered, and the client retries the original call with answers attached in inputResponses.

This covers the three cases that used to need streams: elicitation, sampling with createMessage, and roots/list. Approvals are the one I care about. A tool that needs a human yes before spending money or touching production can now ask, get the answer, and continue, all over stateless HTTP. No stream to babysit.

List results are cacheable

Responses from tools/list, prompts/list, resources/list, and resources/read now carry ttlMs and cacheScope. Clients can cache tool catalogs instead of refetching them, and deterministic ordering keeps upstream prompt caches stable across reconnects.

This fixes a quiet tax. Every reconnect used to refetch the full catalog, which churned tokens and broke prompt caching. With cache hints, the catalog settles down. The roadmap goes further and talks about ETags for versioning tool call results, but even this first step trims real spend on busy gateways.

Authorization gets stricter where it hurt most

The maintainers say auth is where implementers spend most integration time, and this release shows it. Authorization servers should return the iss parameter per RFC 9207, and clients must validate it before redeeming a code. That closes an authorization server mix up hole. Clients set application_type during Dynamic Client Registration so authorization servers stop rejecting localhost redirects for desktop and CLI apps. If your CLI OAuth flow ever died on a redirect URI error, that fix is for you.

The direction is clear. Client ID Metadata Documents, called CIMD, become the standard. Dynamic Client Registration still works for backward compatibility but is formally deprecated and will be removed in a future version. Credentials bind to the issuer that minted them, with no reuse across authorization servers. For enterprise teams, Tasks joins MCP Apps and Enterprise Managed Authorization as a formal extension, which is where long running and governed work now lives.

Tasks move to an extension, and old friends get a sunset date

Tasks leave the experimental core and become the io.modelcontextprotocol/tasks extension, with poll based tasks/get and a new tasks/update. Change notifications move to a single subscriptions/listen stream that clients opt into per notification type. AWS contributed Tasks and already ships it in Bedrock AgentCore for reliable long running agents, which tells you where the enterprise demand sits.

Roots, Sampling, and Logging are deprecated. They still work, and they keep working for at least twelve months. New code should not adopt them. The legacy HTTP plus SSE transport is also officially deprecated with a year long offramp. A formal deprecation policy with a twelve month minimum window now backs all of this, so upgrades become planning work instead of fire drills.

All four Tier 1 SDKs speak the new spec today: TypeScript, Python, Go, and C#. Rust supports it in beta. Expect migration cost concentrated in one place. Anything that depended on session identifiers needs rework, though the migration notes fold in early testing feedback that softens the blow.

Why Cloudflare, AWS, and Google are cheering

The vendor quotes on the release all point the same way. Cloudflare says its Agents SDK supports the spec from day zero, so developers can run MCP servers directly in Workers and call tools without transport session overhead. Sentry and Linear adopted on day zero through that path. AWS frames Bedrock AgentCore as standard scalable infrastructure with no session management, plus Tasks for long running work. Google calls it the robust and extensible foundation its customers and its own teams need for the next generation of AI applications. Honeycomb reports nearly 20 percent of monthly interactive queries now come from agents, and this release lets them serve elicitations at enterprise scale. Figma points to its stateless architecture scaling as generated outputs flow into the canvas.

The pattern is consistent. Everyone who hosts MCP at scale wanted the same thing: stateless, cacheable, routable, globally scalable. That is now the spec.

What is next on the roadmap

The roadmap updated August 22, 2026 names five priority areas for the next cycle. Agentic messaging primitives need to compose, so Tasks, subscriptions, and progress notifications share one lifecycle instead of three answers to the server is not done yet. HTTP native transport unification wants one binding, with Streamable HTTP over stdio via HTTP over stdio work so local servers speak the same model. Agent identity gets its own working group, covering proof of possession, workload identity federation, delegated identity, and token exchange coordinated with IETF OAuth work. Primitives get a cleanup pass on the tools/call result shape plus progressive discovery so clients learn tools as they need them. SDK experience moves toward spec derived artifacts and a conformance suite so examples regenerate instead of rotting.

If you are scoping work for the next six to twelve months, those five areas are where maintainer review time goes first. Proposals with a working group behind them move fastest.

What this means for our fleet

Three practical moves fall out of this for the way we run Hermes and OpenClaw gateways. I wrote up the two harnesses in Hermes vs OpenClaw, and both benefit the same way.

First, simplify the serving path. New MCP servers go stateless from day one. No sticky sessions, no shared session store, plain round robin behind the gateway. Header routing handles auth and metering before bodies are parsed. That is the shape our harness, loop, and graph breakdown already argues for: let code own the edges and keep model judgment in the nodes.

Second, use MRTR for approvals. Any tool that spends money, touches production, or reads sensitive stores gets an explicit confirmation step through MRTR instead of an out of band check. The approval becomes part of the call, auditable and retryable, instead of tribal knowledge in a runbook.

Third, cache the catalog and plan the migration. Turn on list caching where the SDK supports it and watch token spend on reconnects drop. Then budget the real migration work: grep for session identifiers, move server state into explicit handles, shift Tasks consumers to the extension, and stop adopting Roots, Sampling, and Logging in new code. The twelve month window is generous, but the SDK break is real and early movers get the simpler topology sooner.

The honest cost is migration, not capability. Nothing here asks for a bigger model. It asks for a cleaner transport, stricter auth, and explicit state. That is the kind of upgrade that pays quietly every day after, in fewer 3am pages and smaller bills. We are making it across our own servers now, and we will run it for clients the same way: stateless first, cached catalogs, MRTR approvals, and Tasks for anything long running.

About the Author

I'm Brian Marvin, an AI-native Fractional CTO with 30 years in technical leadership. At empowered.guru, I help startups build MVPs, shape roadmaps, and make AI-powered technology decisions that scale.