MCP Streamable HTTP Transport Semantics
New transport design eliminates sessions for simpler HTTP deployment.

MCP Streamable HTTP transport semantics in the 2026-07-28 revision center on a single POST endpoint, per-request SSE streams, and header-mirrored metadata. The revision makes remote deployment simpler by removing the parts of the protocol that tied requests to specific server instances. Understanding those removals is the key to running MCP on ordinary HTTP infrastructure without session stores or sticky routing, while recognizing the cost of losing stream resumability.
What the wire looked like before July 2026, and why it created deployment problems
Before this revision, an initialize exchange could assign a client an Mcp-Session-Id, which every subsequent request had to carry. The later call therefore depended on more than its own contents. It also depended on session context established by an earlier exchange. The MCP 2026-07-28 release candidate says deployments had to use sticky sessions, a shared session store, and deep packet inspection at the gateway. A request carried a session reference rather than everything needed to process it independently.
The original HTTP+SSE transport used two endpoints, including a GET stream whose first event told the client where to POST. Protocol version 2025-03-26 deprecated that design and collapsed Streamable HTTP to one endpoint. However, it retained session assignment, a standalone GET stream, independent server JSON-RPC requests on response streams, and Last-Event-ID resumability through 2025-11-25.
The four things the 2026-07-28 revision removed, and what each removal means at the wire

The first removal is protocol-level sessions. SEP-2567 and SEP-2575 remove the Mcp-Session-Id header, the initialize/initialized handshake, and the HTTP DELETE call used to terminate a session. Protocol version and client capabilities instead travel in _meta on each request, with client information also recommended. A client that needs server capabilities before making other calls can optionally fetch them through server/discover. The request no longer needs a prior handshake to supply its protocol context.
The second removal is the standalone GET stream. A client can no longer keep an SSE channel open to get server-initiated messages outside a request/response pair. Server-initiated notifications now arrive on the SSE stream belonging to an active POST response. Long-lived notifications move to the response stream of a subscriptions/listen request. SSE therefore remains part of the transport, but its scope is an explicit request rather than a separate connection waiting for unrelated traffic.
The third removal is independent server JSON-RPC requests on response streams. Under SEP-2260, server-initiated requests for elicitation or sampling are permitted only while the server is actively processing a client request. SEP-2322 uses Multi Round-Trip Requests for that exchange in place of an open SSE channel. A server that needs client input returns that need as part of the active call instead of issuing an independent request over a persistent channel.
The fourth removal is stream resumability through SSE event IDs and Last-Event-ID. When a response stream breaks, the in-flight request is lost, and the client must reissue it with a new ID. That is a real regression for long-running tool calls over unreliable networks. Cancellation follows the same request-scoped model because closing the SSE response stream is itself the cancellation signal. The core protocol does not send notifications/cancelled over Streamable HTTP in this revision, so cancellation is a consequence of the new stream lifecycle.
What a valid 2026-07-28 POST request looks like, header by header
The release candidate’s before-and-after example replaces the session-bearing exchange with a self-describing tools/call POST. Every POST carries MCP-Protocol-Version with the value 2026-07-28 and Content-Type with the value application/json. Its Accept header must contain application/json, text/event-stream. Both response types are required because the server may choose either a single JSON reply or an SSE stream. The client cannot assume that every successful call will produce the same HTTP response shape.
The operation headers make the call legible without opening its body. Mcp-Method is required on JSON-RPC requests and notifications under SEP-2243. Mcp-Name is required on all Streamable HTTP request POSTs, with notification POSTs exempt from this requirement in this revision. In the release candidate’s tools/call example, these headers appear with MCP-Protocol-Version, while the session header is absent. Together, the headers give an intermediary the metadata it needs to route, rate-limit, and audit the call.
The body contains a single JSON-RPC request or notification, and clients must not send JSON-RPC responses. Protocol version and client capabilities are required in the _meta.io.modelcontextprotocol/* fields on every request. Client information SHOULD also be included, but it is not mandatory. The release candidate’s example places io.modelcontextprotocol/clientInfo in _meta within the tools/call body.
For a quick reply, the server returns Content-Type with the value application/json and a bare JSON-RPC response object. With text/event-stream, the server instead opens a response stream that sends notifications for the request, then the final JSON-RPC response, and then closes. A notification-only POST receives 202 Accepted with no body. Independently of the response choice, the MCP transports specification requires servers to validate the Origin header on all incoming connections to prevent DNS-rebinding attacks. It also recommends binding to localhost for local deployments.
Why headers mirror body fields, and what breaks if they disagree
Consider a request whose Mcp-Method header says tools/list, but whose body has tools/call with a destructive argument. A load balancer reading only the header routes the call to a low-priority pool. The server, however, executes the operation named in the body. The two components have acted on different descriptions of the same request. That disagreement makes the request confusing and crosses a trust boundary.
The protocol therefore says servers must reject requests when the headers and body disagree. Protocol metadata lives in _meta.io.modelcontextprotocol/* body fields, while Streamable HTTP mirrors selected metadata into headers for intermediaries. Method and name headers must also match the operation they describe. With that agreement enforced, a plain load balancer can route on Mcp-Method without deep packet inspection, and gateways can apply their controls without parsing JSON.
How Multi Round-Trip Requests replace the open SSE channel for server-initiated prompts
One server instance could hold an SSE stream open while waiting for elicitation or sampling input. The client’s answer POST could then reach a different instance that had no record of the in-flight call. Without the session infrastructure needed to join those exchanges, the request was lost. Keeping a connection open did not, by itself, make the client’s next HTTP request reach the instance waiting for it.
Multi Round-Trip Requests replace that dependency with context carried in the payload. When input is needed, the server returns an InputRequiredResult whose resultType is "input_required". Its inputRequests contain the questions, and an optional opaque requestState blob encodes the call’s in-progress context. The release candidate illustrates this with a schema asking for a boolean confirm value. The server returns the need for input instead of holding an SSE stream open while the client supplies it.
The client gathers the answers and reissues the original call with inputResponses and the echoed requestState. Any server instance can handle that retry because the payload carries the full context needed to continue. No shared memory or sticky routing is needed to reconnect the answer to the suspended work. Under SEP-2260, the server can make an elicitation or sampling request only while it is processing something the client started.
What statelessness actually buys at the infrastructure layer, and what it costs
A 2026-07-28-compliant remote MCP server can run behind a plain round-robin load balancer without a protocol session store or sticky routing. When routing uses headers, the gateway can get protocol routing metadata without reading request bodies. The same ingress layer can support centralized identity, audit, rate limiting, and RBAC. These are concrete deployment benefits of making the request describe itself rather than making the gateway reconstruct its context.
A tools/list response carries a ttlMs field, allowing clients to cache the tool manifest for the permitted period and skip a later list round-trip. That saving complements, rather than replaces, horizontal scaling. At the broader deployment level, stdio fans out to a process per session, while Streamable HTTP can serve clients through a small replica set behind one ingress. The transport no longer requires that replica set to preserve a protocol session’s attachment to one instance.
Stateless transport does not mean a stateless application. A server that needs state across calls can mint an explicit handle from a tool and have the model pass it back as an argument. The application owns that state and the meaning of the handle. The release candidate argues that this can be more powerful than hidden session state because the model can compose handles across tools and reason about them.
Compared with 2025-11-25, a client has lost the ability to reconnect to an interrupted SSE response through Last-Event-ID. A fresh request replaces continuation of the broken stream. Multi Round-Trip Requests carry interactive context from one exchange to the next, but cannot resume an interrupted SSE delivery. The infrastructure becomes simpler, but the reliability trade-off is real and belongs in any assessment of the revision.
Migrating a server to 2026-07-28: what changes at the wire and what does not
Remove the initialize/initialized handshake handling, session-ID issuance and tracking, and session-termination handling. Remove the standalone GET stream handler and Last-Event-ID resume logic as well. The POST path that is left must handle each request using the protocol metadata in that request.
The next part is request and response validation. Add MCP-Protocol-Version to every response and validate inbound Mcp-Method and Mcp-Name headers under their request and notification rules. Add a check that the headers and body agree, and code to reject the request if they disagree. If the server uses elicitation or sampling, add InputRequiredResult handling to replace the open-stream interaction pattern. Add server/discover support so clients can get capabilities before making calls without bringing back a handshake.
Tool definitions, tool handler logic, resource handlers, and prompt handlers do not change because they are not transport-layer code. The SSE response format for streaming tool calls is structurally the same, although its scope is per-request and resumability is absent. The SDK separation of concerns keeps most migration work concentrated in headers and session removal. Plans must still account for client compatibility because some clients do not support the 2026-07-28 wire. A deployment serving mixed clients must handle the older session-bearing shape in parallel or negotiate gracefully.
These are breaking changes, but the revision also introduces a formal deprecation policy. The release candidate presents that policy as the means for implementations targeting 2026-07-28 to adopt future revisions without rewriting transport or lifecycle code.


