Model Context Protocol's stateless shift could unlock large-scale AI integrations

AI's most important protocol is getting a little bit easier to use

The Model Context Protocol (MCP) is one of the basic building blocks of AI interoperability, giving AI models a secure way to access external data sources and services. It's the plumbing that lets a chatbot reach into your calendar, your database, or your internal tools, instead of engineers building custom pipes for every connection. Next week, that protocol is getting a significant update, and while it might not be noticeable to end users, it could make a big difference in how the ecosystem develops. The official spec for the new version has been public since May, but Monday morning, we got an unusually clear explanation of the changes from the folks at Arcade. Essentially, MCP is changing the way it handles session IDs -- the little tokens that servers use to remember "ah, this is the same conversation as five seconds ago" -- so servers can operate more easily at a larger scale. As Arcade's Nate Barbettini puts it: [Under the current system] The first time an MCP client like Claude connects to a server, it sends a "hello": I'm Claude, here's my version, here are my capabilities. The server replies with its own capabilities and hands back a session ID... From then on, the client sends that session ID on every request so the server knows it's the same conversation. Sometimes the ID expires, so the client has to notice, request a new one, and carry on.... Picture a real deployment. You're running a server for millions of users, behind a load balancer whose entire job is to route each request to whatever server 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's not impossible, but it's a serious pain, and it fights the load balancer instead of working with it. In other words, the current setup assumes one server remembers you, but real companies spread traffic across dozens of servers that don't talk to each other by default, so today's MCP servers have to do extra work just to keep track of who's who. That's been a significant headache for anyone running an MCP server at scale, and part of the reason we haven't seen more companies ship large-scale, first-party MCP integrations despite all the hype around agentic AI this year. 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, which should make the whole system a lot easier to maintain and, in theory, cheaper to run at scale. That's all pretty technical, but it's an important reminder that not every part of AI development is moving at breakneck speeds. While model training races ahead, a lot of the technical infrastructure those models need is still subject to the slow log-rolling of standards-body consensus. It really is happening; it's just a little slower!

Model Context Protocol prepares to break with its stateful past

AI seemed simpler in 2024 when Anthropic released the first version of the Model Context Protocol (MCP), an open standard for connecting AI applications to external systems. Back then, developers primarily used the protocol on their personal computers. As those laptop-bound demos were adapted for multi-client enterprise use, MCP servers moved into the cloud, where the original design quickly created scalability problems. On July 28, MCP's maintainers plan to finalize the protocol's 2026-07-28 revision, bringing many changes - including some that aren't backward compatible - that reflect some "hard lessons" the core MCP team learned over the past two years, said Anthropic technical staff member David Soria Parra in a livestream Tuesday. The 2026-07-28 revision will come with the "most substantial changes we have made to the specification, probably since adding authorization," Parra said. "A lot of things that made MCP are gone." Parra claims the new MCP will be easier to deploy and use. If users have been updating their SDKs, they shouldn't have much problem upgrading. But he also warned that the underlying data transfer mechanism has totally been rebuilt, which "makes things on the wire a bit more complicated than they used to be." Protocol-level session tracking will no longer be required. For those who rolled their own MCP engine, some long days of reconfiguration may be ahead. "If you built your own implementation, it's going to be a lot of uplift to make this correct," Parra admitted. Anthropic donated MCP in 2025 to the AAIF, a Linux Foundation fund co-founded by Anthropic, Block, and OpenAI. By that time, the SDK was being downloaded over 97 million times a month and at least 10,000 MCP servers had been set up. MCP is now stateless like the rest of the internet The chief change is that the new revision removes protocol-level sessions, allowing each request to be handled independently. This "stateless" approach, common in the cloud-native world, is used to scale web services behind a fleet of load balancers. Anthropic originally built MCP so that servers could be built to expose resources, tools, and prompts. An LLM-connected application can host clients to communicate with these servers via JSON-RPC 2.0. However, this approach came with excessive complexity and operational difficulties, especially creating and supervising protocol sessions for every individual action. As Parra acknowledged, the original specification failed to properly define how session details should be preserved, leading to complications. Furthermore, routing grew overly intricate when extra resources were required. The solution was simple. Under the new revision, information about the protocol version, client identity, and capabilities travels in the _meta parameter with each request, eliminating the need for protocol session tracking. MCP now operates very much like the Claude Messages API, also stateless, which provides the interface for sending and receiving messages with Anthropic's models. "I think that it's a very smart and nice way to just move... state away from the server onto the wire protocol and hope that bandwidth is for free," Parra said. MCP's routing mechanism was also totally gutted. The original messages were sent over JSON-RPC HTTP POST payloads, with the actual operation buried in the JSON body. The new revision also mirrors routing information in HTTP headers, allowing networking gear to route requests without tracking session status or inspecting the JSON-RPC body. MCP can now be extended however you desire A number of features in the original MCP have also been deprecated. One is sampling, which seemed useful at the time but turned out to be used rarely. It allowed an MCP server to ask the client's model to generate a completion, but the semantics were confusing and hard to implement, Parra said. Roots was also deprecated. It allows clients to tell servers which file system locations are relevant to a session. It was "a very niche thing," Parra said. Logging also got its notice for being excessively chatty, and developers were advised to just use stderr, stdio, or OpenTelemetry. "We are widening the surface to the things we thought were useful, but we are also realistic about narrowing [MCP] down to the good pieces that everybody is actively using," Parra said. MCP also has been enhanced with extensibility. "I think the extensions are a model for us to really test out things in the protocol before we bake them into the protocol," said Den Delimarsky, an Anthropic technical staff member who also joined the conversation. There are many use cases that are domain specific where an extension would be helpful, but the potential user base is not big enough to warrant rolling that feature out to everyone. And experimental features will be tested through extensions. Extensions can be bundled with the protocol, but have their own release schedule. One official extension is MCP Apps, which allows the MCP to present the user with an interactive app, built in JavaScript, instead of just text or an image. MCP's Tasks feature, used for managing long-running operations, has been moved out of the core protocol and into an extension. In addition to officially recognized extensions, users can build their own, following the instructions and suggestions in the specification, Parra said. Features formally marked as deprecated will remain functional for at least 12 months, according to Stacklok's "Enterprise Readiness Guide for the July 2026 MCP Spec Update." Stacklok, which offers an MCP platform, warns that this is not a blanket guarantee of interoperability with legacy implementations. Servers using the 2026-07-28 revision may not work with older clients, and vice versa. "Compatibility requires both sides to share a supported protocol era, or for one side to implement deliberate fallback or translation," the report noted. MCP's move to statelessness was a necessary one, in the view of Stacklok CEO (and co-creator of the very stateless Kubernetes), Craig McLuckie. "The stateful nature of MCP was really a by-product of its origin as a way to support developers using coding tools (that tend to run locally) to access things. The broader AI community is now embracing MCP as a mechanism to allow enterprises to intermediate access to production systems," McLuckie told the Register. "This gives cyber teams a unified control point to apply agent aware policy and is delivered in a form factor that platform teams are comfortable with running." ®

The future of AI may depend on this one behind-the-scenes change

Whenever a new AI model arrives, it's easy to get caught up in the bells and whistles. We talk about how much smarter it is, how quickly it answers questions, or how realistic its images have become. But here's the thing: none of that matters much if the AI can't reliably work with the apps and services people use every day. That's why an upcoming update to the Model Context Protocol (MCP) caught my attention. It isn't a new chatbot or a fancy AI model. In fact, most people will never even know it's happening. But it could quietly make the AI ecosystem a lot healthier. If you've never heard of MCP before, don't worry. Think of it as a shared language that lets AI assistants safely talk to apps like Gmail, Slack, calendars, databases, and countless other services. Instead of every company inventing its own way to make those connections, MCP gives everyone a common rulebook. The problem wasn't the AI -- it was everything around it One of the easiest mistakes to make is assuming AI only gets better when companies release a more powerful model. In reality, a lot of today's growing pains have nothing to do with intelligence. They have to do with infrastructure. Imagine calling a friend every few minutes and having to introduce yourself from scratch each time. That's a bit like how today's system works for many AI services. Servers spend extra effort tracking who's talking to them, especially when millions of people are using the same service at once. The next version of MCP changes that approach. Instead of making one server keep track of every conversation, the protocol makes requests easier to move between different servers. It sounds like a tiny technical tweak, but it removes a surprising amount of complexity for companies running AI services at scale. Sometimes boring is exactly what AI needs This update won't suddenly make ChatGPT, Claude, or Gemini feel dramatically smarter overnight. What it could do is make future AI products easier to build, easier to maintain, and easier to connect with the tools people already rely on. That's important because AI is moving beyond chatbots and becoming something that can work across your digital life. I like updates like this because they remind us that real progress isn't always visible. Sometimes it's not about teaching AI a new trick. Sometimes it's about fixing the plumbing so everything else works the way it should, and that is what makes the bigger payoff possible. And while that may not sound exciting today, it's exactly the kind of improvement that makes tomorrow's AI feel effortless and far more useful.