MCP gets a major overhaul! The stateless core now runs natively on Cloudflare Workers!

Hi, it's Shii! Today I found some big news on the Cloudflare blog about MCP (Model Context Protocol). It's an announcement about rebuilding the protocol's core from the ground up, and while it might sound low-key, it's actually the kind of change that reshapes how you build infrastructure around it. Let's dig in!

Cloudflare Blog blog.cloudflare.com

What was announced?

Cloudflare's blog announced a new MCP specification called "MCP 2026-07-28." The headline change is that the protocol's core has been rewritten to be stateless. The old MCP assumed the server would hold onto session state, but under the new spec a request can arrive at the server, invoke a tool, prompt, or resource, and just return the result, nothing more. As the post puts it, "there is no protocol session to store" anymore.

By the way, it looks like Cloudflare put out several agent-related announcements on the same day, so this MCP overhaul seems to be part of a broader push toward making the web friendlier for agents.

The story so far

Until now, MCP required session management between client and server via an Mcp-Session-Id header, plus a mandatory initialization handshake up front. That meant the server had to keep track of which session belonged to whom, which forced you into stateful infrastructure: sticky-session routing to make sure requests hit the right instance, and mechanisms to keep streams alive.

In a Workers environment like Cloudflare's, that kind of state management typically meant reaching for Durable Objects, so even standing up a simple MCP server added real infrastructure complexity.

What changes

Thanks to the new stateless core, MCP servers can now run as plain HTTP workloads. You don't need Durable Objects or similar state-management primitives, you can deploy straight to Cloudflare Workers. That lowers operational overhead, and it means MCP servers get to use the same scale, security, and observability primitives developers already use for the rest of the web.

On top of that, the /mcp endpoint accepts both the new stateless clients and 2025-spec Streamable HTTP clients at the same time, so you can migrate gradually without any configuration changes.

Dive Deep

Let's go a bit deeper into what's actually in the spec, I'm fired up!

Elicitation is now MRTR: Interactions where the server needs extra information, like approvals, user selections, or confirmations, used to depend on keeping a stream open. The new spec replaces that with input_required results, where the client retries the operation with the collected information attached, a pattern called Multi Round-Trip Requests (MRTR). Not having to keep a stream alive is a big deal.

Header-level visibility for HTTP infrastructure: MCP requests now carry Mcp-Method and Mcp-Name headers, so infrastructure components like gateways, rate limiters, and WAFs can make routing decisions without parsing the JSON body. For example:

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search

Caching and determinism: Results from tools/list, prompts/list, resources/list, and resources/read now come with ttlMs and cacheScope hints, and catalogs are ordered deterministically, which makes caching much more stable.

Stronger authorization: A clear preference order for clients has been established: pre-registered clients come first, then Client ID Metadata Documents (CIMD), while Dynamic Client Registration (DCR) is now deprecated and scheduled for removal after summer 2027. RFC 9207 issuer identification and RFC 8707 resource parameters were also added, preventing response confusion across authorization servers.

A new feature lifecycle: MCP now has a formal deprecation policy: a feature must stay available for at least 12 months before it can be removed. Every feature is classified as Active, Deprecated, or Removed, and in this release Roots, Sampling, Logging, DCR, and the legacy HTTP+SSE transport all move to Deprecated. There's also a new "Extensions" framework for experimenting outside the core spec, covering things like MCP Apps, Enterprise-Managed Authorization, and Tasks for long-running work.

The SDK migration path: The TypeScript SDK gets a new official API called createMcpHandler, graduating from its experimental status in the Agents SDK. A minimal server looks something like this:

import { McpServer } from "@modelcontextprotocol/server";
import { createMcpHandler } from "agents/mcp/server";
import { z } from "zod";

function createServer() {
  const server = new McpServer({
    name: "hello-server",
    version: "1.0.0",
  });

  server.registerTool(
    "hello",
    {
      description: "Return a greeting",
      inputSchema: { name: z.string().optional() },
    },
    async ({ name }) => ({
      content: [
        {
          type: "text",
          text: `Hello, ${name ?? "World"}!`,
        },
      ],
    }),
  );

  return server;
}

export default {
  fetch(request, env, ctx) {
    return createMcpHandler(createServer)(request, env, ctx);
  },
}

If you still need stateful sessions for legacy reasons, the post suggests running old and new routes side by side, migrating features incrementally, letting existing sessions drain naturally, and then removing the legacy route. There's also a Workers OAuth Provider library that handles the whole authorization flow for you.

Proven at production scale: Cloudflare's Code Mode MCP Server, released in February 2026, has scaled up to thousands of requests per second and served billions of tool calls in production.

Quotes from early adopters are featured too:

• David Cramer, co-founder of Sentry, said: "We built Sentry's MCP on Cloudflare's SDK. Big fans. We went live with this new one before the 7-28 spec was even finalized, and it didn't break prod. Big fans of that, too. This new spec cleans up a bunch of the nonsense around auth and tools, which is exactly what I wanted."
• Tom Moor, Head of Engineering at Linear, said: "MCP is a clear example of why open standards matter. The latest iteration of the spec is a great improvement that makes hosting an MCP server easier, more reliable, and at the same time adds much needed functionality."
• David Soria Parra, MCP co-creator at Anthropic, said: "This is the most significant advance to the protocol since launch. Clients gain meaningful performance with minimal engineering work. Security follows the same proven standards that protect the rest of the internet."

Wrap-up

Here's a recap of today's announcement.

• MCP's protocol core has been rewritten to be stateless, so requests complete without session management
• MCP servers can now run directly on Cloudflare Workers with no need for state-management primitives like Durable Objects
• Elicitation now uses the MRTR pattern with input_required, removing the need to keep a stream alive
• Mcp-Method / Mcp-Name headers make gateway-level routing decisions easier
• Authorization now prefers CIMD, deprecates DCR, and adds RFC 9207 / RFC 8707-based security protections
• A new feature lifecycle sets a 12-month deprecation window, moving Roots, Sampling, Logging, DCR, and legacy HTTP+SSE to Deprecated
• The new createMcpHandler makes the /mcp endpoint compatible with both old and new clients, enabling a gradual migration

This one is especially worth reading if you're already running an MCP server, or if you're planning to expose your own tools to agents over MCP. I'm itching to give createMcpHandler a try myself!