GitHub Stacked PRs vs Graphite vs Cursor Origin (2026)

Stacked pull requests went from a niche workflow to a three-way race in under a year. Graphite sold stacking as a product, Cursor acquired Graphite in December 2025 and set the team building Origin, and in April 2026 GitHub answered with a native Stacked PRs preview of its own. The core idea is identical everywhere. What differs is who can actually use each one today, what it costs, and how much you commit to by adopting it.

The three columns carry three different kinds of evidence. Graphite's comes from a shipping product with prices on a public page. GitHub's comes from a preview page and a roadmap entry, both describing intent. Origin's reads "Not published" in four of its six cells, which is a gap rather than a zero: from outside you cannot tell whether the thing exists and is undocumented, or does not exist.

The instinct with a table like this is to rank the columns by what they claim. Do that and GitHub's preview finishes ahead on mechanics it will not run until someone switches it on for your repository. Rank by access instead.

GitHub's Stacked PRs entered private preview in mid-April 2026, per coverage in InfoQ and The Register. GitHub's own preview page says plainly that the feature stays off until GitHub enables it for your repository, behind a waitlist. Once it is on, the mechanics are the interesting part, because GitHub built stacks into the pull request model itself rather than bolting a tool on top.

• Each PR in the stack targets the branch of the PR below it, forming an ordered chain that lands on your default branch.
• The pull request view shows a stack map, so reviewers can move between layers without losing their place.
• CI runs for every PR as if it targeted the final branch, and branch protection is enforced against that final target, not just the direct base.
• Merging the top PR merges every unmerged PR below it in one atomic operation. Merging part of a stack automatically rebases what remains.

Tooling is optional. GitHub ships a stack CLI as the gh-stack extension, with gs commands (gs init starts a stack, gs add creates a new layer, gs submit opens the pull requests) that handle branching, cascading rebases and PR creation. Stacks can also be built straight through the UI or API. The launch coverage circulated one number worth keeping: an analysis of 1.5 million pull requests found PRs between 200 and 400 lines carried 40% fewer defects and were approved roughly three times faster than larger ones.

That statistic is weaker evidence for any of these three products than it first looks, because what it measures is pull request size. None of the three is what makes a pull request small. A team that already splits a feature into four branches by hand and opens them in order gets the same short reviews without paying anyone, then does the rebasing itself every time something low in the chain moves. The rebasing is what you are buying here, along with the ordered merge.

The protection line in that list is the one I would put in front of a security reviewer before anything else. GitHub enforces branch protection against the final target branch, and its preview page names no protection setting you have to switch off. Graphite's stacks ride GitHub's ordinary checks, and Graphite's docs ask you to relax two of them. Check which of those settings your change-management policy names before you compare the CLIs.

Cursor announced a definitive agreement to acquire Graphite on December 19, 2025, and Graphite has kept operating as an independent product since. Its own announcement promised tighter integration with Cursor through 2026 rather than a wind-down. Practically, Graphite remains what it was: the most mature stacking workflow you can adopt today, run through the gt CLI against a normal GitHub repo.

Four commands carry most of the workflow, and they map onto how you would build a feature in dependent pieces.

Pricing is per user. The free Hobby tier covers personal repos, the CLI, the VS Code extension and limited AI reviews. Starter at $20 per user per month adds organization repos and Slack notifications. Team at $40 adds unlimited AI reviews, automations and the merge queue, and Enterprise adds SAMLSecurity Assertion Markup Language. The XML-era enterprise standard that powers single sign-on: your identity provider vouches for you to each app. Older than OIDC but still what many enterprise tools speak. Press Enter for the full definition., audit logging and GHES support at custom pricing. All paid figures are annual billing, per graphite.com/pricing.

The free tier is not the small-team tier, which catches people out. Hobby covers personal repos, so the moment your stack lives in an organization repository you are on Starter at $20 per user per month, and Starter does not include the merge queue. Whether the $40 tier pays for itself has less to do with headcount than with how many changes you keep open at once. The same number decides whether a merge queue is worth the latency it adds.

If SAMLSecurity Assertion Markup Language. The XML-era enterprise standard that powers single sign-on: your identity provider vouches for you to each app. Older than OIDC but still what many enterprise tools speak. Press Enter for the full definition. and audit logging are non-negotiable for you, the tier is Enterprise and the price is a conversation.

Origin is Cursor's own git hosting platform, announced June 16, 2026 at the Compile event, demoed by Graphite co-founder Tomas Reimers, and in early beta on paid plans since August 17, 2026. It is built inside Cursor by the Graphite team, and that lineage is still nearly all we can say about its stacking, because the beta's pull-request docs describe ordinary pull requests with reviewers, line comments and a manual merge, and say nothing about stacks. Cursor's changelog pitches the beta as the essentials and says agent-native features ship soon.

Inherited stacking, then, means this: the team building Origin shipped stacked review in production for years at Graphite, so stacked diffs are the single strongest expectation about how Origin's review works. The stacked diffs guide covers that model in detail, and the Graphite acquisition explains how the team got there. Both of those pages are about Graphite.

The question I would want answered on day one is whether stacks are native to Origin's pull request model or a layer on top of it, the way gt sits on top of GitHub. It sounds like a detail and it sets how reversible the adoption is. A layer comes off cheaply. A review model built into the host is one more thing to unpick if you move back, on top of the pull requests and review threads that no git push carries with it.

The beta docs do not answer it.

Not permanently, and not for all three. Graphite and GitHub's native stacks both operate on ordinary GitHub repositories, so adopting gt now does not rule out the preview later, though nothing published says the two run together on one repo. Origin is the hard one to reverse, since it replaces the host rather than sitting on one.

The sequencing that falls out of that is not the one most teams pick. The common move is to wait, on the reasoning that GitHub announced a native version and paying for something you will get free later feels wasteful. A year of that is a year of reviewing the pull requests you wanted to shrink, and the roadmap entry marks every date as subject to change.

Set a calendar reminder to re-check the preview, and count what the wait costs you in the meantime.

No clean sweep exists here. Each option wins a real case and loses another, so the honest way to choose is by constraint: what you can access, what you can spend, and how much vendor commitment you can tolerate.

Team size changes which column you should be reading at all. Five engineers on a shared repository are choosing between a $20 seat and the workflow they already have, and the preview and Origin are both noise at that scale. Three hundred engineers are choosing between a vendor their security team has to review and a native feature it already covers. That conversation runs slower and often lands somewhere else.

Lock-in runs in a clear order. GitHub's native stacks add nothing beyond GitHub itself. Graphite adds a layer you can drop, since your pull requests remain plain GitHub PRs underneath. Origin replaces the host, which is the biggest commitment a team can make in this category. Adopt in that order of caution, and if you want the fuller custody argument, the Origin vs GitHub comparison walks through it.

If a stacking trial stalls, the first thing I would check is whether review was ever the bottleneck. Stacking shortens the time a change waits for a human. A slow test suite and a merge that keeps racing other merges both get reported as "the stack is confusing," and both have their own fixes. Time a week of changes from opened to first review, before and after. If that number has not moved, look at CI and merge time next.