MCP protocol goes stateless for AI scalability
In the early 2000s, web developers faced a quiet crisis. Websites were growing beyond what a single server could handle, but the standard way of keeping track of users — storing their session data on one machine — meant that if a request went to a different server, the user would be logged out or lose their shopping cart. The fix was simple and brutal: make the server forget. Store nothing. Pass all the information you need in a token the client sends back with every request. Statelessness became the foundation of the modern web, and it is the same lesson that AI’s infrastructure is now, belatedly, learning.
The Model Context Protocol (MCP) is the invisible plumbing that lets an AI chatbot reach into your calendar, your database, or your internal tools without engineers having to build custom connections for every single one Arcade It is one of the basic building blocks of AI interoperability, giving models a secure way to access external data sources and services. Next week, that protocol is getting a significant update, and while most users will never notice, it could determine whether the promise of AI agents working inside real companies ever materializes Arcade.
Where the Protocol Fails
The problem is session IDs — those little tokens that servers use to remember that this is the same conversation they were having five seconds ago. Under the current system, when an MCP client like Claude first connects to a server, it sends a greeting: its name, its version, its capabilities. The server replies with its own capabilities and hands back a session ID. From then on, the client sends that ID on every request so the server knows it is the same conversation. Sometimes the ID expires, so the client has to notice, request a new one, and carry on Arcade.
This works fine for a single server talking to a single client. It works fine for a demo. But picture a real deployment: you are running a server for millions of users, behind a load balancer whose entire job is to route each request to whatever machine in the farm is free, sometimes in a different region. Now every one of those machines has to know about a session ID that some other machine handed out. It is not impossible, but it is a serious pain, and it fights the load balancer instead of working with it Arcade.
The Infrastructure That Wasn’t Ready
Arcade is a two-year-old startup that built its entire business around making AI agents actually function inside real companies, letting them securely connect to and act on tools like Gmail, Slack, and Salesforce. They raised $60 million in June on the premise that most AI agents do not fail because the underlying models are weak, but because the infrastructure around them is not ready yet Arcade. That is exactly what this update is trying to address.
The current setup assumes one server remembers you, but real companies spread traffic across dozens of servers that do not talk to each other by default. Today’s MCP servers have to do extra work just to keep track of who is who. That has been a significant headache for anyone running an MCP server at scale, and it is part of the reason we have not seen more companies ship large-scale, first-party MCP integrations despite all the hype around agentic AI this year Arcade.
The Fix That Is Also a Lesson
Under the new system, the protocol will take a looser, stateless approach to session IDs on the server side, similar to how most ordinary websites already work. This should make the whole system much easier to maintain and, in theory, cheaper to run at scale Arcade. The official spec for the new version has been public since May, but the change is only now becoming real.
The irony is thick. The web solved this problem twenty years ago. The HTTP protocol that carries almost all internet traffic is fundamentally stateless — each request is treated as an isolated transaction, and any state is either stored in cookies on the client side or passed in the URL. The lesson was that trying to remember things on the server creates bottlenecks that destroy scalability. MCP is now learning the same lesson, from scratch, two decades later.
Why This Matters More Than It Sounds
This is not a story about session IDs. It is a story about what happens when a field moves too fast to look back. AI development has been racing ahead at breakneck speeds, with model training consuming billions of dollars and generating breathless headlines every week. But the technical infrastructure those models need to actually do useful work is still subject to the slow log-rolling of standards-body consensus, the tedious work of getting people in a room to agree on how things should work Arcade.
The result is that we have incredibly powerful models that can reason, write, and generate code, but they cannot reliably look up your calendar entries or send an email on your behalf without a team of engineers building custom pipes for every single connection. The hype says we are on the verge of autonomous agents that will run our lives. The reality is that the plumbing is still being designed, and it is being designed by people who are rediscovering lessons that web developers learned in 2004.
The Image That Summarizes the Problem
Imagine a skyscraper built with the world’s strongest steel, the most advanced elevators, and the most sophisticated climate control system. Now imagine that the architects forgot to include the pipes for water. The building stands, it looks impressive, but nobody can live there. That is where we are with AI agents. The models are extraordinary. The infrastructure is still being figured out, and every time someone thinks they have solved it, they discover that the problem was harder than it looked. The MCP update is a small step toward fixing that, but it is a step that the industry should have taken years ago.
The MCP update is a small step. It makes one specific thing easier: running servers at scale without fighting your own load balancer. But it is also a reminder that the hardest problems in AI are not the ones that generate headlines. They are the boring ones, the ones about session management and load balancing and consistent APIs, the ones that the web solved years ago but that AI is only now getting around to addressing.
Sources
1. Arcade