MCP's New Roadmap Is Mostly Deletions. That's Why It's Winning.

The most interesting thing that happened in AI this week wasn't a model release. There were no benchmarks, no benchmark charts with suspiciously cropped axes, no CEO promising godhood by Q4.

It was a six-minute blog post from the MCP maintainers, published August 22, about a roadmap. And the headline item — the thing that should actually change how you think about the agent ecosystem — is that the protocol keeps deleting itself.

Sessions: deleted. The initialization handshake: deleted. The special local transport that made MCP servers different from every other process on your machine: on its way out. When a protocol's biggest updates are removals, one of two things is happening. Either it's dying, or it's winning so hard it can afford to disappear.

Spoiler: it's the second one.

Quick refresher, then the good stuff

MCP — the Model Context Protocol — is the standard that lets AI agents connect to tools, data, and each other. Anthropic open-sourced it in November 2024, the industry shrugged, then OpenAI adopted it, then Google, then Microsoft, and now it's the connective tissue of the entire agent ecosystem. It lives under the Linux Foundation, which is corporate-speak for "nobody's taking this ball home."

You've heard it called the "USB-C of AI." Everyone says it. It's a lazy metaphor and, as the new roadmap makes clear, it's also wrong in an instructive way. More on that in a second.

Deletion as a strategy

The March 2026 roadmap had four priorities: transport, agent communication, governance, enterprise readiness. The July 28 spec release delivered on them, and the receipts are in the new post:

• Protocol-level sessions are gone (SEP-2575, SEP-2567). So is the initialization handshake. An MCP server no longer holds state per client, which means it scales horizontally like any other HTTP workload. Put it behind a load balancer and walk away.
• server/discover exists now. Clients can ask a server what it supports before committing to anything. Revolutionary? No. How every grown-up protocol works? Yes.
• List results are cacheable (SEP-2549), so your agent isn't re-downloading a tool catalog it saw eleven seconds ago.
• The next step: Streamable HTTP over stdio. The local transport and the remote transport are converging into one. One code path, one mental model, one thing to debug at 2am.

Read that list again and notice what's missing: anything that makes MCP special. The protocol is aggressively converging on "just HTTP." Requests, responses, webhooks, OAuth. The stuff your backend already speaks.

This is the part where the USB-C metaphor fails. USB-C won because it's a plug — one physical connector, obvious, visible. MCP is winning the opposite way: by becoming invisible. The end state of successful infrastructure isn't a connector, it's TCP. Nobody thinks about TCP. Nobody has opinions about TCP. It's just there, moving your bytes, boring and correct, for forty years.

Protocols don't win by being exciting. They win by being forgettable. Every special thing MCP deletes is a thing some future developer never has to learn.

The buried lede: agents are getting an identity

Here's the section of the roadmap that deserved way more attention than it got, tucked under the modest heading "Agent identity and enterprise-ready security":

MCP authorization today is built around a person approving access in a browser. That works well for interactive clients, but more and more of the callers are agents running as cloud workloads with their own identity, acting on behalf of a user who isn't present, or delegating narrower authority to sub-agents.

Parse that. The maintainers are saying out loud that the current model — you, a human, clicking "Allow" in a browser — doesn't cover how agents actually work anymore. Agents run at 3am. Agents spawn sub-agents. Agents act for users who are asleep or gone.

And today, the standard answer to "how does an agent authenticate?" is: paste an API key into a config file. The roadmap calls this out almost verbatim — the goal is agent identity "built on existing standards rather than pasted API keys and long-lived tokens." When the maintainers themselves describe your current security model as "pasted keys," you know the era is ending.

What's actually being built: Demonstrating Proof-of-Possession (DPoP) so a token can't just be copied and replayed, Workload Identity Federation so an agent gets an identity from the platform it runs on instead of a secret string, and the ID-JAG grant for delegation. They're doing this with the IETF — the actual OAuth and WIMSE working groups, the people who wrote the standards your bank runs on.

Why you should care, concretely: today, connecting an agent to a service means the agent is you. Full power of attorney, forever, via one bearer token. The roadmap's end state is delegation — you grant your agent narrower authority, the agent grants its sub-agents narrower authority still, and each link in that chain is verifiable and revocable. The difference between giving your housekeeper a key that opens one door, and taping a copy of your master key under the doormat with a note that says "be cool."

Nobody's shipping this tomorrow. But the direction is now official, it has named maintainers and a working group, and when it lands, "I pasted my key into an agent" will sound the way "I emailed my password to the intern" sounds today. If you're building agent infrastructure, start auditing where your keys live. You'll want that inventory sooner than you think.

Agents don't fit request-response, and MCP knows it

The first priority area in the roadmap is "agentic messaging primitives," and the opening line is quietly brutal: "Modern agentic workloads no longer fit the standard request-and-response pattern."

Right. An agent asks a server to do something, and that something takes forty minutes. The request-response pattern handles this the way a vending machine handles a marriage — wrong shape entirely.

So MCP is growing in the directions you'd expect: server-initiated events (webhooks and channels, so clients aren't left polling like dogs at a closed door), mid-flight steering of running work, and the Tasks extension maturing toward the main spec after being kicked out to an official extension earlier this year when early adopters said it wasn't quite right.

That last one deserves a beat of appreciation. Tasks went into the spec, real users pushed back, the maintainers moved it out to an extension, iterated, and are now walking it back in. That's a standards body functioning correctly — shipping, listening, retreating, correcting. It's the opposite of the industry's usual move, which is announcing a feature at a developer conference and deprecating it eighteen months later with a blog post titled "An update on our journey."

The context tax, finally being addressed

Buried in the "improved primitives" section is the item every MCP user has privately suffered through:

Connecting to a server with a hundred tools means the model pays for that entire surface before the user has asked a single question, and tool selection tends to get worse as the list grows.

This is the context tax, and it's brutal in exactly the places nobody measures. Connect your agent to a big MCP server and the tool definitions eat thousands of tokens before the conversation starts. Then the model, confronted with ninety tools, picks the wrong one — not because it's dumb, but because you handed it a phone book and asked for a plumber.

The fix is "progressive discovery": a server offers a small entry point and reveals more of its catalog as the conversation narrows. Which is, if you squint, just lazy loading — the same trick the web figured out decades ago. But applied to agent context, it's a direct cost and accuracy win. And if you're running open models locally, where every token is computed on your own GPU and a bloated context window means slower, dumber, hotter: this one's for you. There's also a promised cleanup of tool results — today the same output can arrive in multiple forms and the server has no idea which shape the client will show the model, so they're standardizing on one clear contract. Again: deletion of ambiguity.

One sentence you should not skip

My favorite line in the entire roadmap isn't about the protocol at all. It's in the SDK section, offered without ceremony:

"...many developers build MCP clients and servers by pointing an agent at our libraries, where clear APIs and accurate docs decide whether the code will work with minimal friction."

Sit with that. A major protocol is now optimizing its documentation for models as the primary reader, because the modal MCP developer is an AI writing code while a human supervises. The docs aren't just for you anymore. They're for the thing you built to replace the part of the job you liked.

This is the agent ecosystem eating its own tail in the most productive way possible, and it's happening quietly, in a subsection, on page five of a roadmap.

What actually matters here

Zoom out and the shape of this roadmap tells you where the agent world is going:

• The plumbing is consolidating on the web stack. HTTP, OAuth, webhooks. Your existing infrastructure knowledge transfers. The specialist-knowledge moat around "agent infrastructure" is draining.
• Agents become principals, not impersonators. Identity, delegation, proof-of-possession. The security model of the agent era is being designed right now, in public, by the OAuth people. That's unusually good news.
• Context stops being free-for-all. Progressive discovery means smaller prompts, better tool selection, cheaper agents. Especially local ones.
• The governance is real. SEP process, working groups, a contributor ladder, a deprecation policy that's actually been exercised. This is what a healthy protocol looks like two years in — boring, deliberate, and still shipping.

None of this will trend. There's no benchmark to screenshot. But if you're trying to figure out whether the agent ecosystem is a hype cycle or actual infrastructure, this roadmap is your answer: infrastructure doesn't announce. It maintains. The fact that MCP's big news is a series of deletions and an unglamorous identity scheme is the strongest signal yet that agents are graduating from demo to utility.

The exciting part of the agent era was always going to be the models. It turns out the durable part is the plumbing.

---

If you want to actually use this stuff instead of reading about it: CopperRiver is a desktop AI assistant that does the agent thing on your Mac — browsing, terminal, files, automation — running on open-source models like GLM, DeepSeek, and Qwen, with plans from $9/mo. It plugs into exactly this ecosystem, the boring-plumbing one that works. Give it a look.