The Agent Stack Is Rebuilding Itself — Cursor Origin and the Stateless MCP Rewrite in the Same Week

On August 17, 2026, GitHub began a global outage at 13:40 UTC. Pull requests, Issues, Actions, Webhooks, the API, Copilot — all degraded. The web and API error rate hit roughly 20%; archive and source-code download error rates neared 50%. More than 10,000 users reported the failure on Downdetector at peak (创业邦, Aug 18). Microsoft lost about 3% of its market cap the same day — roughly $112 billion erased on the news that one platform could cripple the world's software supply.

Three days earlier, SpaceX completed its $60 billion all-stock acquisition of Anysphere, the parent of Cursor (财经日日评, Aug 14). And on the morning of the outage, with engineers worldwide refreshing a broken GitHub status page, Cursor — newly christened "SpaceX AI" — opened early beta of Origin: a Git hosting platform built, in its own words, for the Agent era (丸美小沐, Aug 18).

The same week, the Model Context Protocol shipped its 2026-07-28 final specification, the largest single rewrite of the standard since Anthropic first published it (Cloudflare, "The next generation of MCP," Aug 6). MCP is now fully stateless. The initialize handshake, the Mcp-Session-Id header, sticky affinity — gone. A remote MCP server can run as a plain Cloudflare Worker, the same HTTP workload engineers already know how to deploy.

Two announcements, one week apart. Both look, at first glance, like a code-hosting launch and a protocol revision. They aren't. They are two layers of the same stack appearing on the same shop floor at the same time.

The agent era is not just changing who writes the code. It's rebuilding the substrate the code lives on.

What "agent-native" actually changes in a code forge

The pitch that GitHub's model is built around a human reviewer is older than most of the people reading this. It looks like this: one developer, one branch, one PR, one human reviewer, one merge. The unit of work is a person-day. The artifact is a clean diff for a person to read.

That model breaks when five agents are working the same repository in parallel, opening dozens of branches, each one stacked on the previous, each one producing machine-readable review state that another agent will consume. The unit of work stops being a person-day. It becomes a person-minute, and the human reviewer becomes the bottleneck — or, more often, the absent party.

Origin is the first product shipping a different unit of work.

Stacked pull requests, with a dependency graph

The first capability Origin ships is the stacked-PR model Cursor inherited when it acquired Graphite in December 2025. A stacked PR set is one logical change, decomposed into N dependent PRs that merge in order: PR #3 won't merge until #1 and #2 do, but each one is independently reviewable. The product surface for this is a dependency graph drawn on top of the PR list — nodes are PRs, edges are merge-order constraints.

This matters because agents naturally batch changes. An agent given a feature spec will edit fifty files at once. A human reviewer given a 50-file PR will refuse it. A stacked-PR system hands that agent the same change in five 10-file PRs, in a deterministic merge order, with a graph the human (or another agent) can navigate.

Merge queue with an AI conflict resolver

The second capability is harder. A merge queue is an old idea — pick a set of green-CI PRs, order them, re-run CI against each successive merge, abort and reorder if any step fails. GitHub has Merge Queue. So does GitLab. What Origin adds is an AI merge engine at the conflict-resolution layer: when two branches have touched overlapping regions across dozens of files, instead of failing the merge and pinging a human, Origin attempts the reconciliation in-process.

This is the move. The legacy model treats merge conflict as a human arbitration step. The agent-native model treats it as a deterministic transformation the merge queue should perform.

Machine-readable review state

The third piece is small and quietly structural. Origin's PR review surface exposes not just "LGTM" but a machine-readable JSON view of the review state — which checks have passed, which files have unresolved comments, which required approvals are still missing. An agent reading that JSON can decide whether to push more commits, request another reviewer, or merge itself. The review state is no longer for humans only. It is a contract for both consumers.

This is also why MCP support ships on day one: the same JSON can be fetched over MCP, which means another agent, on a different task, can read the state and act — without scraping HTML, no fragile DOM extraction, no brittle shell-out to GitHub's UI.

What "stateless" actually changes in a protocol

MCP had a reputation problem in 2025. Cloudflare's own retrospective calls it out: "The latest MCP 2026-07-28 specification was released last week, together with updated TypeScript, Python, Go, and C# SDKs. MCP is now a fully stateless protocol" (Cloudflare, "The next generation of MCP," Aug 6).

The original MCP had a stateful connection model. A client opens a session; the server returns an Mcp-Session-Id; every subsequent request has to land on the server instance that holds that session. To scale horizontally, you need sticky load balancing, shared session storage, or a gateway that parses the JSON body to route calls. Operators paid the bill for a protocol feature most interactions never used.

The new spec kills it:

• No more initialize handshake. No more Mcp-Session-Id header.
• Each request carries its own protocol version, client identity, and capabilities in _meta.
• A new server/discover method lets clients probe a server before calling it — optional, like OPTIONS in HTTP.
• Multi Round-Trip Requests (MRTR) replace the open-stream model for elicitations — when a tool needs confirmation ("approve this deployment?"), it returns input_required with the question; the client retries with the answer.
• New Mcp-Method and Mcp-Name HTTP headers mean gateways, rate limiters, and WAFs no longer have to parse JSON to apply per-tool policy.

Sentry's David Cramer, who has been a candid critic of earlier MCP, said it cleanly: "This new spec cleans up a bunch of the nonsense around auth and tools, which is exactly what I wanted. Agents only get useful once the plumbing stops being the whole story" (Cloudflare blog).

The pricing math is what made the change inevitable. A stateful MCP server on Durable Objects is a stateful workload — autoscaling preserves sessions, deployments have to drain them, losing an instance breaks clients. A stateless MCP server is a Worker. You can scale it on round-robin. You can deploy it with wrangler deploy. You can put a CDN in front of it. For most MCP servers, statelessness is what makes them cheap enough to leave running.

Cloudflare also published customer numbers that telegraph where the spend is going: their Code Mode MCP Server, an unofficial-stateless-mode deploy from February, "has scaled up to thousands of requests per second and served billions of tool calls." That is the operational shape of MCP at agent-era scale — billions of stateless calls, not hundreds of stateful sessions.

Why the two announcements are one announcement

Read them separately and they look like a code-hosting launch and a protocol cleanup. Read them together and the picture sharpens.

The old Git forge assumed a human reads a diff. The new MCP assumed the network was as stateful as the desktop. Both assumptions broke at the same point: when the producer and the consumer of an API call are both agents, running concurrently, at machine speed, in a fleet.

The agent-native forge has to expose review state as JSON, because MCP is the cheapest way to consume JSON. The stateless protocol has to be cheap enough to serve billions of calls, because the merge queue and the deploy pipeline both fire MCP events on every PR transition. Neither layer is useful without the other. A stateful MCP server in front of an agent-native forge would collapse under the merge-queue event rate. A stateless protocol in front of a human-PR forge would have nothing to do.

Origin is the first concrete piece of evidence that someone is building this stack end-to-end. The MCP 2026-07-28 spec is the substrate that makes the rest of the stack affordable to run. They shipped in the same week because they are the same product.

What this means for everyone else

Three concrete consequences for teams building on either side:

1. State has to leave the protocol and live in the tool. Stateless MCP moves session, basket, and idempotency state out of the transport layer and into handles — opaque tokens the tool returns and the model passes back. If you're running an MCP server today and rely on Mcp-Session-Id for auth or for in-flight work, you have a 12-month clock. The deprecation floor in the new spec is 12 months minimum; some features (Roots, Sampling, Logging, legacy HTTP+SSE, DCR) are already deprecated (Cloudflare blog).

2. Review state is now an API contract. If you ship a code review product and the review state isn't readable by an agent, you're shipping a UI, not a product. Origin's PR-as-JSON move will get copied. GitHub's PR-as-HTML model will start looking like a hostile choice for any team whose reviewer is a script.

3. The merge queue is the new bottleneck. Stacked PRs without a smart merge queue are just a different way to fail. Whoever runs the merge queue — and Origin has put AI in the conflict-resolution slot — controls the throughput of the whole stack. This is a real competitive surface, not a UX detail.

The bigger question is structural. If the agent-native stack rebuilds from forge to protocol, what does it do to the rest of the dev tools chain — IDEs, package registries, issue trackers, observability? Every layer that was built around the human-PR model is going to feel the same pressure. Cursor's move on code hosting is the canary. The rest of the chain is next.

The week the substrate changed

A $60 billion acquisition closed. A code forge launched against a 7-hour GitHub outage. A protocol that had been the standard for eighteen months threw out its foundational assumption.

These aren't three stories. They are one story told across three layers — capital, code substrate, and protocol — appearing in the same news cycle because the people building each layer finally saw the same shape. The agent era doesn't just change who writes the code. It rebuilds the floor the code lives on, the network the code talks through, and the review queue the code waits in.

The plumbing stops being the whole story when the plumbing finally gets out of the way.