AuravsG Graphite
Comparison · Graphite · stacked PRs and AI review

Graphite makes pull requests smaller. Aura makes them provable.

Graphite is built around stacked pull requests — small, dependent changes that land in order — with an AI reviewer on top. Aura attacks the same problem from the other end: not how to slice a change so a human can review it, but how to give a machine enough context to say whether the change was correct.

Stacking makes review possible. Proof makes it unnecessary to guess.
Jump to the matrix
The short version

What each one is for

G

What Graphite is great at

  • Stacking

    Dependent PRs that rebase cleanly is a genuinely hard problem, and Graphite solved it better than anyone else.

  • Review throughput

    A team on stacks reviews faster because each unit is small enough to hold in your head.

  • Diamond

    The AI reviewer catches real things and is tuned to be quiet, which is the hard part of automated review.

  • GitHub-native

    It fits the flow a team already has rather than asking them to leave it.

What Aura adds on top

  • A goal to review against

    An AI reviewer reads a diff and guesses at intent. Aura is given the intent up front, so the check is against a stated goal rather than an inferred one.

  • The agent side

    Graphite starts at the pull request. Aura starts before the agent runs — approving what it may touch, then checking what it did.

  • Semantic identity

    Function-level identity that survives renames and moves, so a refactor reads as a refactor across a stack.

  • Not only GitHub

    Any Git remote, or none.

Head to head

Dimension by dimension

Where it starts
AuraBefore the agent runs — the goal, the approved scope.
GraphiteAt the pull request.
Review model
AuraDeterministic checks (intent vs AST, deletions, goal wiring) plus an AI pass.
GraphiteAI review of the diff, plus humans on small stacks.
Host
AuraAny Git remote, or a local-only repository.
GraphiteGitHub.
Licence
AuraApache-2.0.
GraphiteCommercial.
Capabilities

Side by side

Capability
Aura
G Graphite
Stacked pull requests
AI code review
GitHub-native workflow
Works without GitHub
Reviews against a stated goal
AST-level semantic diff
Intent recorded and verified at commit
Blocks unaccounted deletions
Drives coding agents
Open source
Compared on public capabilities, mid-2026. ● full · − partial · ✕ none.
Honest advice

When to pick which

G

Pick Graphite if…

  • Your bottleneck is human review throughput on GitHub.
  • Stacked PRs are how your team already works.

Pick Aura if…

  • Your bottleneck is not knowing whether an agent’s change did what you asked.
  • You are not on GitHub, or not only on GitHub.
Not either/or

Keep Graphite. Add the control layer.

Stack with Graphite, prove with Aura. Aura’s check runs at the commit, before anything reaches a pull request, so a stack arrives already carrying a verdict per commit.

Questions

Aura & Graphite

Does Aura do stacked PRs?

Not as a first-class feature. Crew works a dependency graph and merges in order, which covers some of the same ground, but Graphite’s stacking is more complete.

Is Aura’s review AI or deterministic?

Both, and the deterministic part comes first. Intent versus AST, deletions versus callers, and goal wiring are computed, not guessed. An AI pass runs on top of that.

Ship with proof, not hope

Free public beta for macOS and Linux. Point it at a repo and keep driving Graphite, now with a semantic diff, a verdict and a record on every change.

Try the CLI