Comparison
GitHub Stacked PRs vs Graphite vs Cursor Origin (2026)
All three run the same idea: small, dependent pull requests reviewed in order. Graphite's gt CLI is the only one you can adopt today without a waitlist. GitHub's native Stacked PRs entered private preview in April 2026. Cursor Origin, built by the Graphite team, is waitlist-only with nothing published on pricing or features.
On this page
GitHub Stacked PRs vs Graphite vs Origin at a glance
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.
- Availability
- GitHub Stacked PRs
- Private preview since April 2026; waitlist, per-repo enablement
- Graphite
- Shipping now; free Hobby tier
- Cursor Origin
- Waitlist-only, pre-launch
- Review model
- GitHub Stacked PRs
- Native stacks: each PR targets the branch below it
- Graphite
- Stacked PRs via the gt CLI, layered on GitHub
- Cursor Origin
- Not published; stacked review expected from the Graphite lineage
- Merge + queue
- GitHub Stacked PRs
- All or part of a stack merges atomically; partial merges auto-rebase the rest
- Graphite
- gt merge, plus a stack-aware merge queue on the Team plan
- Cursor Origin
- Not published
- CI + protections
- GitHub Stacked PRs
- CI and branch protection run against the final target branch
- Graphite
- Rides GitHub's own checks; gt restack keeps the chain rebased
- Cursor Origin
- Not published
- Pricing
- GitHub Stacked PRs
- No stack-specific price; roadmap targets Team and Enterprise plans
- Graphite
- Free Hobby; $20 Starter; $40 Team per user/month (annual)
- Cursor Origin
- Not published
- Lock-in
- GitHub Stacked PRs
- None beyond GitHub itself
- Graphite
- A droppable layer; your PRs stay plain GitHub PRs
- Cursor Origin
- A new host entirely; repo custody moves to Cursor
| GitHub Stacked PRs | Graphite | Cursor Origin | |
|---|---|---|---|
| Availability | Private preview since April 2026; waitlist, per-repo enablement | Shipping now; free Hobby tier | Waitlist-only, pre-launch |
| Review model | Native stacks: each PR targets the branch below it | Stacked PRs via the gt CLI, layered on GitHub | Not published; stacked review expected from the Graphite lineage |
| Merge + queue | All or part of a stack merges atomically; partial merges auto-rebase the rest | gt merge, plus a stack-aware merge queue on the Team plan | Not published |
| CI + protections | CI and branch protection run against the final target branch | Rides GitHub's own checks; gt restack keeps the chain rebased | Not published |
| Pricing | No stack-specific price; roadmap targets Team and Enterprise plans | Free Hobby; $20 Starter; $40 Team per user/month (annual) | Not published |
| Lock-in | None beyond GitHub itself | A droppable layer; your PRs stay plain GitHub PRs | A new host entirely; repo custody moves to Cursor |
As of July 2026. GitHub's feature is preview-gated and Origin's column is mostly unpublished; verify each vendor's page before you decide.
This is covered hands-on in Cursor First Hour — 4 short modules, free to read.
What did GitHub actually ship with Stacked PRs?
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, which is the whole case for stacking in two statistics.
GitHub's public roadmap entry for pull request stacks lists Team and Enterprise as the target plans and marks all dates as subject to change. Until the feature is switched on for your organization, it does not work at all, so don't rebuild your team's review workflow around it yet.
Where does Graphite stand after the Cursor acquisition?
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.
- gt create
- New branch stacked on the current one, committing staged changes. An --ai flag can name the branch and write the commit message.
- gt submit
- Force-pushes every branch in the stack and opens or updates one pull request per branch.
- gt restack
- Rebases dependent branches so each keeps its parent in its history after you change something lower in the stack.
- gt sync
- Syncs with remote, offers to delete branches for merged PRs, and restacks whatever it can without conflicts.
Per Graphite's command reference (graphite.com/docs/command-reference), checked July 2026.
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 SAMLAn enterprise standard that powers single sign-on. Press Enter for the full definition., audit logging and GHES support at custom pricing. All paid figures are annual billing, per graphite.com/pricing.
Graphite runs on top of GitHub, and Graphite's owner is building a GitHub competitor. Nothing published says Graphite winds down, and the product keeps shipping, but if you are making a multi-year tooling bet, price in that its roadmap now serves Cursor's larger plan for Origin.
What stacking model does Cursor Origin inherit?
Origin is Cursor's own git hosting platform, announced June 16, 2026 at the Compile event and demoed by Graphite co-founder Tomas Reimers. It is built inside Cursor by the Graphite team, and that lineage is nearly all we can say about its review layer, because cursor.com/origin is a waitlist page: no feature list, no pricing, no release date. Cursor's tagline pitches it as a git forge for the agent era, and the page stops there.
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. Expectation is the right word for both.
Cursor has published no review model, no pricing and no security terms for Origin. Third-party coverage has floated a fall 2026 window; Cursor itself has published no date. Read Origin's column in the table above as intent, and re-check cursor.com/origin before treating any of it as shipped.
Which stacking workflow should you pick?
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.
You're on GitHub Team or Enterprise and can get into the preview.
You want stacking with zero extra vendors, native branch protection and atomic stack merges.
Trade: waitlist now, and the newest, least proven implementation of the three.
You want stacks in production this week, with years of tooling maturity behind gt.
You'll pay per user for the merge queue and AI review on top of GitHub.
Trade: subscription cost, plus the question of what Cursor's ownership means long-term.
Your diffs increasingly come from Cursor agents and you'd consider moving hosts for a review layer built around them.
You can wait, and trial a pre-launch product on a non-critical repo first.
Trade: everything about it is unpublished, and custody moves to Cursor.
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.
Frequently asked questions
Can I use GitHub's native stacked pull requests today?
Only if you're in the private preview. The feature entered preview in April 2026 behind a waitlist, and GitHub's preview page is explicit that it stays off until enabled for your repository. Sign up, but plan your current workflow around tools that ship today.
Do I still need Graphite now that GitHub has stacked PRs?
If you want stacking now, yes: Graphite is generally available while GitHub's version is preview-gated. When GitHub's feature reaches GA, the calculus changes, since native stacks with no extra vendor will suit many teams. Graphite's counterweights are maturity, the merge queue and its AI review layer.
Will Cursor Origin support stacked diffs?
Cursor hasn't published Origin's review model, so nothing is confirmed. The strong expectation comes from the team: Origin is built by the Graphite crew whose signature product was stacked pull requests. Verify on cursor.com/origin when it opens rather than planning around the assumption.
Do stacked PRs work with branch protection and CI?
In GitHub's native implementation, yes by design: CI runs for every PR in the stack as if targeting the final branch, and protections are enforced against that final target. With Graphite, stacks ride GitHub's normal checks, and Graphite's docs recommend relaxing two settings (dismiss stale approvals, require approval of the most recent push) that fight stacked workflows.
Sources & last verified
- GitHub — Stacked PRs (preview)
- GitHub roadmap — Pull request stacks [Preview]
- InfoQ — GitHub targets large merge problem with Stacked PRs
- Graphite — Pricing
- Graphite — gt command reference
- Cursor — Graphite is joining Cursor
- Cursor — Origin (waitlist)
Cursor ships frequently. Facts verified against primary sources on July 16, 2026.