AI Integration · BraivIQ AI Engineering Playbook

MCP Just Went Stateless: Architecting Remote Model Context Protocol Servers As Ordinary HTTP Workloads

The Model Context Protocol has become the universal connector between AI agents and the systems they need to reach - 97 million monthly SDK downloads and over 10,000 public servers in production by 2026 - but until recently, deploying a remote MCP server at scale was awkward because the protocol assumed a stateful, long-lived connection between client and server. The 2026-07-28 specification changed that decisively: MCP evolved into a stateless architecture in which a remote MCP server is no different from any other HTTP workload - cacheable, routable, horizontally scalable, and deployable on exactly the infrastructure you already run your APIs on. This playbook is an engineering-grade guide to what stateless MCP actually means in code, the new patterns it introduced (Tasks, subscriptions, progress notifications, and the Multi Round-Trip Requests pattern that replaced server-initiated requests), and how to architect a remote MCP server that scales like the rest of your web tier.

September 13, 2026 · 13 min read · By BraivIQ Engineering

97M / month - Combined Python + TypeScript MCP SDK downloads - the protocol is now mainstream infrastructure · 10,000+ - Public MCP servers in production, from individual dev tools to Fortune 500 deployments · 2026-07-28 - The specification that made MCP stateless - remote servers become ordinary HTTP workloads · SEP-2322 - The Multi Round-Trip Requests pattern that replaced server-initiated requests so elicitation works statelessly

The Model Context Protocol won. In the space of about eighteen months it went from a promising idea to the default way agents reach the systems they need - the CRM, the database, the ticketing tool, the internal service - crossing 97 million combined monthly SDK downloads and more than 10,000 public servers in production by 2026, spanning everything from a solo developer's tool to Fortune 500 deployments. The appeal is structural: write an MCP server once, in Python, TypeScript or C#, and it can be consumed interchangeably by Claude Desktop, custom enterprise agents, IDE plugins and multi-agent frameworks without modification, turning the old M-clients-times-N-systems integration mess into M-plus-N. But there was a real operational wart. Early MCP assumed a stateful, long-lived connection between client and server, which is fine for a desktop app talking to a local server and genuinely painful when you want to deploy a remote MCP server for a whole organisation - stateful long-lived connections do not cache, do not load-balance cleanly, and do not scale horizontally the way modern web infrastructure expects. The 2026-07-28 specification fixed exactly this by making MCP stateless, and as an AI Agency Developer London that builds these integrations for enterprises, we think it is one of the most important protocol changes of the year. This playbook is what it means in code.

Why Statelessness Is The Whole Story: A stateful server holds per-client session state in memory across a long-lived connection, which means requests from one client must keep hitting the same server instance, you cannot freely cache responses, and scaling out requires sticky sessions and careful connection management - all the things that make scaling hard. A stateless server treats each request as self-contained: any instance can handle any request, responses can be cached, a load balancer can route freely, and you scale horizontally by simply adding instances - exactly how you already run your REST and GraphQL APIs. By moving MCP to a stateless model, the 2026-07-28 spec made a remote MCP server no different from any other HTTP workload. That single change is what turns MCP from something awkward to deploy at scale into something you host on the boring, proven infrastructure you already operate - and it is why enterprise adoption is about to accelerate.

What Changed In The 2026-07-28 Specification

The headline is statelessness, but the specification had to solve several concrete problems to get there, and understanding them is what lets you architect correctly. The first is the obvious one: a remote MCP server is now designed to be operated like any HTTP service - stateless, cacheable, routable and globally scalable - so you host it on the same load-balanced, auto-scaling infrastructure you use for your other APIs, with no special session affinity. The second problem is that some MCP interactions are genuinely long-running or asynchronous - a tool call that kicks off a job that takes minutes - which does not fit a simple request-response model; the spec introduced Tasks to represent this, along with subscriptions and progress notifications so a client can start something, be told about progress, and collect the result without holding a connection open the whole time. The third and subtlest problem is elicitation: sometimes a server needs to ask the client something mid-operation (a confirmation, a missing parameter), which historically meant server-initiated requests - and server-initiated requests are fundamentally incompatible with statelessness, because they assume the server can reach back down a held connection. The Multi Round-Trip Requests pattern, introduced as SEP-2322, replaced server-initiated requests with a client-driven flow that achieves the same elicitation behaviour without requiring the server to hold state or initiate contact. Together these changes preserve MCP's rich interaction model while making the transport behave like ordinary, scalable HTTP.

Stateless transport - each request is self-contained, so any server instance can serve any request; no sticky sessions, free horizontal scaling.
Tasks - a first-class representation of long-running or asynchronous work, so a tool that starts a multi-minute job fits the protocol cleanly.
Subscriptions and progress notifications - clients can be informed of progress and completion without holding a connection open throughout.
Multi Round-Trip Requests (SEP-2322) - a client-driven replacement for server-initiated requests, so elicitation works without stateful, server-initiated contact.
HTTP-native operation - the server is deployable on the same load-balanced, cacheable, auto-scaling infrastructure you already run your APIs on.

Architecting A Remote MCP Server That Scales

In practice, statelessness changes how you build the server, mostly for the better and mostly in ways that will feel familiar to anyone who has built a well-behaved REST API. Treat every request as self-contained: derive everything you need from the request itself plus your backing stores, and hold no per-client session state in the process memory - if you need continuity, persist it in a shared store (a database, a cache) keyed by an identifier the client passes, exactly as you would for a stateless web service. For long-running work, use Tasks rather than trying to keep a request open: accept the request, start the job, return a task handle, and let the client poll or subscribe for progress and results, which keeps individual requests short and lets any instance serve any follow-up. Design your tools to be idempotent where possible, so that retries - which a stateless, horizontally-scaled world makes more likely - do not cause duplicate side effects. And bring your normal web-tier discipline to bear: put the server behind your standard load balancer and auto-scaler, cache what is genuinely cacheable, and instrument it with the same logging, tracing and metrics you use for your other services. The payoff is that operating an MCP server stops being a special case and becomes just another HTTP workload your platform team already knows how to run.

The security concern statelessness does not remove: Making MCP servers easy to deploy at scale makes it easy to expose a lot of capability to agents - which is exactly why the security discipline around MCP matters more, not less. An MCP server is a doorway into a real system, so it must enforce least privilege (scoped credentials, only the tools and data genuinely needed), strong authentication and authorisation on every request (trivially, statelessness means every request must carry and be checked for its own auth - you cannot lean on a trusted long-lived session), audit logging of what was called and by whom, and defence against prompt-injection-driven misuse of high-consequence tools. Stateless transport is an operational win; it changes nothing about the obligation to treat every MCP server as a security boundary. Build the scaling and the guardrails together.

The Bottom Line

MCP became the universal connector between agents and enterprise systems, but its early assumption of stateful, long-lived connections made remote servers awkward to deploy at the scale enterprises need. The 2026-07-28 specification resolved that by making MCP stateless: a remote MCP server is now no different from any other HTTP workload - cacheable, routable, horizontally scalable, and deployable on the infrastructure you already run your APIs on - while new patterns (Tasks, subscriptions, progress notifications, and the Multi Round-Trip Requests pattern that replaced server-initiated requests) preserve the rich interactions that made the protocol useful. For engineering teams the practical consequence is liberating: building and operating an MCP server stops being a special case and becomes ordinary web-tier work, which is precisely what will drive the next wave of enterprise adoption. The discipline that remains is security - every MCP server is a doorway into a real system and must be built as a least-privilege, authenticated, audited boundary. Get both right - scale it like your web tier, secure it like a doorway - and MCP becomes the dependable connective tissue of your entire agent estate, which is exactly the integration work we do.

References & Further Reading

Model Context Protocol Blog - The 2026-07-28 Specification (stateless architecture, Tasks, Multi Round-Trip Requests / SEP-2322): https://blog.modelcontextprotocol.io/posts/2026-07-28/
Model Context Protocol Blog - The new MCP roadmap: https://blog.modelcontextprotocol.io/posts/mcp-roadmap/
Kunal Chowdhury - Model Context Protocol (MCP) architecture: building standardized tooling for production enterprise AI agents: https://www.kunal-chowdhury.com/2026/09/model-context-protocol-mcp-architecture.html
Raulji Technologies - MCP in 2026: the universal connector for AI agents (adoption and scale): https://www.rauljitechnologies.com/blog/mcp-model-context-protocol-2026/
NeuralCoreTech - Agentic AI and Model Context Protocol (MCP): architecture guide 2026: https://neuralcoretech.com/agentic-ai-model-context-protocol-mcp-architecture-2026/