Every platform team that shipped a Model Context Protocol server in the last two years shipped it against a protocol that no longer exists. Revision 2026-07-28 of the MCP specification deleted the initialize handshake, deleted protocol-level sessions, deleted the SSE GET stream, deprecated Sampling, Roots, and Logging, and moved version negotiation into the body of every request. If your mental model of MCP is “JSON-RPC with an init dance and a session header,” that model is now dead and everything you deploy on top of it will behave strangely in production.

We rebuilt a small tool server against the new spec using the official Python SDK (v2.2.0, released 2026-09-07), drove it over Streamable HTTP, and captured the actual wire traffic with raw POSTs. This guide is the result: what changed, why the platform-engineering implications are bigger than the diff suggests, and the manifests, OAuth wiring, and failure modes you need to run MCP servers as production infrastructure rather than desktop-app curiosities.

TL;DR

  • MCP is now stateless at the protocol level. No initialize, no Mcp-Session-Id, no GET stream. Every request is a self-contained POST carrying its protocol version in _meta. We verified this on the wire: the same tools/call works with zero prior handshake.
  • Version negotiation moved to per-request _meta plus a new mandatory server/discover RPC. A mismatch returns UnsupportedProtocolVersionError (error code -32022) — we triggered it live.
  • New required headers on every POST: Mcp-Method and Mcp-Name, enforced with HeaderMismatch (-32020). We confirmed the SDK rejects a tools/call whose Mcp-Name does not match the tool being called — this will break naive proxies and hand-rolled clients that assume header-less JSON-RPC.
  • Sampling, Roots, and Logging are deprecated with a twelve-month window (earliest removal 2027-07-28). New server builds should not adopt them. If your agent host depends on server-initiated sampling, you now own that LLM call chain directly.
  • The production surface is now horizontal. Stateless requests mean boring, scalable HTTP semantics: any replica can serve any request, load balancing is trivial, and retries are safe. But per-request context (who is calling, what tenant, what trace) must now ride in headers and _meta, because there is no session to hang it on.
  • Security got teeth. OAuth 2.1 with RFC 9728 Protected Resource Metadata, RFC 9207 iss validation on code redemption, issuer-keyed credential storage, and a documented confused-deputy attack against MCP proxies that use static client IDs. Enterprise fleets get the Enterprise-Managed Authorization extension (ID-JAG) so Okta/Azure AD policy, not per-user consent, controls server access.

The Structural Shift: From Chat-with-Docs to Stateless Agent Infrastructure

The first era of MCP — the one most tutorials and most production deployments still target — was architecturally a desktop-app protocol. A host like Claude Desktop or VS Code launched local servers over stdio, performed an initialize handshake, and kept a long-lived session per server. That design was fine for one developer’s laptop. It was hostile to everything a platform team actually needs: horizontal scaling, load balancing across replicas, transparent retries, and clean multi-tenancy. Sticky sessions on a stateful protocol means every replica holds per-connection state, every load balancer needs session affinity, and every network blip is a session-resumption problem.

Revision 2026-07-28 reworks MCP into what the Streamable HTTP transport now plainly states: the server operates as an independent process handling multiple clients, every JSON-RPC message is its own HTTP POST, and a broken stream just means the client re-issues the request with a new ID. Sessions, event replay, and the GET-side channel are gone. List endpoints no longer vary per connection. Cross-call state, when a server genuinely needs it, moves into explicit server-minted handles passed as ordinary tool arguments — state by value, not by session.

That is the structural shift: MCP stopped being a conversation protocol and became a request/response protocol with an agreed capability vocabulary. For platform engineers this lands in three places:

  • Load balancing: any replica can serve any request. No affinity. We ran the same server behind repeated raw POSTs with no session state whatsoever.
  • Identity and tenancy: with no session to hang context on, tenant and caller identity must travel per-request (OAuth token claims, x-mcp-header custom headers from tool parameters, _meta trace context). This is a forced maturity upgrade for servers that previously ignored who was calling.
  • Observability: the spec now documents OpenTelemetry trace context propagation conventions for _meta keys (traceparent, tracestate, baggage), and the Python SDK ships an OpenTelemetryMiddleware. Distributed tracing is no longer an SDK-by-SDK afterthought.

There is a second shift worth naming before anyone schedules a migration. The client side of the old protocol — servers asking the host to sample an LLM (sampling/createMessage), clients advertising filesystem roots — is being wound down. Roots, Sampling, and Logging are all Deprecated as of 2026-07-28, with earliest removal at the first revision on or after 2027-07-28. The migrations the spec prescribes are blunt: pass paths via tool parameters or config instead of Roots; call LLM provider APIs directly instead of Sampling; log to stderr or OpenTelemetry instead of the MCP Logging feature. The protocol is narrowing to “server exposes tools/resources/prompts; client calls them” — and that narrowing is exactly what makes it deployable as platform infrastructure.

Architectural Blueprint

Here is the topology this guide builds toward: a fleet of stateless MCP tool servers behind an ingress, OAuth 2.1 in front, per-request identity and trace context, and a host-side gateway that handles discovery, caching, and progressive tool loading.

flowchart TB
    subgraph HOST["MCP Host (Agent Runtime)"]
        GW["Host-side MCP client(s)"]
        DISC["server/discover probe
(version + capabilities, optional)"] GW --> DISC end subgraph EDGE["Platform Edge"] ING["Ingress / Gateway
TLS, Origin validation, rate limit"] AUTHN["OAuth 2.1 resource server
RFC 9728 PRM discovery
token: audience-bound, issuer-keyed"] ING --> AUTHN end subgraph FLEET["Stateless MCP server fleet (n replicas)"] S1["Replica 1
POST /mcp"] S2["Replica 2
POST /mcp"] S3["Replica n
POST /mcp"] OTEL["OpenTelemetry middleware
traceparent in _meta"] end subgraph BACKING["Backing systems"] TOOLS["Databases, CI, cloud APIs
(per-tool scoped credentials)"] REG["MCP Registry
(server.json metadata, preview)"] end GW -->|"POST tools/call
_meta: protocolVersion 2026-07-28
headers: Mcp-Method, Mcp-Name"| ING AUTHN --> S1 AUTHN --> S2 AUTHN --> S3 S1 --> TOOLS S2 --> TOOLS S3 --> TOOLS OTEL -.-> S1 REG -.->|"publish server metadata"| S1