Hi,

Most weeks in this field the story is loud. A launch, a raise, a number with a lot of zeros in it.

This week's story is a deletion. One header, gone from a technical specification. No event, no announcement, nothing to look at.

I almost skipped it. Then I read what was actually being deleted, and it turned out to be the thing the plumbing under every AI agent has assumed from the beginning: that the machine on the other end remembers who you are.

Take that away and the memory does not disappear. It moves. Out of the wiring, into the conversation, where you can actually see it.

Which leaves a question I have not stopped turning over. Once the server stops remembering you, whose job is it to make sure whatever is remembering you on your behalf is remembering honestly?

Listen:

Spotify: https://open.spotify.com/episode/3JJgRtSgGYAoGptXpXc1fm?si=n3Yo69uCS_CW81YqPC5QLw

Apple Podcasts: https://podcasts.apple.com/us/podcast/plain-strata-no-handshake-required/id6783455764?i=1000778745314

YouTube: https://youtu.be/Lha8eFO-3pc?si=WBojr1YM6HVreFN_

The full piece, no need to click through:

On July 28, the plumbing underneath most of the AI agents you've heard of quietly stops remembering you.

That sounds like nothing. An infrastructure header, gone from a technical spec. But this is the exact week it ships, and the change underneath it is bigger than it sounds. The protocol that lets an AI assistant reach outside itself, open a file, run a search, book a flight, is deleting the one thing every earlier version of it assumed it needed: a running memory of who's on the line.

That's this week's story. The protocol is called MCP, the Model Context Protocol, and on July 28 it finishes becoming stateless.

Start with what MCP actually is, physically. When an AI model wants to do something outside its own head, search a database, read a file, call an API, it needs an agreed-upon way to ask and to be understood. MCP is that agreement: a wiring standard connecting a model to the tools around it. The word protocol comes from the Greek protokollon, the first glued sheet on a scroll, the page you read before the real text, stating what's inside and how to handle it. A protocol is that instinct made formal: one first page everyone reads the same way, so two strangers' machines can talk without guessing.

Until this week, using that wiring meant something like starting a phone call. First you dialed in: an "initialize" handshake, where the agent introduced itself, its version, its capabilities. The server on the other end handed back an ID, a session ID, and every message after that had to carry it, the way you'd give a callback number to the one operator who picked up. That operator, that one machine, was now the only one who could serve you for the rest of the conversation. If a company ran its agent-tool servers across three machines, all three had to share a card index of every open session, or a load balancer had to remember which machine answered which call and keep routing that caller back to the same desk. Engineers call this sticky routing, and it is exactly the kind of invisible bookkeeping nobody wants to maintain as traffic grows.

As of July 28, that whole exchange disappears. No dial-in, no handshake, no session ID. Every request an agent makes now carries everything the server needs to answer it, right there in that one message: who's asking, what version of the protocol they speak, what they want done. Any server, any machine, in any city, can pick up any single request and answer it in full, because nothing about answering it depends on remembering an earlier conversation. The AI agents didn't get worse at holding a conversation. The protocol underneath simply stopped being the thing responsible for remembering it.

This is the same move as pulling two blurred moments apart and naming them separately. The old protocol blurred "connect to a server" and "have a conversation" into one continuous thing, so the server had to hold you in memory from the first exchange to the last. The new one splits that cleanly: connecting is nothing, a single request is everything, and if a conversation needs to remember something across many requests, that's now a fact carried in the words themselves, not a fact about which wire you're still holding open.

So what does deleting a header actually buy anyone? A very physical thing. Computers that must share memory about who's talking to whom become a bottleneck no matter how many you add, because someone still has to keep the card index straight across all of them. A stateless protocol removes that bottleneck outright. A company running agent-tool infrastructure can now put an ordinary, dumb load balancer in front of any number of servers and let it hand each incoming request to whichever machine happens to be free, the way a call center works once nobody needs to remember which agent you spoke to last time. That's the concrete gain, and it's why the team maintaining MCP calls the stateless core the headline change in the largest revision the protocol has had since it launched.

Real conversations still need some memory, obviously. An agent building a shopping order needs to know what's already in the basket between one tool call and the next. The new spec doesn't pretend that need vanishes, it just moves who's responsible for holding it. Instead of a hidden token the transport quietly carried on the caller's behalf, a tool now hands back an explicit handle, a basket ID, say, and the model itself carries that number forward and passes it as an ordinary argument on the next call. The memory hasn't disappeared. It's moved out of invisible plumbing and into the open conversation, something the model can see, reason about, and even hand off between steps, instead of something a server was quietly tracking behind the scenes.

The same release also tightens how an agent proves it's allowed to act at all, aligning MCP's authorization flow more closely with the OAuth and OpenID Connect standards the rest of the web already leans on, closing a class of mix-up attack that gets more likely once one client is juggling many servers instead of one.

Here's where this week's story connects to one this show already told. Three weeks ago, this show covered a different piece of agent plumbing, a standard that lets an AI agent hold a name and a track record, and found something underneath it worth naming: a reputation doesn't need a continuous self behind it, a person who remembers being the same person yesterday. It only needs a continuous identifier, one number that stays the same no matter what changes behind it. MCP's session removal is the same idea, one layer further down the stack. A conversation with a tool doesn't need a continuous connection behind it either. It only needs the words themselves to carry, honestly and completely, what a continuous connection used to carry for free. Two different pieces of the same emerging system, arriving weeks apart, solving the same underlying problem the same way: stop relying on something staying connected, and start relying on something being stated.

The honest cut: statelessness buys scale, it doesn't automatically buy trust. Every explicit handle, a basket ID, a workflow token, is now a plain argument sitting in a request instead of something a session quietly guarded. A fair reply is that the old session ID never really protected the value either, it protected the wire. Still, the question this leaves open for anyone building or depending on agent infrastructure is a real one: once the server stops remembering you, whose job is it to make sure whatever is remembering you on your behalf, the model, the client app, some downstream system, is remembering honestly? That's the same authorization question this show has circled all month, wearing a new coat. Identity answers who you are. Verification answers whether the work got done right. This adds a third, quieter cousin: whether the state a stateless conversation is carrying forward is actually the state it claims to be.

Nothing about this is loud. No launch event, no funding round, no token. It is a specification finishing a ten-week validation window and shipping on schedule, the kind of change that never trends and reorganizes the floor everything else stands on anyway. Every agent framework this show has mentioned, the ones that build on MCP to let a model reach a tool, inherits this shift the moment it upgrades, whether or not anyone building on top of it notices the day it happened.

Watch which of MCP's Tier 1 SDKs, Python, TypeScript, Go, and C#, ship full stateless support cleanly inside the validation window versus which need extra time; that gap is the real measure of how breaking this change turns out to be in practice, not the spec text itself. And watch the agent frameworks built on top of MCP whose own internal design assumed a session, since at least one major one has said its checkpointing model leans on session-shaped state and now has to answer for it in public.

The two voices are AI. The research and writing are mine.

Decentralized AI, layer by layer.

Dastan