AI Code Review Tools Compared: What CodeRabbit, Graphite and Copilot Charge

Three AI code review tools sit on most shortlists, and they bill in three different ways. CodeRabbit charges $24 to $72 per developer a month. Graphite charges $40 for unlimited reviews. GitHub Copilot bills each review in AI credits. The seat price is the least useful number on any of these pages.

This is a comparison built from official documentation and pricing pages, read on 13 October 2026. Where a vendor page carries no date, we say so. Where we could not verify a figure, we leave it out.

How AI code review tools are bought

Code review became the slow step once coding agents started producing pull requests faster than people could read them. That argument is made in full in our piece on the code review bottleneck, so we do not repeat it here. This post answers the next question. Once you decide to automate part of the review, what does each option cost, and what does it promise?

The three tools in this comparison are bought in three different ways. Understanding the buying model matters more than the headline price.

Per seat, with rate limits

CodeRabbit sells seats. Each paid developer gets a plan, and the plan sets how many reviews that developer can trigger per hour. Cost is predictable. Throughput is capped.

Per seat, with the reviewer bundled in

Graphite sells a pull request workflow tool for stacked changes. Its AI reviewer is one feature inside the plan. You pay for the workflow, and the review comes with it.

Per review, inside a larger subscription

Copilot code review is a feature of a Copilot licence. Each review draws down AI credits, and the agentic parts also consume GitHub Actions minutes. The licence price is a floor, not a total.

Our view: most buyers compare the wrong column. The seat price tells you what a quiet month costs. The billing unit tells you what a busy month costs, and that is where the three tools differ most.

The price and capability matrix

The table below uses only what the vendors publish. Where a cell says the pages did not list something, that is a gap in what we read. We would rather show a gap than fill it from a comparison blog.

Sources: CodeRabbit plans documentation, Graphite pricing page, GitHub Docs and GitHub Copilot plans page, all read 13 October 2026. The last row concedes where each tool leads. It is our reading, not a vendor claim.

CodeRabbit: the per-seat reviewer with rate limits

CodeRabbit is the only one of the three that is a dedicated review product on every plan. Its plans documentation lists Free, Open source, Essentials, Team, Advanced and Enterprise. Many comparison sites still call the paid tiers Pro and Pro+. The documentation says Essentials was formerly Pro and Team was formerly Pro+, so check which names a source uses before comparing prices.

Billing is per developer on annual or monthly terms. Essentials is $24 annual or $30 monthly. Team is $48 or $60. Advanced is $72 or $90. The pricing page says you are charged only for developers who create pull requests. For a team where many people review but few author, that detail matters.

Rate limits are the real tier boundary

The plans documentation sets limits per developer, per hour, on rolling windows. Essentials allows 5 pull request reviews an hour. Team allows 8, Advanced 10 and Enterprise 12. The Free plan allows 1, and that review is a summary only.

The per-review file cap also steps up. Free and Essentials review up to 150 files. Team and above review up to 300. If your pull requests are small, you will never hit either limit. If an agent opens large refactors in bursts, you will.

Beyond the included limits, the documentation describes usage-based reviews. They are offered only on GitHub and GitHub Enterprise, and only for reviews of 300 files or fewer. Admins can set the behaviour to automatic, on demand or off.

Triggers and platforms

The plans documentation describes automatic incremental reviews after new pushes. Public repositories with fewer than 10 stars need a manual trigger. You press the trigger button in the status comment, or you comment @coderabbitai review for the latest changes or @coderabbitai full review for everything.

Platform coverage is the widest of the three. CodeRabbit's documentation says it works on GitHub, GitLab, Azure DevOps and Bitbucket. It also lists IDE extensions for VS Code, Cursor and Windsurf, plus a command line tool. Reviews before the pull request exist even on the Free plan, within the 3 per hour IDE and CLI allowance.

We could not find a language list on the pages we read. That is a gap, not a negative finding.

Graphite: review inside a stacked-pull-request workflow

Graphite is a different kind of product. It is a pull request workflow tool built around stacked changes, and AI review is one feature of it. Its pricing page lists Hobby (free, limited AI reviews), Starter at $20 per user per month billed annually (limited), Team at $40 (unlimited AI reviews, customisations, automations and a merge queue) and a custom Enterprise plan.

No numeric cap on the limited tiers is published on the page we read. If you plan to run Starter, ask the vendor what limited means in reviews per month before you commit.

The reviewer used to be sold as Diamond. Graphite's own pages describe it as Graphite Agent now, and the pricing page presents AI review as part of each plan rather than as an add-on. Older comparison blogs still quote a separate per-contributor price for Diamond. Treat those as out of date.

The Cursor deal

On 19 December 2025, Graphite announced a definitive agreement to join Cursor. The post said the company anticipated closing in the next few weeks, and that Graphite would keep operating as an independent product. It also said the plan was to combine the best of Graphite's AI reviewer and Cursor's Bugbot.

We found no closing confirmation on graphite.com. We did find that Graphite's site now links sales enquiries to cursor.com. For a buyer, the practical point is roadmap risk. The reviewer you evaluate today may be merged with another product. If you want context on the acquirer, our analysis of Cursor's valuation covers how it got here.

Graphite is built on GitHub's APIs. The standard product supports GitHub only, and GitHub Enterprise Server is an Enterprise plan feature. On the trigger, Graphite's AI review setup documentation says the agent automatically reviews all new pull requests in the repositories you select. We found no manual trigger command in the pages we read.

GitHub Copilot code review: billed in AI credits

Copilot code review is the cheapest tool to adopt if you already pay for Copilot, and the hardest to price if you do not. The GitHub documentation describes review as a Copilot feature that consumes AI credits and, for its agentic parts, GitHub Actions minutes.

Triggers and effort levels

By default, Copilot reviews a pull request only if you assign it as a reviewer. It reviews once unless you ask again or turn on review of new pushes. Automatic review can be switched on by individual users on paid plans, by repository owners, or by organisation owners through rulesets. Draft pull requests are reviewed only if you enable that option.

When you request a review, you pick an effort level. Lite is fast and targeted. Balanced is the default and uses a higher-reasoning model. Supported surfaces are GitHub.com, the GitHub CLI, GitHub Mobile, VS Code, Visual Studio, Xcode and JetBrains IDEs, with Azure DevOps in public preview.

GitHub says Copilot reviews code written in any language. It skips dependency management files such as package.json and Gemfile.lock, plus log files and SVG files. Model switching is not supported.

What a review costs

The documentation estimates $0.05 to $1 of AI credits for a Lite review and $0.25 to $5 for a Balanced review. Those figures exclude Actions minutes, and the page gives no per-review minute count. One AI credit is $0.01 on the Copilot plans page.

Now the seat side. Per GitHub's documentation, the Free plan does not include code review. Pro is $10 a month, Pro+ is $39, Max is $100, Business is $19 per seat and Enterprise is $39 per seat. Business includes 1,900 credits per user per month, which is $19 of credit. At 25 credits for a $0.25 review, that pool covers 76 reviews. At 500 credits for a $5 review, it covers just under 4. The pages we read do not say how much of that pool other Copilot features consume, so treat those counts as ceilings.

One trap is worth flagging. A GitHub page on premium requests says a review consumes 13 premium requests. That page is labelled legacy. It applies only to Copilot Pro and Pro+ subscribers on an existing annual plan who stayed on legacy billing after 1 June 2026. Several blogs still quote 1 or 13 premium requests per review. For new plans, the credit model above applies. If you are modelling Copilot spend more broadly, our map of Copilot's metered billing goes further.

What each vendor publishes about accuracy

This is where the comparison gets uncomfortable. Price and platform are facts on a page. Accuracy is a claim, and the three vendors treat it very differently.

Graphite's AI reviews page claims teams catch more critical issues with fewer false positives than competing solutions, from benchmark tests. It also states a negative comment rate of less than 5%. The page names no benchmark, no sample and no date. A product mock panel on the same page shows 3.5% of comments downvoted across 1,482 pull requests, which looks like demo data rather than a measurement.

GitHub takes the opposite stance. Its documentation says Copilot is not guaranteed to spot all problems or issues in a pull request, that it sometimes makes mistakes, and that you should supplement it with a human review. That is honest, and it is also no number at all.

On the CodeRabbit pages we read, we found no accuracy statement. CodeRabbit's blog may carry benchmark claims. We could not open the post we were looking for, so we do not characterise it.

The independent benchmark

The most useful independent source we found is Martian's Code Review Bench. Its launch post is dated 26 February 2026. It combines an offline gold-set evaluation with online data on which review comments developers acted on. The offline set is 50 pull requests from five open source projects, with 173 human-verified comments. The online set samples merged GitHub pull requests that bots reviewed, and the post says it covers 200,000 or more pull requests and updates daily.

Three findings from the post matter here. CodeRabbit had the highest recall in the online data at 0.54, across 5,035 pull requests reviewed. Graphite had the highest precision and the lowest recall in both benchmarks. And no tool found more than 63% of the known issues.

Martian also warns that its gold set is incomplete. That makes every precision figure likely understated and every recall figure likely overstated. We take the warning seriously and so should you.

The live leaderboard renders in the browser, and we could not read per-tool scores for Copilot from it. Comparison blogs quote F1 scores that disagree with each other, and one claims a different tool now leads. We do not print those numbers.

Where this comparison is weakest

A few limits apply, and you should weigh them before acting on anything above.

First, prices and plan names moved several times in the last year. CodeRabbit renamed its tiers. Graphite folded Diamond into every plan. Copilot moved to credits and added Actions minutes on 1 June 2026. The vendor pages carry no publication dates, so everything here is a snapshot of 13 October 2026.

Second, several facts are missing rather than negative. We found no language lists for CodeRabbit or Graphite. We found no numeric limit for Graphite's limited tiers. We found no per-review Actions minutes for Copilot. A missing figure on a page we read is not proof that none exists.

Third, the benchmark evidence is thin for a purchase decision. The offline set is 50 pull requests from five open source projects. Your repository is probably not one of them. The online data measures whether developers acted on a comment, which is a proxy for usefulness and not for correctness.

Fourth, we did not run these tools on a shared codebase. A hands-on test would beat everything here on the question of accuracy. We have not done one, and we will not pretend a reading of documentation is a substitute.

Finally, there is a case against buying any of them. If your pull requests are small and your team is senior, a human reviewer may catch more than any of these tools at lower cost. The value of automated review rises with pull request volume, and falls with reviewer attention you already have.

A 20-developer cost model

To make the seat prices concrete, here is annual list cost for 20 developers on annual billing. The model uses only published prices, and it ignores usage-based add-ons and Actions minutes.

Cost is 20 developers times the list price times 12 months. Copilot also bundles completion and chat, so its seat price buys far more than review. Do not read the last two rows as a like-for-like comparison.

The gap between the cheapest and dearest row is $6,960 a year at this team size. That is small next to one developer salary. We think the right way to read the table is as a rounding error against the cost of a missed production bug, so spend your evaluation time on accuracy and fit, not on the seat price.

Frequently asked questions

Where to start this week

Pick one repository with a normal week of pull request traffic, and pull the last 30 merged pull requests. Write down, for each one, the bugs a human reviewer caught after merge or in review. That list is your own gold set, and it is worth more than any leaderboard.

Then run two tools on it for 30 days. Our pick would be CodeRabbit and whichever of Graphite or Copilot fits your host, because they bill differently and fail differently. Count the comments your team acted on against the comments they dismissed. If the dismissed pile is bigger, the tool is costing you attention, whatever the seat price says. For the layers around review, see our comparison of AI code security scanners and our verdict on Claude Code, Cursor and Copilot.

Related reading