GitHub Broke for 7 Hours 47 Minutes. 4 Days Earlier, Its Replacement Sold for $60 Billion.

Four days, in order

Start with the sequence, because the sequence is the whole story. None of these events caused each other in a legal or mechanical sense, Cursor did not engineer an outage, and GitHub did not time its failure to Cursor's launch calendar. But all four sit inside one work week, and once you read GitHub's own numbers, the collision stops looking like bad luck and starts looking like the same underlying force showing up twice.

SpaceX's acquisition of Anysphere, the maker of Cursor, closed on August 14, 2026, in an all-stock transaction that issued roughly 391 million SpaceX Class A shares, by most reporting the largest startup acquisition on record. Two days after that, on August 16, Bloomberg confirmed a separate, unrelated deal: Stripe agreeing to pay more than $7 billion for OpenRouter. Put the two together and SpaceX paid 8.5x what Stripe paid, in the same week, for two different pieces of AI infrastructure. Then, on August 17 and 18, Cursor rolled out Origin, its own code-hosting platform, to paid users. And on August 17, in the middle of that rollout, GitHub went down.

Why Cursor was worth $60 billion in the first place

The acquisition price only makes sense next to the growth curve behind it. Cursor's annualized revenue went from $1 billion in November 2025 to $2 billion in February 2026 to $4 billion by June 2026, doubling every 3 months, 6 times in a row. SpaceX's $60 billion price tag works out to roughly 15x that trailing revenue, a multiple multiple investors have called one of the fastest ARR ramps software has ever recorded.

That growth is also, mechanically, agent-driven growth. Cursor's product is an AI coding environment: the more of a developer's actual commits flow through Cursor agents rather than manual edits, the faster that revenue line moves. The same force that made Cursor worth acquiring, AI agents doing an increasing share of the world's software commits, is the force that shows up again a few paragraphs down, on GitHub's side of the ledger.

What Origin actually shipped, and what it didn't

Four days after the acquisition closed, Cursor rolled out Origin: source-code hosting, pull requests, and code review, built directly into the Cursor editor, with bidirectional sync back to GitHub rather than a forced migration. It launched to paid users only, with 3 outside integrations at day one.

That scope matters for reading what comes next correctly. Origin is not, on day one, a GitHub replacement in the way a headline can make it sound. It's a narrow, deliberate product bet: give Cursor's own agents a git host built for agent-speed traffic, with an escape hatch back to the incumbent. Small, sober launches like this rarely make outages happen. They do, however, tell you what kind of traffic pattern the company building them expects to keep growing.

What actually broke, in GitHub's own words

GitHub published its own postmortem, “The August 17 Outage and the Work Ahead,” and it is specific rather than vague about what happened. The outage ran 7 hours and 47 minutes. At peak, GitHub reported roughly a 20% error rate across the web interface and API, and error rates near 50% on raw repository content and archive downloads. Pull requests, issues, authentication, GitHub Actions, and Copilot were all down or degraded for the better part of a workday.

# GitHub's own root-cause chain, condensed from the postmortem
1. traffic hit a new peak in GitHub's Central US datacenter
2. Istio sidecar proxies (inter-service traffic mediation) hit their
   processing limit
3. autoscaling triggered on the wrong signal; it never accounted for
   sidecar capacity, so it didn't scale the layer that was actually full
4. Copilot's client-side retry loop kept retrying through the failure,
   adding load during the exact window recovery needed load to drop
5. result: 7h47m to full restoration

That fourth line is worth sitting with on its own. An automated client, not a human furiously refreshing a tab, kept hammering a recovering system harder because it was built to retry on failure without a circuit breaker. As more of GitHub's traffic comes from agents and agent-driven tools rather than people clicking around, that failure mode, a machine retrying into an outage instead of backing off, becomes the default rather than the exception.

The number underneath all of it

GitHub's postmortem volunteers the number that explains why a single sidecar-capacity miss took down the whole platform. Monthly commit volume grew from 1.4 billion in April 2026 to 2.9 billion in August, a 107% increase in 4 months. GitHub had already added more than 3 million CPU cores and 120 petabytes of storage since April specifically to keep up. It still wasn't enough, because the growth wasn't the kind capacity planning is built around: steady, forecastable, human-paced. It was compounding, and a meaningful share of it is agents, not people.

A platform mid-migration when it happened

One more number from the same postmortem changes how surprising the outage should be. GitHub has been migrating infrastructure to Azure since earlier this year. In May 2026, Azure carried about 12% of GitHub's platform load. By August, that was 58%, and Azure was handling half of all Git operations. GitHub's traffic spike hit in the middle of its own infrastructure rebuild, not on a stable, fully-settled platform.

The turn: Origin is built for the load that just broke GitHub

Put the four numbers next to each other and the story stops being about one bad afternoon. Autonomous coding agents pushed GitHub's commit volume up 107% in 4 months. That growth broke an autoscaling assumption nobody had stress-tested against this new traffic shape. Days earlier, the company best positioned to sell developers an alternative to that strained system had just been bought for $60 billion, specifically because its own agent-driven usage was compounding at the same rate.

Origin does not remove that load. It is built to serve exactly the thing that just broke GitHub: coding agents committing faster than any scaling plan expects. What changes is where that load lives, and who owns the infrastructure underneath it. Instead of one incumbent with a public postmortem and a decade of operating history, the load moves toward a narrower set of companies, one of which also runs a satellite constellation, a rocket program, and a growing share of the compute other companies' agents depend on.

What would falsify this, and what's still uncertain

A few things keep this from being an airtight causal claim, and they're worth stating plainly. GitHub's outage and Cursor's Origin launch were not coordinated; there's no evidence either company timed its move around the other, and GitHub's own postmortem attributes the failure to internal capacity planning, not to any external competitor's launch. It's also possible the commit-growth number is Copilot-adjacent rather than purely agentic: some share of that 107% increase is ordinary developer growth, new signups, more repositories, more CI-triggered pushes, not exclusively autonomous agents running unattended. And Origin's day-one footprint, paid users only, 3 integrations, is genuinely small; treating it as an immediate GitHub-scale threat would overstate where the product is today.

What the falsification test doesn't change is the trend underneath both events. Whether this specific week was coincidence or not, GitHub's own numbers show commit-volume growth outpacing its capacity additions, and Cursor's own revenue numbers show the same category of usage compounding fast enough to justify a $60 billion acquisition. Those two facts don't need a coordinated timeline to both be true, and both point the same direction: more of the write traffic hitting developer infrastructure is agentic, and it's growing faster than the infrastructure built for human-paced commits was designed to absorb.

What this means if your own agents depend on someone else's uptime

The practical lesson isn't “GitHub is unreliable” or “switch to Origin.” It's that every layer your agents depend on, git hosting, CI, model inference, is now absorbing agent-driven traffic that grows faster than most capacity plans expect, and a single scaling assumption anywhere in that stack can take your agents down for the better part of a workday. A simple version of the question GitHub's postmortem forces onto every team building with agents: what happens to your pipeline when one dependency, not even your own code, has a bad 8 hours?

# a minimal version of the question worth asking about any single
# dependency your agents can't work around
$ for remote in "github" "origin"; do
    echo "checking $remote..."
    # replace with a real reachability/latency check against your
    # actual git remotes, CI provider, or model endpoint
  done
checking github...
checking origin...
# if the answer is "we have exactly one remote and no fallback,"
# that's the same single point of failure GitHub's postmortem describes,
# just one layer down in your own stack

The same logic applies one layer down, at the model layer your agents actually call. MegaBrainroutes to 500+ models through one API at zero markup, so a single provider's bad week, an outage, a price change, a quiet quality regression, isn't a single point of failure for whatever you're building. And for agents that need to keep running through exactly the kind of disruption this week produced, a headline-grabbing acquisition, a major platform outage, a sudden shift in whose infrastructure you're depending on, mhermes, MegaBrain's always-on agent runtime, keeps working on its own schedule, on its own isolated VM, rather than pausing until the news settles.

Sign up at getmegabrain.com to route around any single provider's bad day, or spin up a mhermes agent to keep building while the rest of the industry works out who owns the pipes.