On the morning of August 17, Cursor began rolling out Origin — its own code-hosting platform, complete with repositories, pull requests, and CI integrations. Roughly three and a half hours later, GitHub's status page lit up. What followed was a six-hour-and-forty-two-minute global degradation: error rates near 20% across pull requests, issues, and the API, near 50% on archive and raw file downloads, enterprise SSO fully down, and Copilot dead along with everything else.
The timing was an accident — Cursor's own Matt Palmer admitted the launch was actually delayed by the outage: "We were going to ship this earlier, but GitHub was down." A GitHub outage postponed the launch of a GitHub competitor. But the coincidence dramatized the argument Origin exists to make, and that argument is bigger than an uptime pissing match.
Most coverage framed Origin as "Cursor takes on GitHub." That's the wrong frame. The real story is this: writing code stopped being the constraint, and the forge — the layer where code is stored, reviewed, and merged — became the bottleneck of the entire agent pipeline. When 35% of the pull requests in your tool are opened by agents, the forge isn't developer tooling anymore. It's part of the harness.
The Number That Explains Origin
Cursor has said that 35% of pull requests merged inside its product are opened by agents running autonomously on cloud virtual machines. That figure was reported back in February and the trend has only gone one direction since. SemiAnalysis estimated in March that Claude Code alone accounts for roughly 4% of all public GitHub commits, with projections toward 20% by year-end.
Think about what that means for the receiving end. GitHub's own Octoverse 2025 counted 180 million developers, 630 million repositories, and 43.2 million pull requests merged per month — already up 23% year over year before the agent volume started compounding. Agents don't just add commits; they add pull requests, CI runs, review comments, and merge operations at a cadence no human team ever produced. A single developer supervising four parallel agents can generate more PR traffic in an afternoon than a mid-2000s open source project saw in a year.
Here's the asymmetry nobody priced in: agent write throughput scales with compute, which is elastic. Human review throughput scales with headcount, which is not. Every agent-first team hits the same wall — the merge queue. The forge is where agent output goes to die in a queue behind human attention.
That's the bottleneck Origin is attacking. Cursor's changelog puts it in one line: "Your code, PRs, and agents are now in the same place." A developer can hand an agent a review comment and have it revise the pull request in place, or push a branch, without leaving the surface where the code lives. The forge and the agent stop being separate systems with a human clipboard between them.
GitHub Earned This Fight
It's tempting to read Origin as pure opportunism against a struggling incumbent, and there's some truth to that. GitHub's reliability record over the past fifteen months is genuinely bad:
- An analysis by LeadDev counted 257 incidents between May 2025 and April 2026, 48 of them major — roughly one significant disruption per week. February 2026 was the worst month on record with 37.
- GitHub Actions alone accounted for 57 outages in twelve months. Actions is precisely the layer agents hammer hardest.
- GitHub's own CTO Vlad Fedorov has said the platform "wasn't built for the scale it's now being asked to handle" and must be redesigned for 30 times today's load. An April engineering post acknowledged the company "failed to meet its own reliability standards," citing rapid growth, tight architectural coupling, and inadequate load shedding.
- Monday's outage was the seventh incident on GitHub's status page in fifteen days.
The exodus started before Origin existed. HashiCorp's iceberg left GitHub in November 2025, citing Actions failures. In April, Mitchell Hashimoto announced Ghostty — a terminal emulator with over 52,000 stars — would leave too, pointing to near-daily outages blocking reviews and CI for hours. The Information reported in March that OpenAI, a company Microsoft holds a large stake in, began building its own GitHub alternative partly because outages left its engineers unable to commit for hours at a time.
And the organizational signals are bleak. Thomas Dohmke resigned as GitHub CEO in August 2025 and was never replaced; the unit was absorbed into Microsoft's CoreAI organization under Jay Parikh, who reportedly warned deputies that coding tools from Cursor and Anthropic could eventually make GitHub obsolete. Dohmke himself has moved on to Entire, a distributed Git network that raised a $60 million seed in February — with Microsoft's venture arm among the investors — and went to market in July.
When the former CEO of the incumbent raises money for a competitor and the incumbent's parent invests in it, the market is telling you something. GitHub's answer, Agent HQ — orchestrate third-party agents from Anthropic, OpenAI, Google, Cognition, and xAI inside GitHub — is a coherent strategy, but it concedes the agent layer to keep the substrate underneath. Origin attacks precisely that substrate.
What "Agent-Native Forge" Actually Means
Strip the launch hype and here's what Origin shipped: a Codebase tab inside Cursor, git repos you push to from the command line, pull requests with timelines, diffs, checks, and merges, and day-one integrations with Vercel (preview deployments per PR), Depot and Buildkite (CI — and both run your existing GitHub Actions workflows unchanged). It's in early beta on all paid plans. Notably, it's default-on for paid users except enterprise orgs whose admins opt out — a sentence administrators should read twice.
Cursor's Tomas Reimers was refreshingly honest about the differentiation: asked what sets Origin apart beyond uptime, he said "very little" — "We're intentionally releasing this as a GitHub alternative where we meet them toe-to-toe on functionality." The agent-native features — tooling that makes sense of agent-written code, automation that pushes PRs toward a mergeable state on their own — are explicitly "coming in the coming weeks."
So why does a toe-to-toe GitHub clone matter? Because of the integration direction. In the GitHub model, the agent is a guest: it authenticates over an API, opens PRs through a web abstraction, and reads review feedback through webhooks and notifications designed for humans. In the Origin model, the agent is a native resident: the review comment, the PR, the CI result, and the agent that can act on all three live in the same event loop.
This is the same structural move that played out at every other layer of the stack. The IDE treated the agent as an extension guest; the terminal gave the agent resident status — the same access the developer has — and won. MCP treated tools as external RPC calls; Agent Skills moved the instructions inside the context. Each time, the layer that absorbed the agent beat the layer that merely hosted it. The forge is the last major layer left, and Cursor just made its move.
The Contrarian Read: This Isn't About Uptime
Most people think Origin is a bet on GitHub being flaky. If GitHub fixes its reliability — and Microsoft is spending real money trying — the argument for Origin collapses, goes this reasoning.
I think that's wrong, and the evidence is in GitHub's own numbers. Even a perfectly reliable GitHub is still a human-paced forge. Its unit of account is the pull request a person reviews, the notification a person reads, the merge button a person clicks. Reliability is table stakes. The structural question is whether the forge's primitives — review, merge, checks, permissions — are designed for a party that never sleeps.
Consider what an agent-native forge could do that a human-native one can't cheaply express:
- Merge contracts instead of merge buttons. A PR from an agent doesn't need a human to click merge; it needs a machine-checkable contract — tests green, review passed, no conflicts, budget under limit. Auto-merge exists on GitHub as an opt-in feature. In an agent-native forge it's the primary path, with human review as the escalation, not the default.
- Provenance as a first-class field. Which model wrote this diff? Which harness? What did the verification loop actually run? GitHub shows you a username. An agent-native forge can show you the whole causal chain — which is rapidly becoming a compliance requirement, not a nice-to-have.
- Review load balancing. When agents open a third of PRs, routing those PRs to other agents for first-pass review — with humans sampled in for audit — is a forge-level function. It can't be bolted onto a notification system built for humans.
None of that is shipped yet. Origin today is repos, PRs, and sync. But the roadmap Reimers describes — "automation that pushes pull requests toward a mergeable state on their own" — points exactly at merge contracts and agent-mediated review. The boring beta is the trojan horse.
The Sync Trap and the Exit Question
Now the skeptical part, because there are real problems here.
First, the sync design is a one-way ratchet in disguise. Origin doesn't ask you to leave GitHub: connect an org, pick repos, and they sync in both directions, with GitHub remaining "the source of truth for anything started there." This is genuinely smart adoption mechanics — near-zero switching cost, walk away anytime. But the properties that make adoption safe are the ones most likely to erode. Today Origin runs your Actions workflows unchanged and mirrors GitHub faithfully. Once teams start creating repos natively in Origin — and Cursor will make that path increasingly frictionless — GitHub stops being the source of truth for anything new. Each agent-native feature will work a little better on Origin-native repos than synced ones. That's not deception; it's gravity. Ask what egress looks like now, while the mirror is still a mirror.
Second, the paperwork doesn't exist. Origin's pricing, security architecture, data retention, residency, training use, and subprocessor terms are unpublished. It's default-on for paid plans. And Cursor — now a fully owned SpaceX subsidiary after the $60 billion acquisition closed on August 14, making Origin the first product shipped under that ownership — answers to a rocket company, not a developer tools company. The defensible posture today is to treat Origin as a convenience layer over GitHub rather than a system of record. Conveniently, that's exactly what its current architecture is. Just don't confuse what it is with what it's becoming.
Third, concentration risk cuts both ways. The thing developers are fleeing GitHub over — one company's infrastructure being a single point of failure for the world's code — is the thing Origin recreates with a younger operator. 180 million developers won't move, and enterprises that spent years standardizing on GitHub won't rip it out for a beta. But Entire, OpenAI's internal alternative, and Origin all appearing within months of each other means the assumption that source control is a solved, boring problem is dead. When three credible competitors enter a market that has had none for a decade, the incumbent's pricing, roadmap, and reliability all get renegotiated — whether or not anyone migrates.
What This Means for Your Infrastructure
If you're building agent infrastructure, the forge's absorption into the harness has concrete implications:
Your merge queue is now part of your agent architecture. Measure it. What fraction of your PRs are agent-opened? What's the median time from PR-open to merge for agent work versus human work? If the agent share is above 20% and the review latency is measured in hours, your constraint is the forge, not the model — and no model upgrade will fix it.
Put provenance in your PRs now. Regardless of host, start stamping agent-opened PRs with model, harness, and verification metadata — in the PR body, in check runs, anywhere machine-readable. When forge-level provenance arrives, you'll have historical data. When auditors ask, you'll have answers.
Make branch protection machine-legible. The teams that benefit first from agent-native forges will be the ones whose merge requirements are already expressed as machine-checkable contracts — required checks, status gates, auto-merge rules — rather than tribal convention. That's a refactor you can do entirely inside GitHub this week.
Don't migrate; evaluate. Sync a non-critical repo into Origin, run one agent workflow against it, and measure whether the same-surface review loop actually shortens cycle time. The sync mode is a free experiment with a clean exit. Take it. Just remember it's an experiment with a vendor whose incentive is to make the exit progressively harder.
What to Do This Week
- Sync one non-critical repo into Origin and run one agent workflow against it — open a PR, have the agent respond to a review comment in place, merge. Measure wall-clock time against your normal GitHub loop. The sync mode costs nothing and exits clean.
- Pull your agent PR percentage. Query your forge API for PRs opened by bot credentials over the last 90 days. Below 10%, ignore this post. Above 25%, the merge queue — not the model — is your constraint, and it belongs in your infrastructure roadmap.
- Turn three tribal merge rules into branch protections. Take the conventions reviewers enforce manually ("tests must pass," "one approval," "no force-push to main") and encode them as required checks and rulesets. Machine-legible merge requirements are the prerequisite for every agent-native forge feature shipping next year — on any host.
The Pattern, One Layer Deeper
Watch what's happened to the stack over the past two years. First the value moved from the model to the harness — benchmarks converged, and the scaffold became the differentiator. Then the harness became infrastructure — open-sourced, standardized, commoditized, a shift that's been accelerating all summer. Each time a layer commoditized, the value migrated one layer down or one layer out: to the runtime, to the package format, to the protocol.
The forge is the last major layer where a single incumbent has held unchallenged, uncontested ground for eighteen years. That run ended this week — not because Cursor shipped repos and pull requests, and not because GitHub had an outage. It ended because a third of the code arriving at the forge's front door stopped being written by people, and everything about how a forge works — its review model, its merge semantics, its reliability budget — is now designed for the wrong customer.
The terminal ate the IDE because the terminal is where agents can actually be agents. The forge is next, for the same reason: the forge is where agent output has to survive contact with the rest of the system. The bottleneck always ends up owning the roadmap. This month, the bottleneck got its first real competitor.
How the storage, review, and merge layer fits into agent-first architecture — and why every layer of the harness eventually becomes infrastructure — is covered in depth in Harness Engineering: The Complete Guide to Agent-First Software Development.