Cursor Origin: Git Hosting Built for AI Agents

Origin is a place to store, review and merge code, the same job GitHub and GitLab do. Cursor built it, and the pitch is aimed at teams whose code is increasingly written by agents rather than typed by hand. Cursor's tagline calls Origin a git forge for the agent era, with one line of reasoning underneath it: "Code is moving faster than any infrastructure was built to handle."

You cannot sign up for it yet. The page at cursor.com/origin is a waitlist and a promise, "We'll reach out when Origin is ready for you," with no product screenshots, no pricing and no published feature list. That gap matters for a guide like this, so the rest of this page is careful about which claims come from Cursor and which come from coverage of the demo.

Reading a page like that is its own small skill. A waitlist with a tagline is not nothing, since it tells you what the company thinks the problem is, and nobody announces a git host casually. It is also not evidence that any particular feature exists. Holding both of those at once is most of what this guide is for, and the status tracker exists so you don't have to keep re-checking the page yourself.

The argument starts with a change Cursor already sells: agents that write code. Cursor's cloud agents run tasks on their own and open changes for review, and a team running several at once produces commits and branches faster than one person ever would. Hosting and review tools were designed around human pace, one engineer opening one pull request at a time.

Origin is Cursor's bet that the storage and review layer should be rebuilt for that faster pace instead of bolted onto tools made for it. Whether the bet pays off is an open question. The premise, that agent output is outgrowing GitHub-shaped workflows, is the same one behind Cursor's push into cloud agents, BugbotCursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs. Press Enter for the full definition. and automated review.

The case against deserves stating properly, because it is not a silly one. Pull requests and review have absorbed a lot of change over the years, and the argument made on Origin's launch thread is that the unit of work has not moved: a diff is still a diff, and a person still reads it. If that holds, the answer is better review tooling on the host you already have.

Which side you land on turns on a question you can answer locally: is your queue full of changes waiting for a person, or changes waiting for infrastructure?

I have not met many teams in the second group, which is less an argument against Origin than a reason to be precise about which problem you would be buying a solution to. The throughput page walks that diagnosis.

Origin is not a from-scratch side project. Cursor signed a definitive agreement to acquire Graphite, a code-review startup, on December 19, 2025, and the Graphite founders now build Origin from inside Cursor. Graphite's calling card was stacked pull requests, a review style built for shipping many small, dependent changes quickly.

Tomas Reimers, one of Graphite's three co-founders, demoed Origin on stage at Compile. That lineage is the clearest signal of what Origin is actually about: review throughput, not just somewhere to push a repo.

Lineage predicts priorities more reliably than it predicts quality. A team that came from review will build review-shaped things first, so the parts most likely to feel finished at launch are the ones you can already get from Graphite on GitHub today. The parts most likely to be rough are the host operations nobody demos: permissions and webhook delivery. When access arrives, I would spend the first hour on those rather than on the review features, which are the ones with a track record behind them.

Think of Cursor as assembling a stack that starts in the editor and ends at a merge. You write or direct code in Cursor, agents run tasks (locally or in the cloud), automated review runs on the result, and something hosts the repo and the pull requests. Origin is Cursor's answer for that last layer, the part GitHub holds for most teams today.

How tightly these layers connect inside Origin is mostly reported, not confirmed. BugbotCursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs. Press Enter for the full definition. and Auto-review are real Cursor features you can use today on GitHub and GitLab. What Origin adds on top of them is the part to verify when it ships.

The diagram flattens something worth putting back: the layers do not fail in proportion to their height. Losing the editor for an afternoon is an inconvenience, and losing the bottom layer stops everything, which is also why teams change vendors there last and most reluctantly. Origin is asking for the layer with the highest switching cost, and asking for it with no published terms behind the request.

This is the part to read slowly, because most of the exciting detail about Origin has not been confirmed by Cursor. The product page is a waitlist. The architecture numbers and the feature list come from press coverage of the demo, and some figures that circulated were later traced to other products entirely.

Each label in that second column means something specific, so here is what earns which. Confirmed means a Cursor or Graphite page says it. Strong means there is a shipping product behind the claim, which is why stacked diffs sit above everything that is only reported. Reported means an outlet described something shown on a stage, and the fair weight for that sits above rumour and a long way below documentation.

My instinct with a pre-launch product is to discount it until there are docs, and that turns out to be half right. Discounting is fine. Dismissing is not, because the team that ignores Origin entirely gets caught by the launch and ends up evaluating a git host under time pressure. Planning a quarter around reported features loses the quarter, so neither posture is free. What costs nothing is naming the one signal in advance that would change your mind, then ignoring coverage until it appears, and the launch signals are the obvious candidates.

Start with the why, then the mechanics. The guides below go deeper on the parts of Origin that have real precedent in Graphite and in Cursor's existing agent features, and they keep the same line between confirmed and reported.

The order matters more than it looks. Diagnosis first, because if review is not where your work piles up then none of the rest is urgent this quarter. The review model second, since stacks and bots are adoptable today and need no new host. Custody last, and only if the first two came back positive, because it is the one decision on the list that is hard to reverse.

• Agent-scale git explains the throughput problem Origin is built for, and why human-paced hosting strains under agents.
• Stacked diffs covers the review model Origin inherits from Graphite, with the gt workflow.
• Reviewing agent code is about reading diffs you didn't write, with BugbotCursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs. Press Enter for the full definition. and Auto-review as the gates you have today.
• Parallel agents and merge conflicts is the practical safety guide for running several agents on one repo.
• Migrating from GitHub and code custody weigh what moving your hosting to an AI vendor actually means.

Team size changes how sceptical to be, not what to read. Four people can try a new host on a Saturday and undo it on Sunday; four hundred cannot, so the same thin product page fairly earns a different answer from each of them.