AI's Most Important Protocol Is Getting a Little Bit Easier to Use

Arcade, a startup that raised $60 million in June 2026 on the argument that AI agents keep failing because their infrastructure isn't ready — not because the underlying models are weak — put out the clearest technical explanation yet for a change that's been quietly in the works since May. The Model Context Protocol, which has become the standard plumbing layer connecting AI assistants to external tools, is dropping its stateful session system for a stateless approach that should make enterprise-scale deployments far less painful. The spec has been public since May 2026; the formal update ships next week.

Background You Need

Since Anthropic released MCP in late 2024, the protocol has become the de facto standard for connecting AI models to external services — email, calendars, databases, Slack, internal APIs. Before it existed, every integration was custom: if you wanted your AI assistant to read your inbox and then update a spreadsheet, you needed separate bespoke code for each service, each with its own context format and authentication scheme. MCP standardized that layer. As Quentin O Kasseh explained in a December 2025 analysis for Syntaxia, the protocol functions like an agreed-upon grammar — both sides know how information will be structured and transmitted, so the message sent is the message received.

The practical results of that standardization became visible quickly. A September 2025 piece in the Bulletin of the Atomic Scientists captured what MCP-connected AI actually looks like in use: author Abi Olvera asked Claude to analyze hundreds of emails and compile a spreadsheet of recent Nobel Prize winners. The model did it — navigating across websites, organizing data, catching some of its own errors. The same session then botched a dinner scheduling task, getting the start time wrong twice. That gap — sophisticated in one direction, fumbling in another — captured the state of MCP in its early months: the connective tissue was new enough that real rough edges still showed.

What didn't materialize, despite rapid growth in third-party MCP server implementations, was large-scale first-party enterprise adoption. The tools were there. Major companies largely weren't using them.

What's New

The hidden barrier, as Arcade's engineers explained, was how MCP handled sessions under the hood. The current protocol requires a stateful connection: a client initiates contact, receives a session token, and carries that token on every subsequent request. The server uses it to maintain context across a conversation. That model works cleanly for a single server instance running locally or in a simple setup. It becomes an operational problem the moment you deploy at scale.

Production infrastructure at large companies doesn't route every request from the same user to the same machine. Traffic is distributed across fleets of servers — often in multiple regions, often behind load balancers that have no knowledge of individual users' session history. For MCP to function in that environment under the current spec, every server in the fleet needs access to shared session state: a synchronized store that all machines can read from and write to. That's an engineering problem you can solve, but it's a layer of complexity and ongoing operational overhead that enterprises were quietly unwilling to absorb, especially while MCP's internal business case was still being argued.

The fix is conceptually straightforward: eliminate the session ID and make each request self-contained. A stateless MCP server treats every incoming call the way a standard web API does — all context travels with the request, no shared session store is required, and a load balancer can send traffic anywhere without coordination. The same pattern that made HTTP APIs practical at internet scale is being applied to MCP.

Our read is that this is less a technical breakthrough than a maturation step the protocol needed before enterprise infrastructure teams would give it serious consideration. Arcade's framing — agents fail because the infrastructure isn't ready — maps cleanly onto the session-state problem: models were already capable enough to act as agents, but the wiring beneath them was asking infrastructure teams to build plumbing they hadn't budgeted for. The $60 million raised in June is a bet that removing this kind of friction, not improving the models, is where the real leverage sits right now.

With the revised spec available since May 2026 and the formal update arriving this week, the practical question for teams running existing MCP servers is whether to migrate now or wait for client libraries to absorb the change. New implementations built going forward should target the stateless model by default.

The Pushback

Stateless sessions resolve a deployment headache, but they don't touch the security concerns that have followed MCP since it became load-bearing infrastructure for AI agents. The Bulletin of the Atomic Scientists analysis — written before the session fix was on the table — raised pointed questions about what it means to give an AI model authenticated, automated access to email, calendars, documents, and internal systems at scale. A stateless architecture makes that plumbing easier to distribute across many servers; it doesn't reduce the blast radius of a compromised agent or a model that acts on a malicious instruction embedded in a document it was asked to process. The protocol's surface area stays the same.

A separate protocol, Agent-to-Agent (A2A), is also emerging for multi-agent scenarios where multiple AI models need to negotiate, delegate, and collaborate — a use case MCP wasn't designed for. The Syntaxia analysis frames MCP and A2A as complementary rather than competing, but the boundary between them is still being drawn in practice. What this week's update clarifies is narrower: for the problem MCP was actually built to solve — connecting a single AI model to external tools in a standardized, reliable way — the infrastructure just got meaningfully less painful to run in production. That's a genuine step forward, even if the harder questions about security, multi-agent coordination, and enterprise trust remain unresolved.

Sources