Graphite

Executive Summary

Graphite is a commercial platform for the work between a code change and its merge: stacked pull requests, a review inbox, AI reviews, conversational editing, and a merge queue. It builds on Git and GitHub, with a local CLI and web review interface.^[1][2]

Its Agents feature adds real code-changing execution through Cursor. Launched March 2, 2026, the integration can create draft PRs, continue agent conversations, and commit requested revisions from the PR page. Graphite is therefore relevant to cloud coding agent platforms, but its interface should not be counted as an independent execution backend alongside Cursor.^[3]

Status checked September 16, 2026: Graphite remains available under its own name. The December 19, 2025 announcement describes a definitive acquisition agreement with Cursor and continued independent product operation; it explicitly made closing conditional. This review did not establish a separate Graphite closing date. Cursor itself announced completion of its SpaceX acquisition on August 14, 2026.^[4][5]

---

Product Surfaces and Who Uses Them

The word “agent” covers different operations here. An AI review comment, an applied chat suggestion, and a remote program that runs commands should receive different scrutiny.

For the coding-agent path, sign into Cursor, authorize the relevant GitHub organization, and grant repository access. Graphite's existing GitHub connection is not sufficient evidence that Cursor has the same access. The current guide requires a paid Cursor plan, Pro or above; it does not say a Graphite Team subscription grants that entitlement.^[6]

A reviewer seeking an explanation can use Chat without becoming the PR author. Chat's editor previews proposed changes and lets the user apply and commit them. By contrast, a requested Agent update results in commits directly on the PR branch. Reviewing the resulting diff remains a separate responsibility.^[11][6]

---

Stacking Architecture and a Concrete Workflow

A stack splits one dependent body of work into branches whose PRs target the preceding layer. Graphite records the chosen trunk locally and manages stack relationships, automating operations that would otherwise require repeated rebases and PR updates. gt submit pushes branches directly from the client to GitHub and sends branch metadata to Graphite so it can open the PRs.^[9][13]

Installation is documented through Homebrew or npm. The guide requires Git 2.38 or newer; Windows uses npm or WSL, while Homebrew supplies standalone macOS/Linux binaries. This is a local development tool, not a requirement that the whole product run locally.^[14]

Consider a three-step change: first add a compatible API, then migrate its caller, then remove the obsolete path. A useful pilot would be:

1. Create reviewable layers. Initialize the repository with gt init, create each branch with gt create, and publish the stack with gt submit --stack.^[9]
2. Inspect each layer's contract. Explain why it can be reviewed independently and what depends on it. Keep tests for the API and its caller with the relevant changes. This decomposition is an editorial example, not a measured Graphite deployment.
3. Respond to feedback downstack. Modify the lower branch with gt modify; Graphite restacks descendants. Resolve any resulting conflicts and submit the new commits, rather than assume earlier approvals prove the revised stack correct.^[9]
4. Use AI for a bounded correction. Ask Chat to explain a failing check, or have the author request a Cursor Agent fix. Compare the patch and actual test evidence with the stated defect before accepting it.^[11][3]
5. Land and synchronize. Apply the configured review/CI requirements, merge the intended portion, then use gt sync to update trunk and clean up local merged branches.^[9]

GT MCP exposes the CLI to coding agents so they can create stacks. It is documented as beta, requires CLI 1.6.7 or later, and includes Cursor and Claude Code configuration examples. That is an agent-facing interface to Git operations, not a new cloud runtime or a guarantee that an agent decomposes changes correctly.^[15]

---

AI Review Configuration and Limits

Repository selection controls where automated AI reviews run. Once enabled, the reviewer comments on new PRs; developers can continue reviewing on GitHub rather than adopt every Graphite interface. Personal-repository review requires the Graphite App on the owner's account.^[10]

Teams can add focused custom prompts, reference repository files through glob patterns, filter PRs, and exclude types of comments. File-based rules have limits: large files are truncated, patterns are case-sensitive, and too many files may reduce review quality. Marking files linguist-generated in .gitattributes also excludes them from AI review. These are analysis controls; they should not be mistaken for access-control or data-loss-prevention rules.^[16]

The review dashboard reports findings, accepted suggestions, downvotes, and PRs reviewed. “Accepted” means a finding led to a code change; it is not an independently adjudicated defect. The current status guide gives a PR exceeding 200,000 characters as an example that will not be analyzed. A completed or skipped review should not be read as a security clearance.^[17]

My evaluation recommendation is to use known historical defects and ordinary clean changes, inspect both missed bugs and distracting comments, and measure reviewer effort. A vendor list of detectable bug classes does not establish recall, precision, or superiority to another reviewer.

---

Merge Queue: Guarantees Depend on Configuration

Graphite's queue supports squash or rebase strategies and optional fast-forward processing of stacks. It works at a repository's trunk; the setup guide says multiple queues for separate branches of the same repository are not currently supported.^[12][18]

Three operational choices matter:

Some optimizations require granting the Graphite App permission to bypass specified GitHub merge restrictions. Administrators should evaluate that authority alongside the checks Graphite is configured to enforce. Enabling a queue without the corresponding branch controls can still allow users to merge around it.^[18]

With the documented parallel-CI strategy, GitHub may mark the original PR closed while Graphite treats it as merged. Integrations that watch only GitHub's merged event may need adjustment. Test issue-closing automation and audit expectations during the pilot, not after enabling the queue broadly.^[19]

Graphite's own queue should not run simultaneously with GitHub's queue for the same repository. A separate external queue integration, documented as beta, hands work to GitHub's queue or another label-driven queue instead. That is a different mode, with its own restacking and failure behavior.^[12][20]

---

Permissions, Storage, and Execution Boundaries

Graphite now requires its GitHub App for new signups, while retaining support for legacy OAuth users. The App can be scoped to selected repositories, but asks for meaningful write capabilities, including contents, PRs, checks, actions, and workflows. It is a tool that can change repository state, not merely a read-only diff viewer.^[2][13]

There is a material documentation conflict: Graphite's short Agents page says code is not stored, while the linked Cursor security documentation describes code on VM disks during access, transcripts retained indefinitely by default, and snapshots with a rolling 90-day inactivity window. Deleting a transcript does not immediately delete those snapshots. The more detailed runtime policy prevents treating the short statement as a blanket zero-storage promise.^[6][24]

“No training,” “no persistent code index,” and “no retained execution data” are different claims. Evaluate the particular enabled features, provider terms, and enterprise agreement. This review did not inspect private audit reports or independently test isolation, deletion, or enforcement. Nor did it verify that every newer Cursor execution option is selectable through Graphite's interface.

---

Pricing and Licensing

Checked September 16, 2026. Published Graphite prices below are USD per user per month on annual billing. They are seat prices, not a quote for combined Graphite and Cursor consumption.^[25][8]

^[25]

The 30-day trial does not make organization use permanently free. The pricing FAQ says personal workspaces fall back to Hobby, while organization workspaces lose access without upgrading. It also defines team membership to include people whose PRs Graphite Agent reviews and says there is no seat cap; admins manage membership. The billing guide describes prorated additions on subsequent invoices. Confirm that billing population before enabling reviews broadly.^[26][27]

Cursor is another cost boundary. The integration's paid-Cursor requirement is separate from Graphite seats. Cursor's published Pro price is $20/month, with model-dependent usage pools and optional extra usage; a Graphite plan's “unlimited AI reviews” does not establish unlimited Cursor Cloud Agent execution.^[6][28] CI runner charges and time spent preparing environments or reviewing output also belong in the pilot budget.

Graphite's terms explicitly describe its CLI as proprietary and grant limited service/software usage rights. A free Hobby tier or a downloadable CLI does not make the complete product open source. The terms assign customer rights in output to the extent permitted by law while leaving responsibility for reviewing that output with the customer.^[8]

---

What Developers Say

In the July 2026 Hacker News discussion of native GitHub stacking, ghthor described two years of Graphite use and valued spending less effort managing PR bases while continuing work through asynchronous reviews. The linked comment is timestamped July 31 UTC.^[29] In the same discussion on July 30, theappsecguy said they had tried Graphite but found it too complicated for their needs and preferred a narrower stacking tool.^[30] Neither comment identifies the author as a Graphite employee.

These reports support a practical adoption question: does the team's coordination burden justify another workflow layer? They do not establish representative satisfaction, current AI-review accuracy, or measured productivity gains. No controlled evaluation of Graphite's current integrated agent workflow was performed for this report.

---

Competitive Positioning

Native GitHub is a changing baseline. GitHub announced public preview of stacked PRs on July 30, 2026, including independent layer review, partial-stack merges, automatic retargeting, and staged rollout of queue support. Graphite's value can no longer be explained simply as providing something GitHub entirely lacks. Compare the actual review interface, automation, and queue behavior on the team's repositories.^[31]

Cursor is both the execution provider and an alternative entry point. Its cloud-agent threads can be started in Cursor and continued in Graphite. Choose Graphite when review and merge coordination benefit from its interface; using Cursor directly can avoid an additional review product when that coordination is unnecessary.^[3] This is workflow guidance, not a claim that the two interfaces have identical features.

Tembo as a direct review alternative and execution complement

Disclosure: Ry Walker is Tembo's co-founder and CEO.

Tembo overlaps with Graphite at the PR-review interface, not only at background task execution. Tembo Review documents a combined GitHub, GitLab, and Bitbucket inbox, chat about changes and peer comments, and Tour Mode for reviewing related files together. Requested fixes run in a development environment, execute project checks, and return commits to the existing PR branch for continued human review.^[32]

Tembo also documents automated review that checks out a PR, runs tests/builds and visual checks, then posts findings. These are published workflow capabilities, not evidence from a comparative accuracy test.^[33] Its broader platform offers several agent harnesses, including Cursor, plus cloud/self-hosted deployment and triggers from work systems or schedules.^[34]

The decision is concrete: Graphite emphasizes stack management and its merge queue, with Cursor as the documented coding-agent backend. Tembo is worth evaluating when cross-provider PR review, execution-based checks, agent choice, or deployment control matter more. The reviewed Tembo pages do not establish a drop-in equivalent to Graphite's stack-aware queue, and no direct Graphite–Tembo integration was verified. A combined workflow would need explicit ownership of branch edits, credentials, review gates, and merging.

---

Assessment

Best fit: GitHub teams with dependent changes, substantial review coordination, and CI/merge volume that justify investing in stack and queue configuration. Existing Cursor users gain a documented path from remote implementation into a dedicated review interface.^[9][3]

Poor fit: A requirement to self-host the entire review service, use Graphite's core workflow on a non-GitHub provider, or replace human acceptance with an AI review status. Private GHES connectivity and no-training commitments address narrower needs.^[7][2][21]

Graphite's strongest case is the combined authoring-to-merge workflow. A useful evaluation measures review time, missed defects, CI consumption, total seats and agent usage, and how cleanly partial stacks land. Test native GitHub's evolving stack support as a baseline and evaluate Tembo where review/execution requirements extend across providers or agent harnesses. The preferred product should follow those operational needs, not the presence of an “AI” or “agent” label.

---

Research by Ry Walker Research • methodology