For the better part of a decade, the question of where the world's code lives has had one dominant answer: GitHub. On June 16, 2026, at its Compile conference in San Francisco, Cursor announced it wants to change that. 

The product is called Origin, and Cursor describes it in five words: "a git forge for the agentic era."

The primary users of version control are about to stop being just humans, and you can join the waitlist.

What Is Origin

Origin is a git forge, code hosting, plus the review and collaboration layer that sits on top of a repository. In role, it's closer to GitHub or GitLab than to git itself. It's git-compatible, meaning it works with standard git clients and existing CI pipelines rather than forcing teams onto a new protocol, and it's extensible over both an API and the Model Context Protocol (MCP), so agents can drive it programmatically rather than only through a browser UI.

As of the announcement, Origin is waitlist-only, with general availability targeted for fall 2026. There's no published pricing, no full feature list, and no committed release date beyond that fall window. For now, it's a statement of intent backed by an on-stage demo.

The premise: git was built for humans, and that's apparently the problem

The argument underneath Origin is specific and worth stating plainly. Git, and GitHub on top of it, was designed around human cadence. A developer opens a branch, writes code for a few hours, opens a pull request, waits for a teammate to review it, and merges. The whole rhythm is measured in hours and days, which is fine, because a person can only type so fast.

That assumption breaks when AI agents become the primary contributors. A modern "AI software factory" runs many agents in parallel, each cloning the repository, branching, committing, rebasing against upstream, reviewing other agents' diffs, and triaging CI failures,  continuously, with no human typing in between. A single autonomous coding session can produce more branch operations in an hour than a mid-sized engineering team generates in a day. GitHub's data model, permission system, and event architecture were not built for that load, that authorship model, or that review paradigm.

The bottleneck, in other words, has moved. It's no longer writing code. It's coordinating, reviewing, and safely merging code that machines are generating faster than humans can keep up with, and that layer currently lives on infrastructure designed for a slower world.

The demo numbers

To make the ambition concrete, Cursor showed throughput figures on stage: 22.6 commits per second inside a single repository, global synchronization in under 400 milliseconds, and a configuration handling hundreds of thousands of clones and pushes per hour, with automatic failover via S3 backups.

These are impressive, and they're also Cursor's own announcement figures from a controlled demo. Independent, third-party verification at agent-scale load is still early, and Cursor has not published capacity benchmarks or details on how Origin guarantees concurrency under real-world conditions. Treat the numbers as a directional signal of what Origin is built for, not as audited performance.

What makes it different from GitHub, architecturally

Based on Cursor's framing and early reporting, three design choices set Origin apart from existing git hosts:

• Parallel-first merging. Origin assumes multiple agents are editing overlapping code at the same time and treats that as the default case rather than an edge case to be handled after the fact.
• Automated conflict resolution. When agents push conflicting branches across dozens of files, there's no time for a human to step in. Origin is described as folding AI-powered conflict resolution into the merge layer itself.
• Machine-readable review state. Review and merge state is designed to be readable and actionable by machines from the start,  exposed over API and MCP,  rather than presented only through a human-oriented UI of comment threads and notification digests.

That last point connects to the sharpest piece of community pushback. As one widely shared reaction to the announcement put it, a repository UI is the easy part; the hard part is review, merge, and conflict states that machines can actually reason about. GitHub can, and repeatedly does, ship AI code-review features on top of its existing model. The Origin thesis is that bolting agent features onto a human-era foundation isn't the same as rebuilding the foundation for agents, and that re-architecting a platform serving hundreds of millions of existing repositories is a harder problem than building a new one from scratch.

Why now: the Graphite acquisition and Cursor's bigger play

Origin didn't appear from nowhere. The engineering team behind it came from Graphite, the code-review startup Cursor acquired (announced December 2025), known for its "stacked pull request" workflow that lets developers manage multiple dependent changes in parallel. Graphite co-founder Tomas Reimers demoed Origin on stage.

That acquisition makes the strategy legible. Cursor is assembling a vertically integrated stack: you write code in the Cursor editor, run agents in parallel, review with Graphite-style stacked-PR workflows, and host and merge on Origin. The payoff is context continuity, the "intent" an agent encodes while writing can carry through into PRs and merges, instead of being severed the moment code is pushed to an external host. If it works, Cursor stops being "VS Code with AI" and becomes the control plane for the entire software development lifecycle: write, review, and host, with agents threading through all three.

The competitive and corporate backdrop

Two things make this more than a product launch.

First, it's the most credible pressure GitHub has faced at the infrastructure layer in years, and notably, not from GitLab or Bitbucket, but from a company that approached software development from an AI-first direction. There's also a governance angle. GitHub's ownership by Microsoft is a consideration for some enterprises, particularly in sectors where Microsoft is also a competitor, and Origin offers an alternative not entangled with the VS Code / Copilot / Azure ecosystem. GitHub isn't standing still. Microsoft has been embedding Copilot across GitHub's PR and issue workflows, and GitHub Actions remains a defensible position at the CI layer,  but its core data model carries a decade of human-paced assumptions.

Second, and impossible to separate from Origin's future, is who now owns Cursor. The Origin announcement landed alongside a much larger story: on June 16, 2026, SpaceX exercised an option to acquire Anysphere, Cursor's parent company, in an all-stock deal valued at roughly $60 billion,  widely described as the largest acquisition of a venture-backed startup on record. The deal, which stems from a compute-and-option agreement signed in April 2026, is expected to close in the third quarter of 2026, pending regulatory approval, and would make Cursor a wholly owned subsidiary of SpaceX, folding it into the xAI ecosystem SpaceX merged with earlier in the year. It came just days after SpaceX's record Nasdaq IPO.

In practical terms, the company building an agent-native GitHub competitor is about to be backed by one of the most heavily capitalized AI and compute operations in the world. That changes the resourcing question behind Origin's fall release considerably.

Should you care if you're not running agent swarms today?

If you're already running parallel AI agents and hitting GitHub's scaling limits, Origin is the most credible near-term alternative being built, worth joining the waitlist to evaluate when it ships.

If you're not, it's still worth understanding as a leading indicator. The infrastructure layer of software development has not been seriously contested since GitHub became dominant. The assumptions Origin makes about authorship, review, and collaboration are a clear signal of where the broader tooling stack is heading: toward a world that treats agents as first-class users rather than as features bolted onto tools built for people.

But the underlying bet is a serious one, and the question Origin forces the industry to sit with is genuinely new: what does git hosting look like when you design it, from scratch, for a world where humans are no longer the ones doing most of the committing?