Stateless MCP has recaptured my interest (and inspired mcp-explorer and datasette-mcp)

Why now: MCP's journey from hype to cooling off, and back into the spotlight

The Model Context Protocol (MCP), launched by Anthropic in late 2024, was once hailed as the standard way for AI agents to call tools. But through 2025 it was largely eclipsed by a more freewheeling approach: give the agent a terminal and curl and let it loose. This “Skills”-style flexibility made MCP feel overly rigid, and Simon Willison himself wrote that 2025 was “the only year of MCP.”

Now with the arrival of MCP 2.0 (the 2026-07-28 spec) and its full embrace of statelessness, the mood has shifted. Simon openly says the new architecture has reignited his interest—not only because it’s safer and more auditable, but because implementation costs have plummeted.

Breaking it down: what does stateless MCP actually simplify?

Legacy MCP required a client to first send an initialize request, obtain a session ID, then use that ID for subsequent tool calls. That seems simple, but it introduces a state management burden: servers must track sessions, handle timeouts, and route traffic to the correct backend. For horizontally scaled applications, it’s a significant drag.

The new stateless MCP folds everything into a single HTTP request. Custom headers (like MCP-Protocol-Version, Mcp-Method) carry the metadata, eliminating the need for a separate handshake. One request can convey “call the search tool with the argument ‘otters’” (as shown in the post).

This slash in complexity means client libraries shed entire lifecycle management modules, while servers become trivially lightweight—you can write a compliant MCP server in a few dozen lines and host it effortlessly on serverless platforms. It also aligns with the stateless philosophy of HTTP, making caching, logging, and debugging far more natural.

Trend: the stateless wave hitting AI agents

The shift to stateless MCP hints at a broader trend: AI tool calling is moving from “maintain a complex session” to “single, stateless interaction.” And it’s not random. As agents enter production, auditability, scalability, and least-privilege become paramount. A stateless tool call is just like any API request—you know exactly what happened and why. By contrast, letting an agent run wild in a shell is flexible but risky, like opening a black box with huge security and model-capability requirements.

Simon himself reflected: giving an agent a networked shell is dangerous (he cited an OpenAI cyberattack example) and demands strong models. MCP tools, on the other hand, draw clear boundaries. Each tool has a defined job, making it possible even for smaller, locally running models to drive them reliably.

Practical implications: how developers should think and act

If you’re building an AI toolchain, stateless MCP offers three immediate wins:

1. Ultra-low integration cost: exposing an internal API, database query, or file operation is now a breeze. Simon wrote three tools in as many days (including the mcp-explorer CLI and datasette-mcp), proving the point.
2. Natural fit for microservices and edge deployment: statelessness means you can run MCP servers as Cloudflare Workers or AWS Lambdas, scaling effortlessly.
3. Safer security boundaries: every tool call is independent and loggable. You can tightly control what an agent can do without giving it full shell access.

Counterintuitive angles: a small architectural change swaps control for safety

Many will see the protocol simplification as a mere developer-experience win. But the move from stateful to stateless is really about shifting security responsibility from the model to the architecture. With the old sessions, once established, an agent had ongoing operational power; in the new model, each call must stand alone, drastically shrinking the window for accidental or malicious actions.

Another overlooked angle: this design lets MCP compete again with “Skills-style” approaches. Skills thrive on infinite possibility; MCP leans on clear boundaries and reliability. In an era of rising AI safety concerns, the latter may prove more durable.

In sum, stateless MCP isn’t a revolutionary breakthrough, but it hits the exact sweet spot that developers crave: simple, secure, scalable engineering. That’s why a protocol update has managed to reignite excitement in a veteran like Simon Willison.