MCP Just Killed the Handshake (Your Server Is Next)

Originally published in Temrel, a weekly newsletter on agentic engineering.

You have built an MCP server the right way: handshakes, and perhaps even sampling. On Monday 28 July, the spec finalises and a great deal of "the right way" becomes legacy. It is not going to blow up, but the clock starts.

An MCP primer (skip if you know it)

The Model Context Protocol (MCP) is an open standard from Anthropic (late 2024) that defines how AI apps connect to external tools and data. It runs on local stdio or, more commonly, streamable HTTP for remote tools. Three roles: the host (the app, e.g. Claude Code or Cursor), the client (runs inside the host, manages the connection), and the server (wraps a tool's capability, e.g. GitHub or Postgres).

Servers expose three primitives: Tools (functions, JSON inputs), Resources (data indexed by URI), and Prompts (e.g. slash commands). Client-side primitives let the server ask the client for something: Sampling (LLM completions client-side), Roots (which directories are in scope), and Elicitation (asking for more information mid-operation). Two of these are on death row.

Until now, client and server did an initialize handshake, with remote servers issuing an Mcp-Session-Id header for all subsequent requests in the session.

The handshake is dead

We are dropping initialize and Mcp-Session-Id, so at scale we no longer manage sticky routes and a shared state store. A connection is no longer married to a server instance. Requests route on an Mcp-Method header and can land on any instance behind a load balancer. In essence, MCP just became like any other ordinary web service.

State is debt, now we are paying it off

Sessions used to force stickiness, shared data stores, and gateway packet inspection. Those are gone. They were an infrastructure tax for state that did not add anything meaningful. State is debt. There is a parallel with context engineering: redundant tokens are liabilities, not assets. Protocol state was too. Ironically, some of the statefulness is being pushed back to the model, which now stores the chain of calls instead of the server. That is the superior approach, because the model is driving the bus.

What actually breaks (and what just smells)

The hard break is the Tasks API, replaced by the Tasks extension: task calls migrate to tasks/get, tasks/update, and tasks/cancel. Deprecated, but with a 12-month runway, are Roots (use tool params/config instead), Sampling (the MCP reaches directly to your model's API), and Logging (stderr or OpenTelemetry). Auth is hardening: OAuth 2.1 is now mandatory. Minor SDK updates: Python renames FastMCP to MCPServer, TypeScript goes ESM-only, and Go and C# appear in preview.

Your migration pass, this week

• grep for session assumptions and initialize handlers.


• update your Roots/Sampling/Logging usage; each now has a named replacement.


• pin any critical SDK versions before you get v2 by surprise.

From the temrel-agentic-toolkit

Or use the tool we are releasing today: mcp-spec-audit. It scans your repo for landmines related to the update and gives you a migration checklist. Run it in the CLI, or adopt it as a Claude Code skill; the skill is the fastest route, because Claude will follow up the output and offer to complete the fixes.

Do this today

1. Run mcp-spec-audit (or the manual greps above) against every MCP server you own.


2. Migrate anything on the experimental Tasks API now: it is the only hard break.


3. Open a ticket per deprecated feature with its named replacement, dated inside the 12-month window.

Why this matters

Protocols mature the way codebases do: by deleting. MCP shedding state is it becoming boring infrastructure, and boring is what wins. Keep asking: how can I further shed state, or pass it to more useful locations?

Subscribe to Temrel for weekly agentic engineering field notes.