Complete Graphite Agent Review (2026)

Graphite Agent is the AI reviewer inside Graphite’s GitHub pull-request platform. It comments on bugs, suggests fixes, and can carry a conversation about a finding. The same product also sells stacked pull requests, a review inbox, automation, and a merge queue.

That wider package makes Graphite different from a bot installed only for comments. A team may arrive for the review workflow and get Agent with it, or test Agent first and later decide whether Graphite should become its main pull-request work surface.

CodeWalkers has no documented hands-on Graphite use. The assessment here comes from current Graphite and Cursor material, with vendor claims kept separate from facts a team can measure during a trial.

Graphite Agent at a Glance

checked July 28, 2026: Graphite's AI review docs, plan table, and setup page place Agent across the paid plans and the free personal tier. The current public setup centers entirely on GitHub.

Area	Current Position	Trial Question
Git platform	GitHub	Repos sync cleanly?
Review trigger	New pull requests	Useful on routine work?
Context	Whole codebase claim	Finds cross-file bugs?
Tuning	Rules and exclusions	Noise falls over time?
Workflow	Stacks and merge queue	Team wants both?
Paid model	Per seat	Seat rules understood?

Why Graphite Is More than a Bot

Graphite began as a pull-request workflow built around small dependent changes. Its product includes a CLI and editor extension for stacks, a web inbox, merge controls, team reporting, and GitHub sync. Agent is part of that wider review system.

This matters to buyers because the Team price covers unlimited Agent use alongside the wider review platform. If a team already wants stacking and a merge queue, the AI reviewer is one part of a larger purchase. If it wants only automated comments, every extra surface becomes adoption work to weigh.

Graphite says Agent can create PR titles and descriptions, review code, chat about findings, propose fixes, and summarize continuous-integration results on eligible plans. Custom rules, file exclusions, automations, and acceptance metrics add a feedback loop around those comments.

Keep the decision tied to the team’s bottleneck. Slow handoffs may call for the inbox and stack workflow, while missed bugs may call for stronger review evidence. Merge delays may call for queue rules.

One license can cover all three workflow needs. A broad bundle only pays off when the team uses it.

From Diamond to Graphite Agent

Graphite launched its AI reviewer as Diamond and renamed it on October 7, 2025. The same announcement combined Diamond and Graphite Chat into Graphite Agent, then moved Agent access into each plan.

The rename can make older reviews hard to read. Diamond pricing, separate add-ons, and screenshots may no longer match the product. Search current docs under Graphite Agent, AI reviews, and chat when checking a feature.

The merged product also altered the workflow. A finding can become a discussion and then a proposed edit within the PR page. That path is more useful than a comment when the explanation is sound, though every generated fix still needs tests and human approval.

Graphite’s announcement says the Team plan became $40 per seat each month when billed annually, with unlimited AI reviews and chat. That price remains in the live plan table.

How Graphite Agent Reviews Code

An admin selects repositories in Graphite’s AI review settings. Agent then analyzes new pull requests, leaves inline comments for potential issues, and can suggest a fix. The review dashboard reports pull requests reviewed, issues found, and acceptance rates.

Graphite's current product page says Agent analyzes the entire codebase, learns from team feedback, and focuses on bugs instead of style. These are vendor claims that need a repository-specific trial.

Whole-codebase context should show up in the findings. A useful test changes an interface and leaves one caller broken in an untouched file. Another changes an authorization rule whose use sits in a different package.

Record whether Agent cites the relevant path and explains the broken contract.

Feedback data also needs a closed loop. A thumbs-up rate may show that comments sound plausible, while accepted fixes show that a finding affected code. Track both, then review misses found later by people, tests, or production alerts.

Agent works alongside the continuous integration pipeline. It may find logic and edge cases that tests miss, while tests provide repeatable proof. Keep required checks and human approvals in place because a conversational reviewer cannot guarantee full coverage.

What Stacked Pull Requests Change

A stack breaks one body of work into dependent pull requests. Developers can ask for review on the first slice while building the next. Graphite tracks the chain and helps move later branches as earlier ones merge.

Smaller diffs can help both people and AI because each pull request carries a tighter purpose. The reviewer sees fewer unrelated edits, comments attach to a clearer unit, and authors can fix one slice without reopening a large change.

Stacks also alter the team’s daily Git work. Developers need the Graphite CLI or editor flow, must understand parent-child branches, and have to recover when a middle pull request changes. A mixed team, where only some authors stack, can create more coordination work than it removes.

Graphite Agent can run without stacked pull requests. The setup page says selected repositories receive automatic review on new pull requests. Trial that basic loop first if the team has not agreed to alter how it divides work.

Setting Up and Tuning Reviews

Graphite says AI reviews can be enabled in a few clicks. An admin syncs repositories through the GitHub App, selects the repositories in AI review settings, and saves. Agent reviews new and updated pull requests that match the settings.

Keep defaults on a small repository group while testing the first stack. Label each comment as a valid bug, useful suggestion, wrong claim, repeat, or style preference. Add a custom rule or exclusion when the stack exposes a repeated pattern.

Graphite offers two forms of tuning: comment exclusions and custom rules. Exclusions stop known low-worth comments, while rules state a practice the reviewer should enforce. The customization guide recommends narrow prompts with clear examples.

A workable exclusion might say: “Skip performance comments for files under /scripts because each script runs once during migration.” A workable rule might require a public API field to appear in the schema and contract test. Both examples define a clear scope and evidence.

Generated files can be marked with linguist-generated=true in .gitattributes. Graphite says those files collapse in review, do not count toward a too-large PR check, and are skipped by Agent. Test this with your generated paths before relying on it.

Measuring Graphite Review Quality

Graphite's customization docs, list metrics for every rule and exclusion. Rules report issues found, PRs reviewed, accepted issues, acceptance rate, and votes. Exclusions report the issues checked and filtered out.

Acceptance rate provides one useful starting signal. A developer may accept a small edit because it is cheap, while ignoring a more serious finding that needs design work. Pair the number with severity, fix size, later test results, and bugs found after merge.

Review each custom rule after enough pull requests to expose a pattern. A rule with many findings and few accepted fixes may be vague, wrong for part of the repository, or better handled by a deterministic check. Narrow it, split its scope, or remove it.

Exclusion data can expose overly broad review tuning. If one exclusion filters a large share of candidate findings, sample those hidden cases. A broad instruction that cuts noise can also conceal a valid performance or security issue outside the reason it was written.

Keep a human-found-miss list beside Graphite’s dashboard. The product can report what it said, while only the team can record what it failed to say. Re-run those misses after rule edits and product releases.

Graphite Pricing and Seat Math

Graphite's billing table lists Hobby for personal work, Starter at $20 per seat each month billed annually, Team at $40 per seat each month billed annually, and custom Enterprise terms.

Plan	Listed Price	Agent Access	Main Buyer
Hobby	Free	Limited reviews and chat	Personal repositories
Starter	$20/seat/mo (annual)	Limited reviews and chat	Small teams
Team	$40/seat/mo (annual)	Unlimited and tunable	Growing teams
Enterprise	Custom	Unlimited and governed	Large organizations

The Team plan adds review customization, suggested fixes, CI summaries, code-indexing controls, privacy controls, automation, and a basic merge queue. Enterprise adds items such as SAML or SSO, audit logs, access controls, GitHub Enterprise Server, and private uploads.

Graphite's seat-counting rule deserves close buyer attention. Its pricing FAQ says anyone who joins the workspace or has a pull request reviewed by Agent counts as a team member. Ask Graphite how that rule applies to bots, contractors, occasional authors, and archived accounts.

The 30-day Team trial allows unlimited invited contributors, according to the billing docs. Use it to build a full seat list and a monthly cost before the trial ends. A five-person Team workspace lists at $200 each month on annual billing, while a larger author pool may alter that figure.

Admin and Data Controls

Graphite’s plan table separates code-indexing controls and AI privacy controls into Team and Enterprise. Enterprise adds access controls, SAML or SSO, audit-log export, GitHub Enterprise Server, private uploads, and contract options. Exact settings should be shown in the plan you intend to buy.

Codebase-aware review raises several clear data questions. Ask what Graphite indexes, where that index is stored, how soon deleted repositories leave it, which model providers receive code, and whether chat or suggested fixes create extra stored data.

The GitHub App permission set needs a repository-by-repository check. Confirm who can sync a new repository, enable automatic reviews, edit rules, view organization metrics, and export audit records. Use least access during the pilot, then widen only where the workflow needs it.

Test removal as part of the trial. Disable review on one repository, revoke Graphite’s access, and check whether comments, dashboards, and indexed context behave as the contract states. A clean exit matters when the platform sits across review, merge, and repository history.

What the Announced Cursor Acquisition Means

Graphite announced on December 19, 2025 that it had signed a definitive agreement to join Cursor. The official post said the transaction remained subject to customary closing conditions and described what would happen on closing. No official closing announcement was found by July 28, 2026.

The announcement named possible directions, including review informed by both systems and tighter movement from local code to pull requests. It did not promise a delivery date or a merged product. Current Graphite docs should decide what a buyer can use now.

Cursor already sells BugBot, so the announced acquisition creates an obvious overlap in AI review. Graphite Agent remains presented as part of Graphite's GitHub workflow, while BugBot has its own product and pricing. Avoid assuming one license includes the other unless a current plan page says so.

The practical check is simple: ask for a live demo of any cross-product feature in your contract discussion. A roadmap can help with direction, but a purchase should stand on the Graphite functions available during the trial.

Test Stack Context and Seat Math

Use the hub's four-week method for the shared sample and outcome labels. Graphite needs two additional tests: whether stack context catches a dependency between related pull requests, and whether occasional authors unexpectedly change the seat count.

1. Sync selected repositories: verify Graphite sees new and updated pull requests without broad access you did not intend.
2. Replay known outcomes: use recent bugs, false-positive traps, and a cross-file contract break.
3. Measure stack context: record findings that depend on another pull request in the stack.
4. Add one rule: write a narrow team standard with good and bad code examples.
5. Add one exclusion: remove a proven source of noise, such as generated output.
6. Price the workspace: list every person whose pull request Agent may review.

Test stacked pull requests as a second track. Ask two developers to split one feature into three small pull requests, then compare review time and merge recovery with the team’s normal workflow. Do not force the whole group to adopt stacks before that result is clear.

At the end of 30 days, review Agent and the workflow platform separately. A strong merge queue does not prove bug detection, and a useful comment does not prove stacking will fit the team.

Where Graphite Agent Needs Care

GitHub focus is the first hard boundary. Graphite’s current public setup relies on its GitHub App. Teams on GitLab, Bitbucket, or Azure DevOps need another review route unless Graphite publishes a new integration.

Per-seat billing can spread beyond the small group that administers Graphite. Anyone whose pull request Agent reviews may count as a member. Teams with many occasional authors should settle the roster rules before enabling every repository.

Vendor claims about whole-codebase context and learning need local proof. Test untouched callers, shared types, and repeated feedback. Track misses found by human reviewers so a high acceptance rate does not hide a narrow review surface.

The bundle can also blur the reason for buying. Decide whether Agent, stacks, inbox, automation, or merge queue carries the purchase. If only Agent scores well, compare its seat cost with dedicated review products before moving the whole PR workflow.

The Verdict for Graphite Teams

Graphite Agent has the clearest case when a GitHub team also wants Graphite’s stack, inbox, automation, or merge-queue workflow. In that setting, unlimited Team-plan review joins a platform the team has another reason to use.

Run Agent alone on ordinary pull requests before changing Git habits. Adopt the wider platform when verified findings, tuning data, and workflow gains cover the per-seat bill. Teams seeking only a review bot should compare that same evidence against a narrower product.

FAQ

Is Diamond now Graphite Agent?

Yes, Graphite retired the Diamond name in October 2025 and combined its AI pull-request reviewer with Graphite Chat under the Graphite Agent name. Use current Graphite Agent documentation for buying and setup because older Diamond reviews may describe plans, limits, or screens that have since moved.

Can I use Graphite Agent without stacked PRs?

Yes, Graphite lets an admin enable AI reviews for selected GitHub repositories, and the agent reviews new pull requests without requiring the stacking workflow. Stacks remain a separate reason to buy Graphite, so a team can trial the reviewer on ordinary pull requests before altering local Git habits.

Does Graphite Agent work outside GitHub?

Graphite’s current setup runs through the Graphite GitHub App and repositories synced from GitHub. Its enterprise plan lists GitHub Enterprise Server, while the public review setup does not list GitLab, Bitbucket, or Azure DevOps. Confirm any private GitHub edition with Graphite before planning a rollout.

Is Graphite Agent free?

Graphite has a free Hobby plan for personal repositories with limited AI reviews and chat. Paid team use starts with Starter at $20 per seat each month when billed annually. Team costs $40 per seat each month when billed annually and includes unlimited reviews, chat, and review customization.

Has Cursor's acquisition of Graphite closed?

Graphite announced a definitive agreement to join Cursor on December 19, 2025. Its announcement said the transaction remained subject to customary closing conditions and described what would happen on closing. No official closing announcement was found by July 28, 2026, so this page treats it as an announced acquisition.