MCP is now stateless: What the latest revision changes
MCP's latest revision drops session-based requests. Here's what changed, what it costs, and how to migrate.
If you've built or deployed an MCP server, you've probably dealt with more than just exposing tools.
Managing sessions, keeping connections alive, routing requests to the right instance, and handling server-to-client communication can add a surprising amount of complexity.
The MCP maintainers recently released MCP 2026-07-28, the largest revision to the protocol since its launch. It addresses many of these challenges by introducing a fundamentally different approach to how MCP servers communicate with clients.
The biggest change is a stateless protocol core. MCP no longer requires an initialization handshake or protocol-level sessions. Each request carries the information needed to process it independently.
This is a breaking protocol revision, so migrating may require more than just upgrading your SDK. With an update like this it's always challenging because both the server and client code need to be updated.
However, the updated SDKs provide support for both the old and new protocol versions, so you can choose not to migrate.
Let's look at what changed and what you'll need to update when migrating your MCP server.
MCP version update at a flance.
Here's a quick glance at what changed between the earlier protocol and the new one.
| Area | Legacy | Latest |
|---|---|---|
| Session Start | initialize + notifications/initialized | Nothing required |
| Protocol session | Optional Mcp-Session-Id | Removed |
| Discovery | Part of initialization | Optional server/discover |
| Routing | Header: MCP-Protocol-Version, Mcp-Session-Id.Body: method, tool name, arguments. Gateway must parse the JSON to route per tool. | Header: MCP-Protocol-Version, Mcp-Method, Mcp-Name (tool or prompt name, or resource URI).Body: the same values plus arguments and _meta. |
| Server needs input from the client | Replica-local bidirectional stream | Replica-independent Multi Round-Trip Requests (MRTR), new in this revision |
| Caching | Up to the client | ttlMs and cacheScope parameter support |
The old model: initialize, then talk
Legacy MCP started with an initialize request.
The client and server agreed on a protocol version and capabilities, then the client sent initialized notification. Over Streamable HTTP, the server needs to hand out an Mcp-Session-Id, which the client sent back on every later request.
That worked well for interactive clients that talk in both directions. But it also meant every message depended on something set up earlier in the connection.
With a single server you'd never notice. Once you scale out, someone has to answer questions like these:
- Which, out of N replicas, owns this session? Sticky sessions need to be implemented.
- What happens when that replica restarts? How is session failover handled?
The new model
Modern MCP puts everything the server needs into the request. The protocol version and client identity travel in _meta:
HTTP Headers
POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Authorization: Bearer ...
HTTP Request Body
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "search",
"arguments": { "query": "checkout timeout" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientInfo": {
"name": "incident-agent",
"version": "1.0.0"
},
"io.modelcontextprotocol/clientCapabilities": {}
}
}
}
Any replica can handle this request, because each request is independent.
Building stateful workflows with the new MCP protocol
A stateless protocol doesn't mean your MCP server has to be stateless. Say a debugging tool needs to keep an investigation going across several calls. The server returns a handle:
{
"investigation_id": "inv_447",
"status": "collecting_evidence"
}
And the agent passes it into the next call:
{
"name": "inspect_deployment",
"arguments": {
"investigation_id": "inv_447",
"deployment_id": "deploy_92"
}
}
This means you need a shared database to track lifecycle context.
This approach has an advantage over the old session model that it can outlive a client restart, and have its own access rules.
Why the new protocol scales better
If all this sounds familiar, it's because this pattern is already followed by application level protocols like HTTP.
HTTP is stateless, but web apps still have accounts, carts, and background jobs. That state belongs to the application layer, not to the transport.
Scaling gets simpler. Plain round-robin routing works. You don't need sticky sessions or shared session memory.
Gateways can see what they're routing. With Mcp-Method and Mcp-Name, a gateway can tell tools/list from tools/call, or read_logs from restart_service, without reading the JSON body. That makes per-tool authorization, rate limits, metering, and audit logs much easier.
Discovery can be cached. Responses from tools/list, prompts/list, resources/list, and resources/read include ttlMs and cacheScope hints. Lists also come back in a fixed order, so LLM prompt caches stay valid when nothing has changed.
Asking for Human Approval via Multi Round-Trip Requests (MRTR)
Sometimes a server is halfway through a tool call and needs a human to approve something.
In legacy MCP, the server sent a request back to the client over a stream it held open.
MRTR drops the stream and instead makes this interaction first-class.
The server stops processing the tool call, returns an InputRequiredResult saying what it needs, and the client retries the call with the answer included:
Migrating a session-based server
- Find your session state. List everything you key on
Mcp-Session-Idor keep in connection memory. - Save your session state in a durable store such as a database.
- Add idempotency keys to every tool that changes state. Tools with side-effects are a major bug source, specially due to frequent retries.
- Switch server-initiated requests to MRTR.
- Add cache hints via ttlMs. For example, a tools/list response might look like:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"resultType": "complete",
"tools": [],
"ttlMs": 60000,
"cacheScope": "public"
}
}
Sources
- Model Context Protocol, 2026-07-28 release announcement
- SEP-2575, Stateless MCP
- SEP-2567, Remove sessions