MCP 2025-11-25 vs. MCP 2026-07-28

A comparison of the major protocol changes introduced in the MCP 2026-07-28 specification.

The following table compares the earlier MCP protocol (2025-11-25 and earlier) with MCP 2026-07-28, highlighting the architectural changes introduced by the move toward a stateless, request-oriented protocol.

Category	Direction	Old MCP (2025-11-25 and earlier)	MCP 2026-07-28
Handshake	Client ↔ Server	initialize / notifications/initialized; server returns Mcp-Session-Id	Removed — version/capabilities travel per-request in _meta. No pinning to a server instance
Session	both	Mcp-Session-Id header on every request; needs sticky routing	Removed — every request self-contained. Any instance can answer any request
Capability probe	Client → Server	Implicit in initialize	server/discover (optional to call, MUST be implemented). Decoupled from a handshake
Routing	Client → Server	Gateway must parse JSON body	Mcp-Method, Mcp-Name headers. Header-based routing without body parsing
Discovery	Client → Server	tools/list, resources/list, prompts/list — varies per connection	Same calls, plus resources/templates/list; now cacheable (ttlMs, cacheScope). Cacheable since results no longer vary per-connection
Core calls	Client → Server	tools/call, resources/read, prompts/get	Same, but can return InputRequiredResult. Adds the MRTR path
Cross-call state	Client → Server	Implicit via session	Explicit server-minted handle passed back as a tool argument (SEP-2567). State made explicit, not connection-bound
Server-initiated input	Server → Client	sampling/createMessage, elicitation/create, roots/list — server calls back mid-handler	Deprecated (SEP-2577) → MRTR: server returns InputRequiredResult; client re-issues original call with inputResponses + echoed requestState. True server → client calls replaced by client-driven retries
Subscribe	Client → Server	resources/subscribe (per URI) / resources/unsubscribe	subscriptions/listen with a filter (toolsListChanged, promptsListChanged, resourcesListChanged, resourceSubscriptions: [uris]). One call can cover many watch targets; multiple concurrent listen streams allowed
Subscription push	Server → Client	notifications/resources/updated, notifications/*/list_changed over the session's GET/SSE connection	Same notifications, now tagged with io.modelcontextprotocol/subscriptionId in _meta, delivered only on the stream that requested them. Demultiplexed by subscription, not by session
Subscription teardown	Client → Server	resources/unsubscribe	Close the SSE stream (HTTP) / notifications/cancelled referencing listen ID (stdio); no dedicated unsubscribe RPC. Server holds no state across reconnects — must re-listen after any drop
Progress	Server → Client	notifications/progress, keyed by progressToken in request _meta	Unchanged in spirit — still request-scoped. Same mechanism, explicitly not moved to subscriptions/listen
Logging level	Client → Server	logging/setLevel (session-scoped)	io.modelcontextprotocol/logLevel in per-request _meta. Per-request instead of per-session Logs are sent in the same open connection, before final response as "notifications/message".
Keepalive	both	ping	Removed — SSE comment-line keepalives on long streams instead. No dedicated RPC
Cancellation	Client → Server	notifications/cancelled	Close the SSE response stream (HTTP); notifications/cancelled now stdio-only. Cancellation piggybacks on stream closure over HTTP
Long-running work	Client ↔ Server	No first-class support	tasks/get, tasks/update, tasks/cancel (extension); tools/call can return a task handle; tasks/list removed. New capability, extension framework
Interactive UI	Server → Client	Not supported	MCP Apps extension (SEP-1865) — sandboxed iframe HTML. New capability
Stream resumability	—	SSE Last-Event-ID allowed reconnect/redelivery	Removed — broken stream ⇒ re-issue request with new ID, no redelivery. Simplicity traded for reliability guarantee

Key takeaway: MCP 2026-07-28 moves away from connection- and session-bound behavior toward self-contained, request-scoped interactions, while introducing mechanisms such as MRTR, subscription-based listening, explicit cross-call state, tasks, and MCP Apps.