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 can use it now, with conditions. Origin began rolling out in early beta on August 17, 2026 to paid plans (Pro, Teams and Enterprise, not Free), in stages, and enterprise admins can opt their org out. Cursor's changelog describes the first release as the essentials: repos, pull requests, code browsing and GitHub sync, with agent-native features to follow. That phrasing matters for a guide like this, so the rest of this page is careful about which claims come from Cursor's docs and which still come from coverage of the June demo.

Reading an early beta is its own small skill. Shipping docs tell you what exists today, and they are also the first honest list of what does not: no published price beyond inclusion in paid plans, no self-hosting, no importer for GitHub issues, and the review features the demo was built around still marked as coming. 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 docs 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, and the early beta complicated the prediction. A team that came from review was expected to build review-shaped things first, and instead the August 17 release shipped the host operations, repos, sync, pull requests, apps, with the review layer marked as coming. The parts most likely to be rough are still the ones nobody demos: the docs themselves say the permissions and protection controls are being redesigned. Once you have access, I would spend the first hour on those rather than on waiting for 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.

Some of the wiring between these layers is now documented. Cloud agents and Automations can run against Origin repos, clone, branch, push and open pull requests on them, and a local agent can create a repo through the Origin CLI. 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 remain Cursor features you use today on GitHub and GitLab; the agent-native review layer the demo showed is the part Cursor says ships soon.

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 from an early beta whose own docs say the permissions and protection controls are still being redesigned.

This is the part to read slowly, because the exciting detail about Origin and the shipped detail are not the same list. Cursor's docs confirm the hosting basics. The architecture numbers and the agent-native review features still come from press coverage of the June 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, and since August 17 that includes an Origin section in Cursor's docs. Strong means there is a shipping product behind the claim, which is why stacked diffs sit above everything that is only reported even though Origin's docs do not mention them yet. 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 product this new is to discount it until there are docs, and now there are docs, which changes the question rather than settling it. Discounting the demo claims is still fine. Dismissing the beta is not, because a team that ignores it gets caught by the agent-native release and ends up evaluating a git host under time pressure. Planning a quarter around features the changelog only promises loses the quarter, so neither posture is free. What costs nothing is naming the one signal in advance that would change your mind, and the status tracker lists 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 mirror a repo on a Saturday and detach it on Sunday; four hundred cannot, so the same early-beta docs fairly earn a different answer from each of them.