Why
In March 2026 "MCP is dead" was a defensible position, and the reason it is worth revisiting is that the complaints were not wrong. Tool schemas were loaded into the context window before the user typed anything. The security model leaked in ways that had names and proofs of concept. And a protocol you could replace with a shell script did not look like infrastructure. Anthropic shipped Agent Skills, people noticed an agent with a terminal could do most of what MCP did more flexibly and for a fraction of the tokens, and the obituaries wrote themselves.
On 2026-07-28 the protocol answered by deleting things. initialize and the Mcp-Session-Id header are gone, so any request lands on any instance behind plain round-robin. Method and tool names travel as HTTP headers, so gateways and WAFs route without parsing a JSON body. Server-initiated elicitation, which needed a held-open stream, became a plain retry: the server answers input_required, the client comes back with the answer attached. Roots, Sampling, Logging, Dynamic Client Registration and the legacy HTTP+SSE transport were all deprecated under a formal twelve-month policy. The lead maintainer's own summary was that a lot of the things that made MCP are gone.
The evidence that it worked is structural rather than promotional, which is what makes it worth reading. Cloudflare retired its own McpAgent primitive — a differentiated product surface that existed only because MCP needed stateful hosting — on the grounds that servers now run as ordinary Workers. Vendors do not delete their own moat unless the standard genuinely got simpler. A Sentry co-founder who had published pieces saying MCP was not good yet reported going live on the new spec before it was finalised without breaking production. The March skeptics split the difference and were right to: a local CLI is still correct for local unauthenticated work, and MCP wins wherever you need auth, org access control, telemetry or scale — because at that point it is just HTTP, and every tool you already own for securing, observing and load-balancing HTTP applies unchanged.
And that is the sentence to keep, because it is a general one. The CLI argument was right that a shell is more powerful and wrong that more power was the point. What an agent needs at the boundary of someone else's system is not reach, it is a surface small enough to be reviewed, authorized, logged and rate-limited — and the reviewable surface is the product. The teams who made this work had already found it empirically and from the other end: GitHub cut Copilot's default toolset from 40 tools to 13 and success rates went up; Block is reported to have rebuilt its Linear server three times and finished at two tools. the-boundary-is-the-unit makes the same claim about architecture in general, and this is the cleanest natural experiment for it — a protocol that got adopted by removing capability, measured by people with no stake in the conclusion.
What the rewrite did not touch is the part that decides whether any of this is safe. The stateless redesign hardened the transport, and the transport was never where the interesting attack lived. Invariant Labs demonstrated tool poisoning in April 2025 — instructions hidden in a tool description, visible to the model and invisible to the user, exfiltrating SSH keys through a tool that added two numbers — and then showed a malicious GitHub issue steering an agent into leaking a private repository through a public pull request, noting that no MCP tool had been compromised. In April 2026 researchers hijacked Claude Code, Gemini CLI and GitHub Copilot by putting instructions in pull request titles and walked out with CI secrets. None of that is a transport bug and none of it is closed by a roadmap item.
The asymmetry is precise and worth stating in one line: a tool description is reviewed once, at connect time; a tool result enters the context on every call, at runtime, with no equivalent check. Registries, .well-known discovery and allowlists are all controls on the first one. There is no deployed control on the second, and the second is the one that carries attacker-authored text by construction. A firewall can block a connection. It cannot block a sentence. That is architectural, not incidental — which is why the honest reading of 2026 is neither the obituary nor the victory lap: the protocol became boring infrastructure, and the unsolved problem was never the protocol's to solve.
How it works
The three complaints, and which one the rewrite actually answered
| Wall | The March 2026 complaint | What 2026-07-28 did | Still open? |
|---|---|---|---|
| Context | Schemas load before the user types; raw responses round-trip through the model even when it needed three fields out of sixty | Cacheable, deterministically ordered tool catalogs, so clients cache and upstream prompt caches stay stable | Partly. Caching is not the same as fewer tools — the cut is still yours to make |
| Trust — connection | Session state, bespoke auth, local-only servers | Handshake and session deleted; plain HTTP with a familiar OAuth model | Closed, and this is the one OAuth quietly unlocked for enterprises with compliance teams |
| Trust — content | Descriptions and results enter the model's context as trusted text | Nothing | Open. Architectural. |
| Substance | Mostly wrappers around existing APIs; a large share abandoned | Nothing — this is a market fact, not a spec fact | Open, and no spec revision can close it |
What was deleted on 2026-07-28
| Before | After | |
|---|---|---|
| Session | initialize handshake + Mcp-Session-Id |
Every request self-contained — any request lands on any instance behind round-robin |
| Routing | Parse the JSON body to know what was called | Method and tool names as HTTP headers — gateways and WAFs route without parsing |
| Elicitation | Server-initiated, needing a held-open stream | Server returns input_required; the client retries with the answer attached |
| Catalogs | Re-fetched, order not guaranteed | Cacheable and deterministically ordered |
| Deprecated | Roots, Sampling, Logging, Dynamic Client Registration, legacy HTTP+SSE | Formal lifecycle policy, twelve-month minimum, removal no earlier than July 2027 |
Two entry points into the context. One of them is reviewed.
| Tool description | Tool result | |
|---|---|---|
| Enters the context | At connect time | On every call, at runtime |
| Reviewed by | A human, once — maybe | Nobody |
| Can change after review | Yes, the server controls it | Different every call by definition |
| Controls that exist today | Registries, .well-known metadata, pinning, allowlists |
None deployed |
| Who authors the text | The server operator | Whoever wrote the data the server read |
The last row is the whole problem. A pull request title, a GitHub issue body, a row in someone else's database — none of them are the server operator, and all of them reach the model as ordinary result text.
Reading the roadmap by confidence, not by date
| Confidence | Item | What it changes |
|---|---|---|
| Near-certain | .well-known server metadata for discovery |
Registries can learn what a server does without connecting — turns a directory of dubious entries into something rankable |
| Near-certain | Enterprise-Managed Authorization extension, now stable | Identity consolidates; adoption reported from Anthropic, Microsoft and Okta |
| Contested | Skill distribution — SEP-2640 would serve skills over MCP as ordinary resources | Today teams sync skills by hand-downloading text files, which is roughly hand-downloading HTML to run a web app. Whoever solves this owns a large piece of the agent stack |
| A bet, not a trend | WebMCP, Chrome origin trial through Chrome 156 | Near-zero real deployment and no mainstream agent calling the tools as of July |
| Unsolved, no item | Runtime checking of tool results | — |
Where this sits against the rest of the catalogue
mcp-three-sidesis the build card — three seats on the same protocol, and it should be done first because it is hands on keyboard. This one is the verdict card: why the deletion was the win, and what it left behind.agentic-intent-vetoandthird-party-blast-radiusare the two halves of the answer to the content gap — separate the reading capability from the acting capability, and assume the text you read is hostile.the-boundary-is-the-unitclaims the reviewable surface is the design unit; this is its natural experiment.agents-computer-useasks the same question one layer up — a shell is more powerful than a tool list, and that is exactly the property that makes it harder to secure.