Stateless MCP [What the New Spec Really Changes]

Stateless MCP is the version of the Model Context Protocol — the interface an AI agent uses to reach outside tools — that removes the protocol's session-tracking core, so a server no longer has to remember which client it was talking to between one request and the next. The specification carrying that change became final on July 28, 2026.

Before this revision, an MCP server and client opened a session once and leaned on that memory for every call that followed. That worked fine for a single process talking to a single server. It broke down the moment a team tried to run that server behind more than one machine, because every request from a given client had to land back on the exact process holding its session state.

This guide separates what the spec actually changed, why the change happened now, and where the honest limits sit — as of July 23, 2026, the date the shift was first reported in detail.

TL;DR

• The new MCP specification removes the initialize/initialized handshake and the Mcp-Session-Id header — the protocol no longer tracks a session at all.

• Version and capability information now travels in a _meta field on every single request instead of being negotiated once.

• Tasks, previously an experimental core feature, moved out into an official extension; MCP Apps arrived as a new extension for sandboxed, JavaScript-based interfaces.

• Six authorization-focused changes tighten MCP's alignment with OAuth 2.1, including mandatory Protected Resource Metadata and token-audience binding.

• Roots, Sampling, and native Logging are now deprecated, with a minimum 12-month window before removal.

What Happened, and Why the Timing Matters

The regulatory-style process here ran on a public timeline. The release candidate locked on May 21, 2026, giving SDK maintainers and server implementers a window to test against it before anything became final.

Sources: MCP release-candidate announcement; The Register.

As of July 23, 2026, when The Register first detailed the change, the release candidate had already been public for roughly nine weeks, and the final specification was five days away. According to MCP's release-candidate announcement, that gap gave implementers roughly a 10-week validation window between the locked candidate and the final spec — short enough that any server relying on the old session model needed to start testing well before July 28.

The Mechanism, in Plain Language

"Stateless" does not mean MCP forgot how to track anything useful — it means the protocol itself stopped doing the tracking. Per the MCP specification's changelog, every request now carries the client's protocol version and capabilities in a _meta field, and servers identify themselves the same way in every result, rather than negotiating those details once at the start of a connection. That single change is why any server instance can now answer any request from a given client — there is no per-connection memory left for a load balancer to route around.

Application-level state did not disappear; it just became visible instead of hidden in transport plumbing. A server that needs to remember something across calls — a shopping cart, a document being edited, a long-running search — now mints an explicit handle, something like basket_id, and hands it back to the client as an ordinary tool argument. The model passes that handle back on the next call. Nothing about that state lives in a session header anymore.

Two more mechanisms round out the picture. A new server/discover request lets a client ask a server which protocol versions and capabilities it supports before committing to anything. And a single long-lived stream called subscriptions/listen replaces the older HTTP GET connection and resources/subscribe/unsubscribe pair for servers that push change notifications to a client.

One more pattern closes the loop on server-initiated requests. The old protocol let a server interrupt a call to ask the client for something — a file root, a sampled completion, missing input — through requests like roots/list, sampling/createMessage, or elicitation/create. Under the new Multi Round-Trip Requests pattern, a server instead returns an InputRequiredResult, and the client answers on a retry of the same request.

No server-initiated request has to survive in memory waiting for a reply anymore. It is the same underlying idea as the explicit handle: turn something that used to depend on one process remembering a pending question into something any process can pick back up.

Why Now — the Constraint That Broke

Sticky sessions are cheap to ignore at small scale and expensive at large scale. According to The Register, the MCP SDK was being downloaded more than 97 million times a month before this revision locked — a volume where forcing every request from a given client back onto one specific server process stops being a minor inconvenience and starts being an infrastructure constraint.

Scale on the server side told the same story. According to The Register, at least 10,000 MCP servers had already been set up, each one a candidate for the sticky-routing problem the new stateless core removes. A remote MCP server built on the new spec can sit behind a plain round-robin load balancer, because any instance can answer any request — nothing about the client's identity or history has to be pinned to one process.

Sources: The Register; MCP release-candidate announcement.

Who Shipped It, and What Actually Moved

The change did not stop at the transport layer. Tasks — the mechanism for long-running operations that used to sit inside the core protocol — moved into an official extension identified as io.modelcontextprotocol/tasks, with clients now polling tasks/get and sending input through tasks/update instead of blocking on a single result. MCP Apps arrived as a separate, new extension: server-rendered interfaces delivered inside sandboxed iframes, so a tool can hand a user something interactive built in JavaScript instead of only text or a static image.

Source: MCP specification changelog, 2026-07-28.

Authorization changed just as much as transport, even though it gets less of the headline attention. According to WorkOS, MCP servers must now implement OAuth 2.0 Protected Resource Metadata under RFC 9728, so a client can automatically discover which authorization server it should trust for a given server, instead of that trust being configured by hand. According to WorkOS, Resource Indicators under RFC 8707 now bind a token to the specific server it was issued for — as WorkOS puts it, "a token minted for Server A can't be replayed against Server B."

Teams already routing intake or document work through US Tech Automations pipelines can treat a change at this layer as a tool or model swap inside an existing chain, not a rebuild — the orchestration sitting above MCP's transport details doesn't have to know a session header disappeared underneath it.

The Honest Limits

Not everything here is a clean win with no cost. According to the MCP specification's own changelog, Roots, Sampling, and native Logging are now deprecated but remain functional for at least 12 months under a new feature-lifecycle policy — Active, Deprecated, Removed — so nothing breaks immediately, but anything still depending on those three features has a countdown running.

Backward compatibility is not guaranteed between an old client and a new server, or the reverse, once a server actually adopts the stateless core. A client built against the prior session model has no Mcp-Session-Id to send and no handshake to complete; it needs an update, not just a passive tolerance window. The HTTP+SSE transport, already deprecated since an earlier protocol version, moved fully into the Deprecated state alongside this revision, and stream resumability via Last-Event-ID was removed outright — a broken connection now means re-issuing the request with a new ID, not resuming where it left off.

None of this is optional homework for a server that markets itself as "MCP-compatible" going forward. A conformance suite requirement now applies to Standards Track proposals before they can reach Final status, which raises the bar for what "supports the spec" is allowed to mean.

A tiered scoring system for official SDKs sits alongside that requirement, with Tier 1 SDKs expected to ship support for the new spec inside the same validation window implementers had before the final release. That means the timeline for "my SDK supports this" varies by which SDK a given team happens to be standing on.

The error-code renumbering is a small detail with an outsized blast radius. Moving the resource-not-found error from a custom -32002 to the standard JSON-RPC -32602 fixes a real inconsistency, but any client code written to catch the old code specifically now silently stops catching anything, because the error still fires — it just carries a different number. That is the kind of change a migration checklist misses if it only skims the headline "sessions are gone" summary.

Signal vs Speculation

Signal: The final specification, published July 28, 2026, removes protocol-level sessions, moves Tasks into an extension, adds MCP Apps, and tightens authorization around OAuth 2.1 and specific RFCs — a reading that has held steady from the initial coverage as of July 23, 2026 through the final publication date. Deprecated features have a minimum 12-month runway, and these are documented, sourced facts about what the spec text says today.

Our read: the practical work for most small and mid-size teams over the next 12 to 36 months will be auditing which of their existing MCP-connected tools quietly depend on sticky sessions, not rewriting agent logic from scratch. That is an inventory problem before it is an engineering problem, and it is the kind of inventory an orchestration layer like US Tech Automations can run across existing connections before a production workflow ever breaks.

Our read: the Extensions framework, not the stateless core, is probably the more consequential long-term change. Once Tasks and MCP Apps prove the pattern of shipping domain-specific features outside the core spec, expect more capability to move the same direction — which means "MCP-compatible" increasingly needs a follow-up question: compatible with which extensions?

Our read: US Tech Automations sits at exactly one layer in this story — connecting a swapped-in tool or model to the rest of a workflow — and nowhere near the protocol layer this revision actually rewrites. Anyone selling this change as an application-level feature is describing a different product than the one The Register, WorkOS, and MCP's own changelog are describing.

What This Means by Industry

The stateless core and the authorization changes land differently depending on what a team is actually running day to day. Three follow-on pieces work through the practical version of that question:

• What stateless MCP means for small businesses — for owners and small teams running lean automation stacks.

• What stateless MCP means for marketing agencies — for agencies with client-facing reporting and campaign tooling.

• What stateless MCP means for accounting firms — for CAS and tax practices moving client financial data through connected tools.

Key Takeaways

• Stateless MCP removes protocol-level sessions; every request now carries its own version and capability metadata instead of relying on a one-time handshake.

• The specification finalized July 28, 2026, after a release candidate that locked May 21, 2026 and roughly a 10-week validation window.

• Tasks moved from the core spec into an official extension; MCP Apps is a new extension for sandboxed, interactive interfaces.

• Authorization tightened around OAuth 2.1, RFC 9728 Protected Resource Metadata, and RFC 8707 Resource Indicators that bind a token to one server.

• Roots, Sampling, and native Logging are deprecated with a minimum 12-month window — not removed today, but on a clock.

• Backward compatibility between old clients and new stateless servers is not guaranteed; an update is required, not just tolerated.

Frequently Asked Questions

What does "stateless MCP" actually mean?

It means the Model Context Protocol no longer tracks a session at the protocol level. Every request now carries its own version and capability metadata in a _meta field, so any server instance can handle any request without needing memory of prior calls from that client.

Does this break existing MCP servers?

Servers that keep working the old way are not deleted overnight — deprecated features remain functional for a minimum of 12 months. But a server that adopts the new stateless core needs clients built to match it; the old session handshake and header are gone from that path.

What happened to Tasks?

Tasks moved out of the core protocol into an official extension identified as io.modelcontextprotocol/tasks. Clients now poll for status with tasks/get and send input with tasks/update; the older blocking approach to long-running operations no longer sits in the base spec.

What is MCP Apps?

MCP Apps is a new extension that lets a server present a user with an interactive interface built in JavaScript, delivered inside a sandboxed iframe, instead of returning only text or a static image.

How long do deprecated features keep working?

According to MCP's own changelog, deprecated features remain fully functional for at least 12 months under the new feature-lifecycle policy, which moves features through Active, Deprecated, and Removed states rather than dropping them without warning.

Does this change how MCP handles authorization?

Yes. MCP servers must now implement OAuth 2.0 Protected Resource Metadata under RFC 9728, and Resource Indicators under RFC 8707 bind a token to the specific server it was issued for, closing a class of token-replay risk across multi-server deployments.

Is this the biggest change MCP has made?

Anthropic's David Soria Parra, quoted by The Register, called these "the most substantial changes we have made to the specification, probably since adding authorization". Our own read of the release supports the scale, if not the superlative: sessions, Tasks, transport error codes, and the authorization model all changed at once.

The Real Change Is Where State Now Lives

Stateless MCP does not mean an agent's tools forgot how to remember anything. It means the protocol stopped being the thing doing the remembering, pushing that responsibility to explicit handles a server hands back and a model passes along. That is a smaller conceptual shift than the "since adding authorization" framing suggests, and a bigger operational one for anyone running MCP servers behind more than one machine.

See how agentic workflow orchestration handles a protocol-level change like this without forcing a rebuild of the agent logic built on top of it.