← Back to blog
Glowing mint-green cubes travel independently along parallel light paths through a gateway frame toward a row of identical dark server racks, evoking stateless requests that any server can answer.
MCP·November 15, 2026·12 min read

MCP Went Stateless: What the 2026-07-28 Spec Changes for Servers and Gateways

The 2026-07-28 MCP revision removes sessions, the initialize handshake and server-initiated requests. Here is what replaces them and what servers, clients and gateways need to change.

The 2026-07-28 revision of the Model Context Protocol deletes the session. There is no initialize handshake, no Mcp-Session-Id header, and no server-initiated JSON-RPC request anymore: every request carries its own protocol version and client capabilities, and any server instance can answer it. That one change turns a remote MCP server from a stateful, sticky-routed oddity into an ordinary HTTP service, and it quietly rewrites how sampling, elicitation, notifications and gateways work.

This post walks through what actually changed in the 2026-07-28 changelog, why the old session model was the bottleneck, and what you need to change if you run an MCP server, client or gateway.

Why the session was the problem

From 2025-03-26 through 2025-11-25, the Streamable HTTP transport let a server mint a session ID in its response to initialize. The client then sent Mcp-Session-Id on every later request, terminated the session with an HTTP DELETE, and could open a standalone SSE stream with GET so the server could push messages, including its own JSON-RPC requests such as sampling/createMessage. Streams were resumable: the server tagged SSE events with IDs and a reconnecting client sent Last-Event-ID to replay what it missed.

Each of those features is reasonable on its own. Together they meant the instance that handled initialize owned the conversation. If the server asked the client for an LLM completion halfway through a tool call, the answer had to come back to the process holding that tool call's stack. If a stream dropped, replaying it required an event log that survived the reconnect. Horizontal scaling therefore needed one of two things: sticky load balancing keyed on the session ID, or a shared store (Redis, typically) holding session state, pending server requests and buffered events.

Teams running remote MCP servers on serverless platforms felt this most. A function that lives for one request cannot hold a GET stream open or remember a session between invocations, so the SDKs grew a stateless option that simply switched off the features needing state. The 2026-07-28 revision makes that mode the protocol.

2025-11-25: session-pinned Client Load balancer sticky on session ID Instance A holds session Instance B Instance C initialize handshake per connection Mcp-Session-Id pins every call to A GET stream carries server-sent requests Last-Event-ID replay needs an event log 2026-07-28: every request self-contained Client Load balancer any instance routes on Mcp-Method Instance A Instance B Instance C version and capabilities in every _meta server input via InputRequiredResult requestState echoed back, integrity-protected subscriptions/listen for change events

What a request looks like now

With no handshake, the information initialize used to exchange once now rides on every request. The body's _meta carries io.modelcontextprotocol/protocolVersion and io.modelcontextprotocol/clientCapabilities (both required), plus io.modelcontextprotocol/clientInfo, which clients should send. On Streamable HTTP the important fields are also mirrored into headers so that a load balancer or API gateway can route without parsing JSON:

POST /mcp HTTP/1.1
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: execute_sql
Mcp-Param-Region: us-west1

{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "execute_sql",
    "arguments": { "region": "us-west1", "query": "SELECT 1" },
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientInfo": { "name": "my-agent", "version": "1.4.0" },
      "io.modelcontextprotocol/clientCapabilities": { "elicitation": {} }
    }
  }
}

Three details matter in production.

The body is the source of truth, and mismatches are rejected

Headers exist for intermediaries, but the server executes what is in the body. If Mcp-Method, Mcp-Name or a mirrored parameter disagrees with the body, a server that processes the body must answer 400 Bad Request with JSON-RPC error -32020 (HeaderMismatch). This closes a classic request-smuggling gap where a gateway authorizes or rate-limits on one value and the backend acts on another. The Streamable HTTP binding goes further: intermediaries that enforce policy on mirrored headers should reject requests that declare an older protocol version, because older versions never promised header and body would agree.

Tool authors can promote arguments to headers

A tool's inputSchema can mark a parameter with x-mcp-header, and conforming clients must copy that argument into an Mcp-Param-{Name} header. The example in the spec routes Spanner queries by region without the gateway reading the body. The rules are strict: only string, integer and boolean parameters, only properties reachable through plain properties chains (no items, oneOf or $ref on the way), and names unique case-insensitively. A client must drop a tool whose annotations break these rules from its tools/list view, so it is worth running your schemas through a checker such as the tool schema linter before you ship. Values that are not plain ASCII are sent as =?base64?...?=, and servers must decode them before comparing against the body.

Version negotiation is per request

There is no negotiated version to remember. A server that does not support the requested version returns UnsupportedProtocolVersionError (-32022) with a supported list, and the client retries with one of them. Servers must also implement server/discover, which returns supported versions, capabilities and identity, but clients are free to skip it and just send the call they wanted. The versioning page spells this out.

Server-to-client requests become multi round-trip requests

The deepest change is that servers no longer send JSON-RPC requests at all. In earlier revisions, sampling let a server ask the client's model for a completion and elicitation let it ask the user for input by sending a request back over an open stream, which is exactly what required the same instance to stay attached.

Under the Multi Round-Trip Requests pattern (SEP-2322), a server that needs input finishes the current request with a result whose resultType is "input_required". That InputRequiredResult carries an inputRequests map (elicitation, sampling or roots requests keyed by server-chosen IDs) and an optional opaque requestState string. The client gathers the answers, then sends the original request again with a new JSON-RPC ID, the same params, an inputResponses map and the echoed requestState. Only tools/call, resources/read and prompts/get may return this result.

The first request is over once the interim result is returned. The retry can land on a different instance, which reconstructs everything it needs from the retry itself. That is what makes the design horizontally scalable, and it moves the hard part into requestState.

requestState travels through the client, so the MRTR spec requires servers to treat it as attacker-controlled. If it influences authorization, resource access or business logic, it must be integrity-protected with an HMAC or AEAD and rejected when verification fails. The spec also recommends binding it to the authenticated principal, a short expiry and a digest of the originating method and parameters, and it warns that none of this makes state single-use: one-time operations still need a server-side check.

If you have built webhook signature verification, the shape is familiar:

import { createHmac, timingSafeEqual } from "node:crypto";

type State = { sub: string; exp: number; req: string; step: string };

export function sealState(s: State, key: Buffer): string {
  const body = Buffer.from(JSON.stringify(s)).toString("base64url");
  const mac = createHmac("sha256", key).update(body).digest("base64url");
  return `${body}.${mac}`;
}

export function openState(token: string, key: Buffer, sub: string, req: string): State {
  const [body, mac] = token.split(".");
  const expected = createHmac("sha256", key).update(body ?? "").digest();
  const given = Buffer.from(mac ?? "", "base64url");
  if (given.length !== expected.length || !timingSafeEqual(given, expected)) {
    throw new Error("requestState failed verification");
  }
  const s = JSON.parse(Buffer.from(body, "base64url").toString()) as State;
  if (s.sub !== sub || s.req !== req || s.exp < Date.now()) {
    throw new Error("requestState is for another user, request or has expired");
  }
  return s;
}

Here req would be something like a SHA-256 of the method name and the tool arguments. If the state includes anything the user must not read, use AEAD (AES-GCM, say) instead of a bare HMAC, since base64url is encoding, not encryption.

Notifications get their own request

The standalone GET stream is gone, and so are resources/subscribe and resources/unsubscribe. A client that wants change notifications sends subscriptions/listen with the types it cares about (tool, prompt and resource list changes, plus resource subscriptions). The response is an SSE stream that stays open, starts with an acknowledgement and tags each notification with a subscription ID.

Request-scoped notifications such as progress and log messages stay on the response stream of the request they belong to. There is no resumability: Last-Event-ID is ignored, and a broken stream loses the in-flight request, which the client must re-issue with a new ID. Cancellation on HTTP is simply closing the response stream, so the spec has no use for notifications/cancelled there (stdio keeps it). Servers should send periodic SSE comment lines as keep-alives on long-lived listen streams and set X-Accel-Buffering: no so nginx-style proxies do not hold events back.

The loss of replay is a real trade-off. Long tool calls that previously survived a flaky connection now restart, which pushes long-running work toward the separate Tasks extension (io.modelcontextprotocol/tasks), now polled with tasks/get, and toward making tools safe to retry.

Legacy versus modern at a glance

Concern2025-11-25 and earlier (legacy)2026-07-28 (modern)
Connection setupinitialize and notifications/initialized handshakeNone; version and capabilities in every request's _meta
Session identityMcp-Session-Id header, ended with DELETERemoved; cross-call state uses server-minted handles passed as tool arguments
Server asks client for inputServer sends sampling/createMessage, elicitation/create, roots/list requestsInputRequiredResult plus client retry with inputResponses (MRTR)
Change notificationsStandalone GET SSE stream, resources/subscribesubscriptions/listen request with opt-in types
Stream recoverySSE event IDs and Last-Event-ID replayNone; re-issue the request with a new ID
Log levellogging/setLevelio.modelcontextprotocol/logLevel in each request's _meta
LivenesspingRemoved
Routing metadataMCP-Protocol-Version header onlyRequired Mcp-Method and Mcp-Name, optional Mcp-Param-*
List cachinglistChanged notificationsPlus required ttlMs and cacheScope on list and read results

Two smaller items are worth noticing for agent builders. Servers should now return tools/list in a deterministic order, partly so the tool block in your prompt stays byte-identical and keeps hitting the provider's prompt cache. And the new ttlMs/cacheScope fields let a gateway cache tools/list responses for public catalogs without guessing.

Deprecations hiding in the same release

The revision also marks Roots, Sampling and Logging as Deprecated under a new feature lifecycle policy with a minimum twelve-month window. They still work over MRTR, but the suggested migrations are telling: pass directories as tool parameters instead of Roots, call model provider APIs directly instead of Sampling, and log to stderr or OpenTelemetry instead of protocol logging. On the auth side, OAuth Dynamic Client Registration is deprecated in favor of Client ID Metadata Documents, and clients must validate the iss parameter in authorization responses when one is present. The old HTTP+SSE transport from 2024-11-05, deprecated since 2025-03-26, is now formally on the removal track.

Read together, the direction is clear. MCP's core is narrowing to "client calls server, server answers", and anything that needed the server to reach back into the client is either reshaped into a retry or pushed out to an extension.

Migrating without breaking older peers

Old and new do not interoperate by accident. The spec's compatibility matrix is blunt: a legacy-only client talking to a modern-only server fails, because the server rejects initialize on stdio and rejects the missing headers on HTTP, and legacy clients have no way to move forward. The safe path is to go dual-era first.

The rest of the request path, including how a call is framed and dispatched once it reaches the server, is unchanged from what we covered in MCP tool-call internals.

The takeaway

If you operate a remote MCP server, the 2026-07-28 revision lets you delete your session store, drop sticky routing and scale on plain round-robin, as long as you do three things: serve both eras until your clients catch up, move every server-to-client interaction onto MRTR with an integrity-protected and expiring requestState, and make long tool calls safe to retry, because streams no longer resume. If you run a gateway, start routing and rate-limiting on Mcp-Method and Mcp-Name, but only for requests that declare 2026-07-28 or later, and let the server's header-body check be your backstop.

#mcp#model-context-protocol#streamable-http#stateless-mcp#mcp-gateway#ai-agents
ShareXLinkedInHacker News

Try it

Free, in your browser, no sign-up.

Using an agent? Add the Utilix tools to Claude Code over MCP (other editors):

claude mcp add utilix -- npx -y @utilix-tech/mcp

New posts by email

One email when a new post goes up. No other mail; unsubscribe in one click.

We store your email only to send new posts. See the privacy policy.

Related reading

MCP
MCP Resources: The Primitive Almost No Server Implements
MCP
MCP Elicitation: Form Mode, URL Mode, and the Phishing Attack Built Into Its Design
MCP
MCP Sampling: How a Server Asks the Client's Model to Think for It