---
title: "MCP 2026-07-28: a stateless protocol, MRTR and the deprecation of Roots, Sampling and Logging"
description: "The Model Context Protocol 2026-07-28 revision drops the initialize handshake and the Mcp-Session-Id header: every request now travels on its own and an MCP server sits behind a load balancer like any other HTTP service. It brings MRTR, routing headers, lists with a TTL and three tightenings on authorization. Roots, Sampling and Logging are deprecated with a twelve-month window."
url: "https://www.noze.it/en/insights/mcp-2026-07-28-stateless/"
lang: "en"
alternate: "https://www.noze.it/insights/mcp-2026-07-28-stateless/"
published: "2026-08-04"
author: "noze S.r.l."
keywords: "Open Source, AI, MCP, AI Agents, Protocols, Interoperability, OAuth, Linux Foundation, Standards"
---

# MCP 2026-07-28: a stateless protocol, MRTR and the deprecation of Roots, Sampling and Logging

The Model Context Protocol 2026-07-28 revision drops the initialize handshake and the Mcp-Session-Id header: every request now travels on its own and an MCP server sits behind a load balancer like any other HTTP service. It brings MRTR, routing headers, lists with a TTL and three tightenings on authorization. Roots, Sampling and Logging are deprecated with a twelve-month window.

4 August 2026

![Four figures on the Model Context Protocol 2026-07-28 revision: the revision is the first since 2025-11-25 and removes the initialize handshake and the Mcp-Session-Id header, so every request carries its own version, capabilities and identity inside \_meta; three deprecated primitives, Roots, Sampling and Logging, still functional but not to be adopted by new implementations, with Sampling moving the cost of inference onto the server; a minimum twelve-month window before removal, with a three-state feature lifecycle policy and a public registry of deprecated features; four Tier 1 SDKs aligned, TypeScript, Python, Go and C#, with Rust in beta and half a billion downloads a month stated by the project. A note at the bottom says that for anyone running a server in production means a migration, because a gateway routing on Mcp-Session-Id has to be rewritten on the Mcp-Method and Mcp-Name headers](https://www.noze.it/images/insights/mcp-2026-07-28-en.svg)

The state of the revision as of 4 August. Sources at the end.

On 28 July the Model Context Protocol published revision **2026-07-28**, the first since 2025-11-25 and the first with the project under the Linux Foundation’s Agentic AI Foundation. One change gives the release its headline: the protocol becomes stateless.

For anyone running an MCP server in production the revision means a migration, not a version bump.

## What stateless means in practice

Two long-standing things disappear. The `initialize` handshake with its `notifications/initialized` notification, and the `Mcp-Session-Id` header of the Streamable HTTP transport.

In their place every request now carries what it needs inside `_meta`: the protocol version, the client capabilities and the identity of the caller. Servers declare their own identity in the `_meta` of every result, and an incompatible version comes back as `UnsupportedProtocolVersionError`. That is [SEP-2575](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2575), alongside [SEP-2567](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2567) which removes sessions from the transport.

Servers that need to remember something between calls now do it with server-minted handles passed as ordinary tool arguments. State does not go away, it changes place: from implicit in the transport to explicit in the function signature.

The operational consequence is the one the project names as the most requested feature from developers: any request can land on any instance, so an MCP server sits behind a round-robin load balancer like any other HTTP service, with no sticky sessions and no affinity.

`server/discover` arrives, and servers **must** implement it to advertise supported versions, capabilities and identity. A client may call it before anything else to pick a version, or use it as a compatibility probe over stdio.

Streamable HTTP POST requests must carry the `Mcp-Method` and `Mcp-Name` headers ([SEP-2243](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2243)). Gateways use them to route and meter without opening the JSON body, which is the difference between a proxy that reads a header and one that deserialises every call.

Results from `tools/list`, `prompts/list`, `resources/list`, `resources/read` and `resources/templates/list` must carry `ttlMs` and `cacheScope` ([SEP-2549](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2549)). The first says how long the data stays fresh, the second whether a shared intermediary may cache it. The recommendation to return tools in a deterministic order points the same way, since it is what makes prompt caches work on the model side.

The resource-not-found error code changes too, from `-32002` to `-32602`, the value JSON-RPC uses for invalid parameters.

## MRTR, when it is the server that needs something

Until now, when a server needed something from the client (directories through `roots/list`, an inference through `sampling/createMessage`, a value from the user through `elicitation/create`) it opened a request in the opposite direction, and that required a persistent stream.

The new pattern is called Multi Round-Trip Requests ([SEP-2322](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2322)) and it reverses the direction. The server returns an `InputRequiredResult` with `resultType: "input_required"`, and puts what it is missing in the `inputRequests` field. The client reissues the same request with `inputResponses` attached. No open channel, just a question travelling back inside an answer.

Hence the consequence that touches every result: each one now carries a required `resultType` field, either `"complete"` or `"input_required"`. Clients must treat results from earlier-protocol servers that omit the field as complete, which is how the revision stays backward compatible.

## Roots, Sampling and Logging deprecated

Three features move to the deprecated state with [SEP-2577](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2577). They remain fully functional for the whole window, but new implementations should not adopt them. The migrations the project suggests:

| Deprecated | In its place                                                                           |
| ---------- | -------------------------------------------------------------------------------------- |
| Roots      | directories and files passed as tool parameters, resource URIs or server configuration |
| Sampling   | integrating directly with the LLM provider APIs                                        |
| Logging    | writing to `stderr` over stdio, or OpenTelemetry                                       |

The heaviest line is Sampling, and it is the least visible in the changelog. It was the primitive through which a server asked the client to run an inference with the model the client had already configured: an MCP server could use an LLM without holding a key, without a contract with a provider and without paying for tokens. Removing it moves that responsibility, and that cost, onto whoever builds the server.

Also deprecated is Dynamic Client Registration from [RFC 7591](https://datatracker.ietf.org/doc/html/rfc7591) as a registration mechanism, in favour of Client ID Metadata Documents. It stays available for compatibility with authorization servers that do not support CIMD.

## Three tightenings on authorization

They are classed as minor changes in the changelog, and rather less minor for anyone exposing an MCP server on the internet.

The authorization server should include the `iss` parameter in authorization responses, per [RFC 9207](https://datatracker.ietf.org/doc/html/rfc9207), and the client **must** validate it against the recorded issuer before redeeming the authorization code ([SEP-2468](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2468)).

Clients must specify an appropriate `application_type` during dynamic registration, to avoid OpenID Connect redirect URI conflicts ([SEP-837](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/837)).

Credentials are bound to the authorization server that issued them: they must be keyed by issuer identifier, must not be reused with a different authorization server, and re-registration is required when the authorization server changes ([SEP-2352](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2352)).

## What gets lost along the way

Stream resumability disappears: the `Last-Event-ID` header and SSE event IDs are gone. A broken stream loses the in-flight request, and the client must reissue it from scratch with a new ID. On long calls, and on mobile networks, that is paid for in repeated work.

The HTTP GET endpoint and the `resources/subscribe` and `resources/unsubscribe` pair give way to `subscriptions/listen`, a single POST-response stream the client opts into by declaring which notifications it wants.

`ping`, `logging/setLevel` and `notifications/roots/list_changed` are removed. Log level is now set per request through `io.modelcontextprotocol/logLevel` inside `_meta`, and servers must not emit `notifications/message` for requests that did not include the field.

Tasks leave the core and become the official `io.modelcontextprotocol/tasks` extension ([SEP-2663](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2663)). The blocking `tasks/result` gives way to polling through `tasks/get`, `tasks/update` arrives for client-to-server input, and `tasks/list` is removed.

The HTTP+SSE transport, deprecated since 2025-03-26, is reclassified as deprecated under the new policy.

## A deprecation policy, not just a release

Along with the revision the project adopted a feature lifecycle policy ([SEP-2596](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2596)): three declared states (Active, Deprecated, Removed), a minimum **twelve-month** window before a deprecated feature can be removed and a public registry tracking everything currently deprecated. In parallel the SEP process becomes markdown files in a `seps/` directory, with numbering derived from the pull request and explicit sponsor responsibilities ([SEP-1850](https://github.com/modelcontextprotocol/specification/pull/1850)).

For anyone fitting MCP into a two-year plan this is the part with the longest reach. Knowing that a deprecated feature stands for at least twelve months, and that the list of what is deprecated lives in a public registry rather than in a thread, changes the kind of decision you can make.

On adoption, the announcement post states that the four Tier 1 SDKs (TypeScript, Python, Go, C#) already support the revision, that the Rust one supports it in beta, and that the Tier 1 SDKs together approach half a billion downloads a month, with TypeScript and Python each past a billion downloads in total. Those are the project’s own figures, with no third-party verification.

## What changes for a server already in production

If a gateway routes or meters on `Mcp-Session-Id`, that logic has to be rewritten on the `Mcp-Method` and `Mcp-Name` headers. If the server expects `initialize` as the first message, updated clients no longer send it. If state lived in the session, it moves into explicit handles passed as arguments. If the server uses Sampling, it needs a plan for direct integration with a provider, with the key and the cost that follow. If anything relied on resuming interrupted streams, it has to be handled with retries.

The previous revision is not switched off, and the changelog explicitly covers servers on older versions: `server/discover` doubles as a compatibility probe and results without `resultType` are read as complete.

## What we think

MCP was born in late [November 2024](https://www.noze.it/en/insights/mcp-model-context-protocol/) as a stateful bidirectional protocol, designed for an agent talking to a server on the same machine. Revision 2026-07-28 turns it into a request/response protocol that sits behind a balancer, with routing headers, declared caches and credentials bound to an issuer. It is the path a piece of software takes when it stops running on a laptop and starts running in production on someone else’s behalf.

The price is stated and it is payable: a real migration, resumability gone and three primitives from the original design leaving the stage. The twelve-month window is what makes deprecating Sampling something for a backlog rather than an emergency.

What remains is the point that holds for every open protocol at this stage, [A2A](https://www.noze.it/en/insights/a2a-agent-to-agent/) included: the hard part sits around the specification more than in it. Declared governance, deprecation windows, public registries. It is the same question that runs through [agent governance](https://www.noze.it/en/insights/open-intelligence-secure-governance-agentic/), and the one that decides whether a project can be adopted by a company that has to answer for what it puts into production.

## Sources

- [The 2026-07-28 revision announcement on the MCP blog](https://blog.modelcontextprotocol.io/posts/2026-07-28/)
- [Full changelog for the 2026-07-28 revision](https://modelcontextprotocol.io/specification/2026-07-28/changelog)
- [Feature lifecycle and deprecation policy](https://modelcontextprotocol.io/community/feature-lifecycle)
- [Registry of deprecated features](https://modelcontextprotocol.io/specification/2026-07-28/deprecated)
- [MCP joins the Agentic AI Foundation, 9 December 2025](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/)
- [Linux Foundation: formation of the Agentic AI Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation)
