AI code review tools in 2026, grouped by what they actually do

Nobody asks me which AI code review tool is best any more. They ask which two to run together, which is the better question, because the tools sold under that one label do four different jobs. Some hunt for bugs. Some annotate the lines and write a summary at the top. One is a workflow product that happens to include a reviewer. A few draw the change so you can see its shape. As of September 2026 the list prices across this group run from free to $72 per developer per month, and two tools at the same price can be doing entirely unrelated work.

Here is the grouping I use when someone asks. Everything below is dated September 2026 and taken from each vendor's own docs or pricing page. These change constantly, so check before you buy.

What are the four kinds of AI code review tool?

The groups are not a ranking. A team with a flaky test suite and a security surface needs a finder. A team drowning in 400-line agent PRs needs an explainer. Most teams I have watched end up with one of each.

Finders: tools that hunt for bugs

Greptile indexes the repository rather than the diff. Its docs say it builds a graph of the entire repository to understand how changes affect the whole system, then posts findings in about three minutes as PR comments with suggested fixes. Its pricing page as of September 2026 lists a free Starter plan with 50 credits a month for one active developer, Pro at $30 per seat per month with 50 credits per seat and $1 per credit after that, where one credit is one standard review. Qualified non-commercial projects under MIT or Apache licences are free.

Cursor Bugbot analyses the PR diff and leaves comments with explanations and fix suggestions. It runs on each update by default, or on a bugbot run comment, and posts inline comments, a top-level summary and a GitHub status check named Cursor Bugbot. With autofix on, it spawns a Cloud Agent that pushes fixes to a branch. Its docs describe usage-based billing: included usage first, then on-demand spend.

Claude Code Review is the deepest of the three and the slowest. Anthropic's description is that it dispatches a team of agents on every PR that look for bugs in parallel, verify those bugs to filter out false positives, and rank them by severity, landing one overview comment plus inline comments for specific bugs. As of September 2026 it is a research preview in beta on Team and Enterprise plans, the average review takes around 20 minutes, and reviews are billed on token usage, generally averaging $15 to $25.

Twenty minutes and about $20 a review buys a careful read for defects. It does not buy you a mental model of the change. I go into that in PR Lens vs Claude Code Review, and the Bugbot version of the same argument is in PR Lens vs Cursor Bugbot.

Commenters: tools that annotate the diff and summarise it

CodeRabbit is the most feature-dense product in this list. As of September 2026 its pricing page lists Essentials at $24 per developer per month billed annually, Team at $48 and Advanced at $72, with free reviews for public repositories. On top of inline review comments it posts a walkthrough comment with a grouped summary of changed files, an estimated review effort, related issues and PRs, suggested labels and reviewers, and a poem. For pull requests that touch component interactions it generates Mermaid sequence diagrams inline, controlled by a sequence_diagrams option that defaults to true. Its Advanced tier lists blast radius and architectural impact analysis.

That diagram feature makes CodeRabbit the tool people most often assume overlaps with PR Lens. The overlap is smaller than it looks, and I take it apart properly in PR Lens vs CodeRabbit.

GitHub Copilot code review is the one your team probably already has. GitHub's docs say it reviews pull requests in any language, produces comments tagged High, Medium or Low, suggests changes you can apply in a couple of clicks, and adds an overview comment saying whether the PR looks ready to merge. Reviews typically finish in under 30 seconds. It is included with Pro, Pro+, Max, Business and Enterprise; the free plan gets only "Review selection" in VS Code. Reviews draw on your AI credit allowance, and GitHub estimates $0.05 to $1 of credits per review at Lite effort and $0.25 to $5 at Balanced.

GitHub's own docs are refreshingly plain about the limits: Copilot is not guaranteed to spot all problems, it sometimes makes mistakes, and it skips dependency files, logs and SVGs. PR Lens vs GitHub Copilot code review covers how the two sit in one pull request.

Workflow: Graphite

Graphite belongs in a different sentence from the rest. It is a stacking tool with a merge queue and a reviewer bolted on, and its main effect on review is that the pull requests arriving are smaller and ordered. Its merge queue is stack aware: stacked PRs queued together can be validated in parallel and fast-forward merged, which is a genuinely clever thing that GitHub's own queue does not do.

Its pricing page as of September 2026 lists Hobby free for personal repositories, Starter at $20 per user per month billed annually, Team at $40 with unlimited AI reviews and chat plus the merge queue, and custom Enterprise pricing. The AI reviewer that used to be called Diamond now sits under Graphite Agent, which merged the reviewer and chat into one thing.

If your team already stacks, PR Lens draws inside each stacked PR without caring how the stack was made. That comparison is PR Lens vs Graphite.

Explainers: tools that draw the change

This is the smallest group and the newest.

ToDiagram takes a pull request diff, hands it to a model, and asks it to explain the change visually. The model picks the format it thinks fits, an architecture diagram or a module graph or a data model, and the result opens in ToDiagram's editor. It is the closest thing to PR Lens in intent, and different in almost every mechanical decision. PR Lens vs ToDiagram is the long version.

CodeSee used to be here, drawing codebase maps and review maps. It is no longer maintained, and as of September 2026 its site does not resolve. People still search for it, which tells you the job it was doing did not go away.

PR Lens is what we build. It draws each pull request as animated architecture and data-flow diagrams and posts them as one comment inside the pull request, updated in place on every push. The architecture lens shows the blast radius: what the PR touches, drawn against the system around it, with green for new, amber for changed and red for gone, and removed components struck through. The parts the PR did not touch stay on the page. The data-flow lens plays the ordered pipeline of the change, one dot crossing one arrow at a time. Every comment links to a canvas where you can pan, zoom, switch theme, and press play to walk the change one step at a time. It is MIT licensed, free for open source, and runs as a GitHub App, a GitHub Action, a CLI, or an agent skill your coding agent already has a model for. The full description is in What is PR Lens?.

Which combination should a team actually run?

Pick one finder and one explainer, and let your existing platform cover the commenter slot.

The finder is for correctness. Its job is to catch the null deref, the missing auth check, the off-by-one in the pagination. Choose on catch rate and on how much false-positive noise your team will tolerate before muting the bot.

The explainer is for comprehension. Its job is to answer the question you ask before you start reading, which is "what did this change do to my system?" Four tools can review the same pull request and none of them will tell you what it changed. That is not a failure on their part. It is a different question, and nobody in the finder or commenter group is trying to answer it.

The commenter slot is usually already filled. If you are on GitHub with Copilot seats, Copilot code review is there and costs you credits rather than a new contract.

Graphite is orthogonal. Adopt it because you want stacking and a merge queue, not because you want a reviewer.

What PR Lens does not do

It does not find bugs. It will not tell you the token comparison is not constant time, it will not flag the SQL injection, and it will not rank findings by severity. If a diagram is the only thing reviewing your pull requests, you have a gap, and one of the finders should fill it.

It also does not replace reading. It changes the order: you see the shape, then you know which twelve of the four hundred lines to read carefully. PR Lens vs Greptile is the clearest version of that split, because Greptile and PR Lens both read the whole codebase and then do opposite things with it.

If you are looking for a free option

Maintainers get a decent deal in 2026. CodeRabbit is free on public repositories, Greptile is free for qualified MIT and Apache non-commercial projects, and PR Lens is free for open source and open source itself. I keep a dated list in Free and open source AI code review tools for maintainers.

And if you would rather not add a bot at all, writing the diagram yourself in the PR description is a real option with real costs. PR Lens vs writing a Mermaid diagram yourself is the honest version of that trade.