MCP Goes Stateless: What the 2026-07-28 Spec Means for AI Agent Infrastructure

The Model Context Protocol shipped its biggest revision in two years today. The release candidate for the 2026-07-28 spec landed on the official blog, and the headline is surgical: MCP is now stateless at the protocol layer. The initialize handshake is gone. The session is gone. Mcp-Session-Id is deprecated. Every request is now self-contained.

This isn’t a feature addition — it’s an architectural shift. And if you’re running MCP in production, it changes how you think about scaling, deployment, and server governance.

What the Old Model Looked Like

MCP was designed around a stateful session model. When a client connected to an MCP server, the protocol required a ritual handshake:

1. Client sends an initialize request with protocol version, capabilities, and client metadata
2. Server responds with its own capabilities and a protocol version confirmation
3. Both sides maintain a Mcp-Session-Id header on every subsequent request and response

This session carried real weight. It tracked which tools were available, which resources had been exposed, which prompts had been sent. For a single-user desktop agent running one or two MCP servers, this was fine. For a production multi-agent deployment running dozens of servers across a distributed system, it was a liability.

The session created a constraint: a request could only hit the exact server instance that handled the handshake. Load balancers couldn’t route freely. Horizontal scaling meant sticky sessions or session replication. Adding a new server instance behind a router required careful coordination to ensure the session state was available where the request landed.

Here’s what the old flow looked like in practice. When your agent called a GitHub MCP tool to list pull requests, the request carried a header like:

Mcp-Session-Id: $SESSION_FROM_HANDSHAKE
Content-Type: application/json

And before that header meant anything, the client had to complete the bootstrap:

// POST /mcp/streamable
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {},
    "clientInfo": { "name": "agent", "version": "1.0" }
  }
}

The server would respond with its own protocol version and capabilities, and then the session was established. Only after this handshake could any actual tool calls happen. The Mcp-Session-Id in the response header was the key that bound all future requests to this specific server instance.

What Stateless Changes

The 2026-07-28 spec removes the handshake entirely. Every JSON-RPC request over Streamable HTTP is now self-describing — it carries everything the server needs to process it without reference to any shared state. The Mcp-Session-Id header is gone. So is the initialize request that established the session.

The protocol now uses MRTR headers (SEP-2243) — Method and Name headers that replace session affinity with content-based routing. A router can send request A to server pool instance 1 and request B to instance 3, and both process identically because there’s no per-connection state to track. The equivalent request now looks like:

POST /mcp/streamable HTTP/1.1
Host: github-mcp.example.com
Mcp-Method: tools/list
Mcp-Name: github
Authorization: Bearer $OAUTH_TOKEN
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 42,
  "method": "tools/list",
  "params": {}
}

No session ID. No bootstrap. The Mcp-Method and Mcp-Name headers tell the server what operation is being requested, and the OAuth token carries auth context. Any stateless server instance in the pool can process this request.

The official blog frames this as six Specification Enhancement Proposals (SEPs) converging, but the practical implications are concrete:

Horizontal scaling is now a first-class property. A stateless server can run behind any TCP/HTTP load balancer without sticky sessions, session replication, or shared storage. This is the difference between “works in development with one server” and “production-ready at 10,000 requests per minute.” A pool of five GitHub MCP server instances behind an unmodified nginx upstream block now works correctly — each request is independent, no affinity needed.

The authorization model is rewritten. The old session-based authorization assumed a single connection lifecycle. The new spec pairs stateless requests with OAuth 2.1/OIDC, which was hardened in parallel. Each request carries its own auth context — no session means no auth state leakage between requests. The token is validated per-request rather than validated once at session establishment.

Extension negotiation is formal. Servers can now declare their capabilities in a structured way that clients can interrogate without a full protocol handshake. This is the foundation for MCP Server Cards — .well-known URLs that expose server metadata so agents can discover and evaluate tools dynamically. Instead of hardcoding what a server supports, an agent can ask at runtime.

What Actually Breaks

This is a breaking change. The official spec ships July 28, 2026, but the release candidate is live today, and the migration window is 12 months. The items that break immediately for any client or server implementing the RC:

Mcp-Session-Id header — SEP-2567 removes it entirely. Any client or server still reading or writing this header on requests is non-conformant. If you’ve built tooling around session tracking — a debugging proxy that logs session IDs, a metrics collector that groups by session, any middleware that injects session context — that code needs to be rewritten.

The initialize request — This was the protocol’s bootstrap. It’s deprecated in the new spec. Servers that require a client to send initialize before offering tools or resources will break with conforming clients. The capability negotiation that happened during initialize is replaced by the extension negotiation mechanism.

Protocol-level state assumptions — Any server implementation that stores per-connection state (connection counts, session metadata, in-flight request tracking tied to a session ID) is now technically incorrect. Stateless means every request is independent. If your GitHub MCP server tracks “this session has already authenticated and can access repos X, Y, Z” — that logic needs to move into per-request auth validation.

The migration checklist for server authors is substantial:

• Remove all Mcp-Session-Id header handling
• Every JSON-RPC request must be independently processed — no request can depend on state established by a prior request
• Adopt MRTR headers (Mcp-Method, Mcp-Name) for request routing
• Update authentication from session-scoped to per-request OAuth tokens
• Implement extension negotiation for dynamic capability discovery
• Update SDK dependencies to the post-July-28 version

For client integrators, the changes are less disruptive — mostly removing session ID propagation from request wrappers and updating auth token handling. The JSON-RPC request shapes mostly stay the same.

Why This Matters for the Ecosystem

The MCP ecosystem crossed 10,000 registered servers in 2026. What started as Anthropic’s tool-calling protocol for Claude has become the dominant interface layer for AI agents broadly — GitHub, Figma, Brave, Hugging Face, Chroma, and hundreds of other services all ship official MCP servers. The registry hit 9,652 indexed servers as of May 2026, and the trajectory was steeply upward before today’s release.

A protocol with session state doesn’t scale to 10,000 heterogeneous servers across a distributed agent fleet. The session model made sense when MCP was a single-user, single-server pattern. But multi-agent systems — which is where the ecosystem is heading — need horizontal scalability. Consider a production agent pipeline like the kind Aniket runs: a CEO agent, an Architect agent, and a Developer agent all hitting the same GitHub MCP server simultaneously. Under the old model, each agent would need its own session, or they’d share one and hope it doesn’t fragment. Under the new model, every request is independent. Three agents, three stateless requests, any server instance processes them.

The stateless shift is also a prerequisite for MCP Server Cards. The spec proposal calls for .well-known URLs on each server that expose structured metadata — not just tool lists, but capability declarations, rate limits, auth requirements. An agent fleet can discover and evaluate servers dynamically, without hardcoding integration points. This is the difference between “we integrated 10 MCP servers at build time” and “the agent discovers and negotiates with MCP servers at runtime.” For multi-agent systems that need to provision tools on demand, this is a meaningful capability unlock.

The Honest Tradeoffs

Stateless is the right architectural move for scaling, but it moves burden onto the application layer. The old session model carried state that application code didn’t have to manage — the protocol essentially did session management for you. The new model pushes that to clients: every request must include enough context for the server to process it independently. For simple tool-calling workflows where each request is self-contained, this is negligible overhead. For complex multi-step agentic tasks that previously relied on session continuity — a sequence of calls where the server remembered what the client had done in prior calls — the migration requires careful redesign. You may need to pass more context explicitly in each request rather than relying on server-side session state.

There’s also the question of server-side state that does need to exist. Tool execution state, authenticated user context, rate limiting counters — the protocol is stateless, but the application behind it isn’t. The spec doesn’t solve where that state lives or how it’s managed. That’s now the server author’s problem, not the protocol’s. A stateless protocol with a stateful backend is a valid architecture, but it means the developer has to think carefully about where state lives and how it’s consistent across a server pool. Shared Redis? Sticky sessions at the application layer? The spec doesn’t care, but your deployment will.

The Bigger Signal

The MCP spec team shipped the release candidate on July 27, with the final spec landing July 28. This timing isn’t coincidental. The stateless architecture is a prerequisite for enterprise-grade MCP deployments — the kind that run 10,000-server fleets in regulated environments with strict horizontal scaling requirements. The 12-month deprecation window tells you how seriously they take backward compatibility, but the direction is set.

What started as Anthropic’s tool-calling protocol for Claude has become the POSIX of agent tool access — a shared interface that outlasts any single model, vendor, or deployment pattern. The session model was an early design choice that served the initial use case. The stateless rewrite is what happens when a protocol grows up.

If you’re running MCP servers today, the migration window gives you time. But the direction is set, and the ecosystem that ships 10,000 servers is going to move fast. The RC is live. The final spec lands tomorrow. Start planning your migration.