Mergify Stacks vs Graphite

Graphite is a developer workflow platform built around stacked pull requests. It ships a CLI (gt), a custom PR review UI, AI reviews, and a merge queue. This page focuses on how the two tools handle stacking: how you create, update, and land a chain of PRs. A short Beyond stacks section near the end covers how the broader platforms differ.

Both tools solve the same core problem (big PRs are hard to review, so split them into a chain of small ones), but they take different approaches to get there.

The biggest difference is how each tool thinks about branches.

Both produce the same result on GitHub: chained PRs where each targets the previous one’s branch. The difference is what you deal with locally.

You work on a single branch. Each commit maps to a PR automatically:

Under the hood, mergify stack push creates a remote branch per commit and chains the PRs:

You never see or manage these remote branches. They're an implementation detail.

You create and name a separate branch for each change with gt create. Each branch becomes a PR that targets the branch below it:

Three branches, three PRs: add-model targets main, add-endpoint targets add-model, add-tests targets add-endpoint. You navigate between them with gt up, gt down, gt top, and gt bottom.

Simpler Git model. One branch, standard Git. You don’t create branches or navigate between them. You commit and rebase like you already do. The branching complexity lives on the remote side where you don’t have to think about it. Graphite’s one-branch-per-PR model is more expressive but asks you to learn a new set of commands (gt up, gt down, gt modify, gt restack) and keep a tree of local branches in your head.

One command does more. mergify stack push rebases on the target branch, pushes all changes, and creates or updates PRs in a single step. Graphite splits the flow across several operations (gt create, gt modify, gt submit) depending on where you are in the stack.

Merge Queue depth. Mergify’s Merge Queue has batching, priority lanes, speculative checks, and queue freeze. Graphite has a merge queue too; Mergify’s is more configurable and has been in production longer.

No one else needs Mergify. Only the stack author installs the CLI. Reviewers, teammates, and anyone else interacting with the PRs use GitHub’s native UI: no Mergify sign-up, no install, no account required. Graphite’s full review, navigation, and approval flow lives inside the Graphite app, so to get the complete experience everyone on the team needs a Graphite account.

gt absorb saves real time. After a review round, you often need to amend several commits with different fixes. Graphite’s gt absorb looks at your staged hunks and routes each one into the commit that last touched those lines. Mergify doesn’t have an equivalent; you amend each commit by hand.

gt split breaks big commits apart. When a commit grows too large during development, gt split carves it into smaller commits by file or hunk. Useful when what started as one change turns out to need separating for review.

gt undo is a safety net. Graphite tracks its own operations and can revert them with a single command. Mergify relies on Git’s reflog, which is harder to navigate when something goes sideways.

Frozen branches for collaboration. Graphite can freeze branches that other contributors are working on to prevent accidental force-pushes. mergify stack checkout supports handoff too, but Graphite’s explicit locking prevents more foot-guns on shared stacks.

IDE integration. Graphite has a VS Code extension that lets you manage the stack visually. Mergify is CLI-only today.

Stacking is one feature of Graphite, not all of it. The rest of the product includes:

• AI reviews and Graphite Chat: automated review comments and an AI assistant that answers questions and edits code on PRs.

• Custom PR review UI: inbox, code tours, diff versions, keyboard shortcuts.

• Developer velocity analytics: PR throughput, review time, per-person metrics.

• Native integrations: Linear, Slack (including review and merge from Slack).

Mergify has invested in a different direction:

• Rules engine: 40+ conditions, 20+ actions, cascading logic for Workflow Automation.

• Merge Queue maturity: batching, priority lanes, speculative checks, queue freeze.

• CI and test intelligence: CI Insights for cost and timing analytics, flaky test detection, quarantine, and test reporting.

• Open CLI, review in GitHub: Stacks works with GitHub’s native review UI; there’s no separate app to learn.

If AI review and a custom PR experience are what you want, Graphite is built around that. If you want a deep Merge Queue, Workflow Automation, and CI/test intelligence, Mergify is built around that. For stacking alone, the choice comes down to the Git model and the feature gaps above.

Pricing. The Mergify CLI and Stacks are free and work without a Mergify subscription. Graphite has a free tier for the CLI and charges for platform features (AI reviews, merge queue, analytics) on team and enterprise plans.

Platform support. Both tools target GitHub today.

Review surface. Graphite encourages review inside its own app. Mergify Stacks keeps review in GitHub’s native UI, which matters if your team doesn’t want to move PR review off GitHub.

If you’ve been using Graphite and want to try Mergify Stacks, the main shift is moving from “one branch per PR” to “one commit per PR on a single branch.”

uv tool install mergify-cli
mergify stack setup

This installs the CLI and adds a commit-msg hook that generates Change-Ids for your commits. See the setup guide for details.

With Graphite:

gt create add-model
# work on first change
gt create add-endpoint
# work on second change
gt submit

With Mergify Stacks:

mergify stack new
git commit -m "add model"
git commit -m "add endpoint"
mergify stack push

The result on GitHub is the same: two chained PRs, each showing one change.