TL;DR - the new MCP standard goes live imminently. Parse your MCP manually, or use Temrel’s free tool to audit and detect what changes to make

You’ve built an MCP server the right way, doing your handshakes, perhaps even sampling. On Monday 28th July, the spec finalises and a great deal of ‘the right way’ becomes legacy. It’s not going to blow up, but the clock starts.

The Model Context Protocol (MCP) is an open standard released by Anthropic in late 2024 that defines how AI apps connect to external tools and data. MCP can run on local stdio or more commonly streamable HTTP for remote tools. There are three roles:

host: the app connecting to the MCP, e.g. Claude Code, Cursor et. al.
client: this runs inside the host and manages the connection to the server
server: this wraps the capability of the tool, e.g. GitHub, Postgres, etc

Servers expose three primitives: Tools (functions the app is calling, JSON inputs), Resources (data, indexed by URI), Prompts (e.g. slash commands).

Client-side primitives allow the server to ask the client something: Sampling for LLM completions on the client side via API calls to tools/call and tools/list, Roots where the client tells the server which directories are in scope and Elicitation where the server asks for more information mid-operation. Two of these are on death row.

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

We’re dropping initialize and Mcp-Session-Id, so at scale we no longer have to manage sticky routes and a shared state store. A connection is no longer married to a server instance. Requests get routed on an Mcp-Method header and can land on any instance behind a load balancer.

In essence, the MCP just became like any other ordinary web service.

Sessions used to force stickiness, shared data stores and gateway packet inspection. These are gone now. They represented an infrastructure tax for state that didn’t really add anything meaningful.

State is debt. We don’t like state.

There’s a parallel here with context engineering: redundant tokens are liabilities, not assets. Protocol state was too.

Ironically in this case, though, some of the statefulness is being pushed back to the model. It’s the model that now stores the chain of calls instead of the server. This is a superior approach as the model is driving the bus here.

Great, you might ask, but what breaks now on my current MCP setup?

The hard break is the Tasks API. This is replaced by the Tasks extension, meaning task calls need to be migrated to tasks/get , tasks/update and tasks/cancel. Bummer if you built on the Tasks API.

Deprecated, but with a 12-month runway are Roots (use tool params/config instead), Sampling (the MCP will reach directly to your model’s API) and Logging (stderr or OT).

Auth is hardening; OAuth 2.1 is now mandatory.

Minor updates on the SDK: Python is renamed MCPServer from FastMCP, TypeScript goes ESM-only and we see the first appearance for Go and C# in preview.

Do a quick pass on what needs to be migrated for your MCP:

Or alternately, use the tool we’re releasing today: mcp-spec-audit. It’s a scanner parses your repo for any 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 - Claude will follow up the output offering to complete the fixes.

Check the details here.

Protocols mature the way codebases do: by deleting. MCP shedding state is it becoming boring infrastructure, and boring is what wins. Let this be a part of your ongoing thinking. Ask yourself ‘How can I further shed state, or otherwise pass it to more useful locations?’

Did the write-down hit anything you actually used? If you're mourning Sampling, tell me what for. Genuinely curious who was on it.

See you next week.