Cursor's Origin Platform Launches Amid GitHub Outage

A new code host from a company known for its AI editor is, by itself, worth paying attention to. Cursor started rolling out Origin on Monday morning — a real code hosting and collaboration platform, going first to paid Cursor users. Three and a half hours later, GitHub's status page turned red for six hours and forty-two minutes. The two events are unrelated. The fact that they hit the same news cycle is the cleanest possible argument that the place your code lives is infrastructure, and infrastructure has outages.

This is genuinely good news for builders, and the practical version of "what do I do about it" is the rest of this post.

1. Origin is a real git host, not a sidebar

A lot of "code hosting" announcements from non-platform companies end up being a read-only mirror or a thin wrapper around someone else's host. Origin isn't that. Cursor shipped it as version control and collaboration with the surface area you'd expect — repos, pull requests, permissions — gated behind paid Cursor tiers.

What's interesting is that an AI editor vendor decided the workflow layer under the editor was worth owning. Not the model. Not the chat sidebar. The repo, the diff, the merge, the deploy hook. Cursor's bet is that the AI and the host are part of the same product surface, and that if you write code in their tool, you'll commit code in their tool too.

That's a meaningful bet, and it's the kind of move that puts real pressure on GitHub's editor integrations and pricing over the next year.

2. Six hours and forty-two minutes is a long time to be locked out

GitHub's own incident log, as reported on the day's events, reads like an inventory of everything a developer needs on a Monday:

• Pull requests, issues, and the API ran near 20% errors
• Archive and raw file downloads ran near 50% errors
• Enterprise single sign-on failed across SAML, OIDC, SCIM provisioning, and Team Sync
• Copilot was down for the duration

That's not one service failing. That's the whole loop. You can't merge. You can't open a PR. You can't curl a tarball out of a release without retrying. And the AI assist you'd normally fall back on during a manual recovery is itself hosted on the same provider that's failing.

Six hours and forty-two minutes is the kind of number that gets platform-risk meetings scheduled. It's also the kind of number that doesn't need to happen often to justify at least running the alternative in parallel for a week.

The SSO failure deserves its own callout. For enterprise teams, "the host is down" is annoying; "we can't even authenticate to the host" is a Monday-bleeding-into-Tuesday incident. SAML, OIDC, SCIM, Team Sync — all four failed. That's the worst single category in the whole log, because auth is the gate everything else sits behind.

3. The launch didn't cause the outage — but it changed what people noticed

The two events are not coordinated. Product launches get locked in weeks ahead, and nothing about Cursor's rollout suggests they were waiting for a status page to turn red. But a GitHub competitor shipping its own host on the same day GitHub buckled is the kind of accident that turns a quiet paid-user rollout into the most-watched code hosting news of the week.

Vercel's chief executive weighed in publicly. A Cursor employee posted a line that, per the reporting, "writes its own headline." The exact wording isn't in the piece I'm working from, so I won't pretend to quote it — but the pattern is familiar: when one provider stumbles, the competitor's launch gets an audience it didn't pay for.

The lesson is not "switch hosts." The lesson is "stop pretending you can't."

4. How to actually try Origin today

The rollout is gated behind Cursor's paid tiers. The article I'm working from doesn't list a public sign-up URL or pricing page, so the specifics below describe the shape of the workflow rather than a copy-paste recipe — Cursor will hand you the actual remote URL when you create a repo.

# 1. Confirm your Cursor editor is on a paid tier.
#    Origin ships behind paid Cursor plans, not the free tier.

# 2. Open Cursor's workspace and find the Origin entry point —
#    a new dashboard or sidebar item where repos live.

# 3. Create your first repo on Origin. Once Origin hands you the
#    remote URL, push from your local checkout:
git remote add origin <the-url-origin-gives-you>
git push -u origin main

# 4. If you want to run both for a quarter instead of migrating
#    cold, mirror your existing GitHub repo across:
git clone --bare git@github.com:your-org/your-repo.git
cd your-repo.git
git push --mirror <the-url-origin-gives-you>

A few practical notes:

• Treat the first week as dual-write, not migration. Push to both, open a few PRs on each, see how review, CI, and permissions actually behave under real load.
• The features Cursor highlighted in the rollout are version control and collaboration — table stakes for any host. The question worth answering yourself is whether the editor-to-host loop is genuinely tighter than the GitHub-Cursor loop today.
• If you're on an enterprise tier that pins to SAML SSO on GitHub, test your auth on Origin in a sandbox org before you trust any real workload to it. The worst moment of the GitHub outage was SSO failures; don't sign up for a single point of failure you didn't vet.

There are no public benchmarks on latency, reliability, or cost-to-host between Origin and GitHub yet. Cursor hasn't published numbers, and any specific figure I'd write here would be invented. That's the thing to actually watch over the next 90 days.

5. What's durable when the host under your code changes

Here's the part that doesn't move when Cursor ships Origin, when GitHub ships a new pricing tier, or when the next outage sends everyone shopping for backups: the UI your users touch. The component that renders on iOS, Android, and the web. The API your screens call. The visual contract you shipped in your last release.

A code host is one layer of a stack. So is an editor. So is a model provider. None of them are the layer your customers interact with. That's the component layer — and it's the one piece of the system whose design should not depend on where the commits live.

That's the part of the build OTF sits under. When your repo lives on GitHub today and Origin tomorrow — or both at once for a quarter while you decide — the same Button, Dialog, and Sheet on web and native doesn't need to know. One component, one API, web + iOS + Android, behavior and styling identical across all three. Swap the host underneath, the screen above doesn't flinch.

Convention beats configuration here. Pick the layer that's stable across vendor churn, push as much of your build into it as you can, and the next outage is a Monday-morning inconvenience instead of a Monday-afternoon rebuild.

6. What to watch in the next 90 days

A new host means new competitive pressure on pricing, on reliability SLAs, and on how tightly the editor and the host integrate. That's good for builders — every announcement that nudges GitHub on any of those axes is a tailwind for everyone shipping code.

Four things worth tracking:

1. Public reliability and latency numbers from Origin. Until Cursor publishes benchmarks, "is Origin as fast as GitHub" is unanswerable.
2. Pricing tiers and the free-vs-paid line. Whether Origin offers a meaningful free tier will determine whether it actually pulls developers off GitHub or only ever co-exists.
3. Editor-to-host integration. If the Cursor editor gets a noticeably tighter loop with Origin than with GitHub, that's the moment this stops being a feature and starts being a moat.
4. Whether other AI coding vendors ship their own hosts. If Origin gets traction, expect the next major AI tool to follow.

The durable part through all of it: the cross-platform UI layer that survives the swap. When Origin earns real adoption, or when the next host earns it after that, the work that doesn't have to change is the work that compounds. One codebase, web and native, the same component on every surface. Build that once, and the next outage is a Tuesday-morning story.