Cursor Origin: Git Forge for Agents

That’s the comparison everyone will make, because it’s the easiest one. It’s also the least useful one.

Origin, now in early beta for paid Cursor plans, is a git forge. You can create a repo, push with standard git, browse code, open and merge pull requests, and sync existing GitHub repos into it. On the surface, that is the same job GitHub and GitLab have been doing for years.

The actual question is narrower:

What happens when the people writing most of the code are no longer writing at human speed?

That’s the problem Origin is trying to own. The way to see it is not a repo list. It is the loop.

The loop is the product

Without Origin, the agent writes in Cursor and the forge lives somewhere else.

You ask an agent to fix a bug. It edits local files. You push to GitHub. You leave Cursor. You open the PR, wait for Actions, review in the browser. Then you come back to Cursor to ask for the next change.

With Origin, that middle website goes away.

You browse the repo in Codebase. You hit Cmd+I on the exact file. A cloud agent clones, branches, commits, and opens the PR on the same remote. You review the diff, the checks, and merge without leaving.

The agent writes either way. Origin is whether you have to leave to finish the job.

That is the claim. Origin is not extra storage. It is the remote the agent can treat as home. If this right-hand column does not get shorter in practice, none of the launch copy matters.

What you can actually do today

Cursor’s one-liner is “a git forge for the agentic era.” The useful description is: hosting and review next to the agents, instead of one hop away on GitHub.

In early beta:

• Create Origin-hosted repos (Origin is the source of truth)
• Mirror GitHub repos (GitHub stays the source of truth; Origin keeps a live copy)
• Clone, push, and pull with normal git
• Browse and search at cursor.com/codebase
• Open, review, comment on, and merge PRs
• Ask an agent about the file you’re browsing, have it change code, update a PR, or push a branch
• Connect Vercel, Depot, and Buildkite on Origin-hosted repos

Those bullets only matter if they collapse the six-step loop into four.

Why you would try it this week

Not to replace GitHub. To stop leaving the editor.

Sync. Ask on the file. Let the agent do git. Review in the same place.

1. 1Sync one repo. GitHub stays source of truth. You do not migrate production.
2. 2Ask on the file. Stand on the broken code. Cmd+I: fix this, open a PR.
3. 3Let the agent do the git work. Clone, branch, commit, open PR. You don’t babysit remotes.
4. 4Review and merge here. Activity, commits, checks, files changed. On a mirror, comments write back to GitHub in seconds.

Use it if your week already looks like “prompt → wait → open GitHub → comment → prompt again.” If you still write most of the code yourself and trust Actions as the CI, you can wait. The test is one non-critical repo, one agent PR, and whether the loop actually got shorter.

Same product. Two different bets.

The marketing says “Cursor can now host your code.” The honest product is two repo types. Pick the first one on purpose.

Start mirrored. Detach only if the loop actually got shorter.

Cursor did not ask teams to rip GitHub out on day one. They asked teams to put a live copy next to the agents. Detach later only if the right-hand loop earned it.

What GitHub and GitLab were never built for

The left column of Diagram 1 is not incompetence. It is the system GitHub was designed around:

a person writes a change, opens a PR, another person reads a diff, comments, merges. Hours and days. The UI, rate limits, merge queue, and review model all assume a human is the bottleneck.

Agents break that. One developer can spawn several agents that clone, branch, commit, rebase, open PRs, fail CI, and try again. Many writers, same repo, overlapping files, short-lived branches. The volume is not “a bit more commits.” It is a different shape of work.

Traditional forges strain in three places:

1. 1Write throughput. Tuned for a few human commits per hour, not many agents committing in parallel.
2. 2Review as a reading surface. A PR UI for one person staring at a diff does not scale to ten agent PRs before lunch.
3. 3A feedback loop that is too long. Agent writes → CI fails → human reads logs → human pokes the agent. That tax is steps 4, 5, and 6 on the left.

Graphite is the missing lineage. Cursor acquired it. Graphite’s product was review when changes arrive faster than a linear PR queue. Origin is that idea moved down one layer, into hosting.

The June demo numbers — 22.6 commits per second, sub-400ms global sync — are a statement of intent. They are not a benchmark you should take to a board yet.

Origin vs GitHub vs GitLab

A fair comparison is not “does it have Issues.” It is who the host is for.

GitHub’s PR surface is still the one most teams think in. Origin’s bet is that this surface should sit where the agent already is. GitHub remains the default. Origin makes “stay on GitHub forever” a choice.

What it’s filling — and what it is not

It closes the last hop in the Cursor stack: write, run, review, and now host. It treats agents as first-class writers, instead of bolting them onto a human forge. It gives you a mirror so you don’t have to migrate. It shortens verification, which is the actual cost of agent coding. And yes, it reduces a strategic dependency on a forge owned by the company that also sells the competing agent.

It is not a GitHub replacement today. Public repos, issues, and a full Actions replacement are not built. Permissions and branch protections are still being redesigned. For a mirrored repo, Issues, Actions, and secrets stay on GitHub.

It is not a social coding network. GitHub’s moat is the public graph — discovery, stars, resumes, “this is where the code lives.” Origin has none of that yet.

It is not GitLab. GitLab is the full DevOps suite. Origin is trying to be a home for Cursor agents.

It is not “Cursor now stores your files.” If you only needed a disk, S3 was enough. Origin matters only if review and the agent move with the bytes.

It is not proven at 4,000-developer monorepo scale. It is not free. Paid plans only, staged rollout, enterprise can opt out.

People will say it kills GitHub. It doesn’t. It makes the left-hand loop optional.

The only test that matters

GitHub / GitLab = a forge that AI tools connect to.

Origin = a forge that lives inside the AI tool.

That is vertical integration, not a feature launch.

Sync one non-critical repo. Run one agent PR through the right-hand loop. Keep GitHub as source of truth. Detach only if the loop got shorter.

If the agent era is real, hosting has to change. Not because git is broken — git still works — but because the coordination layer around git was built for a different animal.

Origin is Cursor saying: we will own that layer. Whether that becomes the default, or just a better sidecar for Cursor-heavy teams, is a six-month question. Reliability, permissions, CI, issues — and whether agents prefer a home they don’t have to ask GitHub’s permission to enter.

That’s the difference. Not another version-control site. A forge whose first user is not you.