An overview of sixty AI code reviewers
Sergii Makarevych surveys 63 AI code-review products, comparing what they read, how they filter findings, what actions they can take, whether they learn, and how they bill. The article argues that AI reviewers cannot replace the broader purposes of human review, including maintainability, shared understanding, and agreement on what is being built.
textSergii Makarevych (@sermakarevich) · Nov 3, 2026 · x.com · Saved Nov 4, 2026
automated code review, code review, pull requests, coding agents

Quick grasp
What. An AI code reviewer puts a language model between a pull request and its merge button. The product collects the change and some context, asks the model for findings, filters them, and posts what survives. That much is the whole of every product in this survey. The sixty-odd products differ on five choices stacked on top:
- Reads. What the model may read beyond the diff.
- Decides. How findings are filtered before they are posted.
- Acts. What the product may do with a finding: comment, patch, commit or approve.
- Learns. Whether it learns from the team's reactions.
- Bills. Which meter it charges on.
Most products differ from their neighbours on one or two of the five and copy the rest. The earlier piece gave a code review four jobs:
- Find defects.
- Keep the code easy to change.
- Spread knowledge of the code across the team.
- Agree on what is being built.
Every product here is sold on the first. What it reads decides how much of the second it does. None does the other two.
Why it exists. Coding agents open pull requests faster than humans read them, so review became the bottleneck, and the answer sold by sixty vendors is a second model call. The market shape follows from who sells the call:
- Git hosts and model vendors bundle review to sell their platform.
- Coding-assistant vendors add review to keep the loop inside their product.
- Static analysis vendors bolt a model onto a scanner they already sell.
- Standalone bots must win on context or on price, and in the last 18 months several of them were bought, retired or re-priced.
How, in five steps.
It receives the pull request event from the git host and decides whether to run. The trigger is one of these:the pull request opens; every push; a command in a comment; a risk tier.
It gathers context. The diff always, plus some of these, depending on the product:files it fetches on demand; a pre-built index of the repository; the linked ticket or spec; the team's rules file; the test suite, run in a sandbox; the failing CI log.
It produces candidate findings and filters them with a grader, a verifier or a confidence threshold. The findings come from one of these:one model pass; several passes; a set of specialists; an agent loop.
It acts on the findings, from least to most authority:posts comments; attaches suggested patches; commits a fix; hands the finding to a coding agent; approves or blocks the merge.
It bills on one of these meters:per seat; per review; per credit; per kilobyte of diff; per token; bundled in a plan you already pay for; nothing, because you bring your own model key.
When to care. The day the first coding agent opens a pull request, as the earlier piece argued, because code written by an agent needs a different review from code written by a person. The reviewer may be the same model that wrote the change. The intent sits in a prompt and a session the reviewer never saw. The mistakes come from missing context more than from carelessness, so they repeat until someone changes what the agent reads. Choosing a product is choosing how your review answers those three facts: what it reads to recover the intent, whether it is a different model from the writer, and whether its lessons reach the agent or only the reviewer. The meter and the approval switch matter too, but they follow from that choice and are not the reason to start.
Important: Every product reads the diff. The differences you pay for are what else it reads, what it is allowed to do with a finding, and which meter it bills on.
What it means for us: Pick the meter and the authority level first and the vendor second. Two products in the same family with the same catch rate can differ by a factor of fifty in monthly cost at the same pull request volume. Why it matters: The agents that write your pull requests are about to double the count. The meter decides whether that doubling lands on the vendor or on you.
The level tree
- Level 1: the map. Sixty-three products in seven families by who sells them, with the launches, exits and re-pricings of the last 18 months.
- Level 2: what it reads. The context ladder from diff only to the CI log, and the instruction file that every reviewer now shares with the coding agent.
- Level 3: how it decides. Pipeline shapes from one pass to agents plus a verifier, and effort levels as the knob that moves both score and price.
- Level 4: what it may do. From a comment to an approval that counts, and who ships the approval switched on.
- Level 5: whether it learns. Reactions, mined history, memories, and the number no vendor publishes.
- Level 6: how it bills. Eight meters, one example team at two volumes, and the drift from seats to usage.
- Level 7: reading the comparisons. Thirteen head-to-heads, who ran each, and why one product scores 22 on one set and 82 on another.
- Level 8: fit. Which family for which team, and when building your own is the cheaper option.
- Products observed, a decision guide, takeaways, references.
Level 1: The map
This level answers: who is selling me this, what else do they sell, and how many of them will still exist next year?
The survey found 63 products or product lines with a public page, after checking and dropping at least 64 more candidates that turned out to be diff viewers, linters without a model, merge queues, dead domains or hobby repositories under a hundred stars. Of the 63, eight are retired, retiring or of doubtful liveness, and seven changed owners since mid-2025. The products sort into seven families by who sells them and why, and the family predicts the other four choices better than the vendor's own label does.
Family 1: standalone hosted bots. Review is the product. Nineteen entries: CodeRabbit, Greptile, Qodo, Graphite, Macroscope, Ellipsis, Baz, cubic, Bito, Kodus, Entelligence, Sourcery, Tenki, Dromeas, Revix, Stage, Gitar, Korbit and Squire. These compete directly with each other and with the bundled families below, so they are the ones that innovate on context and the ones that get bought. Graphite was acquired by Cursor in December 2025, Gitar by Sonar in May 2026. Korbit and Squire show no activity in 2026. This family runs every benchmark in Level 7 and publishes most of the learning loops in Level 5.
Family 2: platform natives. A platform you already pay for added a reviewer: GitHub Copilot code review, GitLab Duo code review, Copilot in Azure DevOps, Atlassian's Rovo Dev reviewer for Bitbucket and GitHub, Vercel Agent review, Harness AI code review, LinearB's reviewer inside its gitStream workflow engine, and Sentry's Seer review. Eight entries. Their advantage is distribution and data the standalone bots cannot reach: Copilot's reviewer sits in the merge box of the largest git host, Sentry's reads production errors, Atlassian's reads the Jira acceptance criteria. Their weakness is that review is a feature, and features get re-priced: GitHub moved review from premium requests to metered AI credits in June 2026, GitLab moved to a flat quarter-credit per review in March 2026, Vercel moved from a flat fee per review to tokens in June 2026, and Atlassian is folding its standalone developer product into Rovo credits from December 2026.
Family 3: model-vendor natives. The companies that train the models sell review as a surface for the model: Claude Code Review in its managed form and as a local command with an expensive variant called Ultrareview, OpenAI's Codex review, Google's Gemini Code Assist on GitHub and the critic step inside its Jules agent, and Amazon's line from CodeGuru through Q Developer to Kiro. Six entries, two of them retiring: Google stopped new sales of the GitHub reviewer in October 2026 and Amazon is retiring CodeGuru and the Q Developer reviewer. The two that remain read the repository with the vendor's own agent, read the team's agent instruction file, and bill by tokens or inside the chat subscription.
Family 4: coding-assistant add-ons. The vendor sells an editor or an agent and added review so the loop stays in its product: Cursor Bugbot, Devin Review together with the free Quick Review inside Windsurf, Amp Review, Augment, Zencoder, Tabnine, Factory's Droid review, JetBrains Junie, Kilo, Sweep and Continue Checks. Twelve entries, three of them gone or going:
- Continue was bought by Cursor and its Checks product closed.
- Tabnine was bought by Tricentis and its review page now redirects.
- Sweep pivoted from a pull request bot to a JetBrains assistant.
Augment's standalone bot is being sunset after Harness bought its assets in October 2026, while Augment's review inside its agent fleet continues. The add-ons have the easiest path to a fix: the same agent that found the problem can be told to repair it.
Family 5: static analysis and security vendors with a model layer. Semgrep, Snyk, SonarQube, DeepSource, Aikido with the Trag team it acquired, Pixee, CodeScene, Codacy, CodeAnt and Panto. Eleven entries counting Trag. The scanner finds the candidate with rules or data flow, and the model triages, explains or writes the fix. Two of them, Codacy and CodeAnt, added a general LLM reviewer beside the scanner; Sonar bought one. Snyk is the clearest case of the family's limit: it has a fix model and a data-flow engine and no feature that reads a diff and comments on general bugs.
Family 6: open source and do it yourself. PR-Agent, Gito, Shippie, PR-AF, Alibaba's Open Code Review, the OpenHands review plugin, and a line of generic GitHub Actions that pipe a diff to a model. Seven entries. Free to run, you pay the model bill, and they run on every git host from a single config file. PR-Agent is the notable case: it began inside Qodo and moved to a community organisation in 2026, with Qodo as sponsor, so the hosted and the free product now share a lineage but not a roadmap.
Family 7: in-house. Fifteen companies have published how their own reviewer works: Cloudflare, Uber, Meta with three systems, Google, Atlassian, DoorDash, Wealthfront, Ionix, Upsun, Microsoft, Anthropic's internal use of its own product, Ericsson, and Shopify's chief technology officer on a podcast saying no product does what he wants. Level 8 returns to them, because they publish the one number the products do not: cost per review.
The last 18 months in one list, so that the churn is visible:
- Acquisitions: Trag by Aikido (August 2025), Graphite by Cursor (December 2025), Gitar by Sonar (May 2026), Continue by Cursor (June 2026), Tabnine by Tricentis (July 2026), Augment's assets by Harness (October 2026). Six of 63 products changed hands, all of them standalone or add-on reviewers, none of them platforms.
- Retirements: Gemini Code Assist on GitHub, CodeGuru and the Q Developer reviewer, Continue Checks, Augment's standalone bot, Rovo Dev as a standalone product, CodeRabbit's Lite and Pro Legacy plans, Sweep's pull request bot. The platform natives retire features; the standalone bots retire companies.
- Re-pricings: Cursor Bugbot from a 40 dollar seat to usage (June 2026), GitHub Copilot review from premium requests to AI credits (June 2026), Vercel from 30 cents a review to tokens (June 2026), GitLab to a flat 0.25 credit per review (March 2026), Greptile from seats with included credits to credits only (during 2026). Five of the ten most-used products changed their meter in one year, every one of them toward usage.
Carry forward:
- The family predicts the meter and the authority level: platforms bundle and meter usage, standalone bots sell seats and learning loops, model vendors bill tokens, add-ons bill through the assistant, scanners bill contributors.
- The products most likely to be bought or closed are the standalone bots and the add-ons; the products most likely to be re-priced are the platform natives.
- Count the live products at about 55, not 63; two retirements in the model-vendor family and three in the add-on family happened in the twelve months before this survey.
Level 2: What it reads
This level answers: beyond the diff, what can each reviewer see, and where does it get its instructions?
The products sit on a ladder of context, and each rung costs the vendor something, which is why the rung is the first thing a product page is vague about. From the bottom:
- The diff and nothing else. The generic GitHub Actions that pipe a diff to a model, the single-pass add-on review in GitLab, Sourcery, Tenki, Stage's ordered reading sections, and Graphite, whose documentation still marks related-file context as coming soon in a product that Cursor bought ten months ago. This rung cannot cite the spec, and on 350 real pull requests frontier models given the diff alone found 15 to 31 percent of the issues human reviewers had flagged (SWE-PRBench).
- The diff plus files fetched on demand. An agent with a file tool reads what it decides it needs. Cursor Bugbot, GitHub Copilot, OpenAI Codex, Claude Code Review, Amp, Kilo, Shippie, the OpenHands plugin, JetBrains Junie and Factory's Droid work this way. Macroscope adds parsers for seven languages so the agent can follow a call across files instead of guessing a path.
- A pre-built index or graph. The vendor indexes the repository before any pull request arrives and the review queries it: Greptile's repository graph of callers and callees, Baz's embedded units with similarity retrieval, Bito's symbol index with abstract syntax trees and embeddings, Qodo's Software Map, cubic's full-codebase and cross-repository reading, Zencoder's multi-repository index. This is the rung that makes a review of one repository aware of another.
- A pre-scan bundle with no further fetching. GitLab's Code Review Flow gathers diffs, directory listings, related files, tests and dependencies first, then runs a model over that bundle, and the model cannot ask for more. The bundle is capped near one megabyte and truncated to about 800 kilobytes, and files over 10,000 lines send only their diff. It is the one documented design that spends its context budget before the model sees the change.
- A clone in a sandbox with tools running. CodeRabbit clones the repository and runs fifty or more linters and analyzers before its agents start. Ellipsis gives each reviewer an environment with install hooks so it can run the tests. Vercel writes a patch for each finding, runs the real build, tests and linters on it, and shows only the suggestions that pass. Claude's Ultrareview reproduces every finding before reporting it. Greptile's TREX agent and Baz's spec reviewer start the application from the branch.
- Things outside the repository. Linked tickets: cubic reads Linear, Jira, Asana and GitHub Issues and checks the change against their requirements; Codacy reads the Jira key and its parent epic; Atlassian's reviewer reads the Jira acceptance criteria; Kodus compares the change with a Jira or Linear ticket; Qodo and Baz read Figma for interface deviations; Gito pulls ticket text when configured. CI logs: CodeRabbit reads failure logs from GitHub Actions, GitLab CI, CircleCI, Jenkins and Azure Pipelines; Gitar reads the failing pipeline and fixes it; Vercel answers "why is this failing" in the pull request. Production data: Sentry's reviewer predicts which errors a change will cause from the errors it already tracks, Harness cites past incidents from its delivery history, Entelligence takes production and incident context as input. Each of these is one product or two, not a trend.
Set against the five things the earlier piece said the diff does not carry, the ladder covers two and a half:
- Why the change was made. Supplied by the ticket readers and by nothing else.
- The decisions taken on purpose. Supplied only if the team wrote them into the instruction file, which fourteen products now read.
- How the application is maintained. The same: only through the instruction file.
- What the team knows. Supplied by no product, because no file holds it.
- Where the application is going. Supplied by no product either.
The same piece carried the measurement that puts the ticket rung in proportion: adding the ticket text to Atlassian's production reviewer moved its results by one to three points, written guidelines moved its judge score by about five, and context files written by a model measured negative on the agent's task success. The short, human-written conventions file is the rung with the measured effect, and it is the one that every reviewer on this list now shares with the coding agent.
The second thing a reviewer reads is its instructions, and here the market converged in one year on a file it did not invent. The coding agents' instruction file, usually called AGENTS.md or CLAUDE.md, is now read by at least 14 reviewers: Vercel lists eleven such files in priority order with a 50 kilobyte cap, from AGENTS.md and CLAUDE.md through Cursor, Windsurf, Cline and Roo rules to CONVENTIONS.md; Greptile reads eleven as well, including its rivals' files, so a team can switch bots without rewriting rules; cubic auto-detects README, AGENTS.md, CLAUDE.md, Cursor rules, Copilot instructions, the CodeRabbit file and four agents' skills folders; Baz reads AGENTS.md and CLAUDE.md at any depth plus the Cursor, Claude, CodeRabbit and Bugbot files, converts them into scoped guidelines, keeps only rules checkable by reading code, and cites the file in every finding; CodeRabbit, Bito, Kodus, Copilot, Shippie and Kilo read AGENTS.md or CLAUDE.md; Codex reads the closest AGENTS.md and takes its review rules from a heading inside it. The exceptions are telling. Cursor Bugbot reads only its own BUGBOT.md file and explicitly ignores the Cursor rules folder that Cursor's own agent reads. GitLab's documentation says the Flow does not read AGENTS.md. Macroscope, Graphite, Gemini and Azure DevOps keep their own rule formats with character caps of 4,000 in Azure's case.
Which branch the instructions come from is a security property, and only three vendors state it. Claude Code Review reads its REVIEW.md from the base or default branch and never from the pull request's own changes. Cursor Bugbot reads its settings from the base branch for the same reason. GitHub Copilot reads its instruction files from the head branch, which means a coding agent that opens a pull request can also edit the instructions its reviewer will follow. Nothing in the Copilot documentation I read calls this out.
Size limits are the quiet third thing. Claude's local review defaults to 500 files and 8,000 changed lines. Atlassian's reviewer may post nothing above 10,000 changed lines or on repositories over 20 gigabytes. Sourcery counts diff characters, 300,000 per pull request on its cheaper plan. Bugbot skips pull requests over a size limit and does not bill the skipped run. The 20 percent of pull requests over 1,000 lines in the mix of the example team in Level 6 is where several of these products go silent, and silence is reported differently by each: a comment, a neutral check, or nothing.
Important: Of 63 products, about 15 index or clone the repository, about 12 read the linked ticket, 3 read CI failure logs and 2 bring production error data. Every one of them reads the diff, and most of the rest of the context is one vendor's distinguishing feature rather than a shared capability.
What it means for us: Decide where your defects live before you pick the rung. If they are visible in the diff, the bottom rung catches them and the rest is noise reduction. If they are spec mismatches, only the ticket readers and the index readers can cite the spec, and only if the spec is written down; and the measured gain from ticket text is small next to the gain from a written conventions file. Why it matters: More context is not automatically better. In two independent studies, SWE-PRBench and AACR-Bench, adding repository context to a frontier model made precision worse, because the extra material produced extra speculation. The products that read more are charging you for reading and for filtering what the reading produces, and the filter is the part to test.
Carry forward:
- Fourteen reviewers read the same instruction file the coding agent reads, so a team writes its rules once; Bugbot and GitLab are the large exceptions.
- Only Claude Code Review and Bugbot state that instructions come from the protected branch; Copilot reads them from the branch under review.
- Tickets, CI logs and production errors are each read by a handful of products, and the handful is where the real differentiation in context is.
Level 3: How it decides
This level answers: between the context and the comment, what does the product do, and what does the effort knob buy?
Six pipeline shapes cover every product whose documentation describes one, and about a third of the products describe none.
- One pass. One prompt, one answer, posted. The generic actions, PR-Agent's one call per command at about 30 seconds each, GitLab's single-pass add-on, Sourcery as its rate limits imply. PR-Agent has a self-reflection filter with a score threshold that defaults to zero, so by default nothing is filtered. One of the open-source actions runs two providers over the same diff and merges by file and title, which is the cheapest form of the next shape.
- Parallel passes with a vote. Cursor's first Bugbot ran eight passes over the same change and kept what several agreed on. Cursor replaced that with an agent design in late 2025, and no current product documents voting as its main mechanism, though Dromeas keeps a council of models that must agree before a finding is posted.
- Specialists and a judge. Several agents each with one concern, then a step that merges, deduplicates and relabels. Baz runs correctness, quality, basic security, advanced security and coding-guideline agents with severities High, Medium, Low. Bito runs performance, structure, security, optimisation and scalability reviewers and combines them. Dromeas runs seven. Ellipsis lets a team define up to 64 reviewers in YAML, each with its own prompt, model, path filter and budget. Amp spawns one agent per Markdown check. This is also the shape of the published in-house systems: Cloudflare's coordinator with up to seven specialists and a judge pass, Uber's three assistants and a grader with a threshold.
- Agents, then a verifier. Candidates are generated, then a separate step tries to confirm or kill each one. Claude Code Review names its stages find, verify, rank, post. Ultrareview reproduces each finding. cubic's Ultrareview runs multiple passes with the strongest models for about nine minutes. PR-AF makes each reviewer agent defend its finding against a challenger. In-house, DoorDash's third version adds a "disprove it" pass, Wealthfront runs one model as prosecution and another as defence, and Meta's Spotlight pairs a generator with a critic.
- Scanner first, model second. Rules or data flow find the candidate, the model triages, explains or fixes. Semgrep labels each finding a likely true or false positive and proposes a fix. Codacy, CodeAnt and DeepSource run static analysis and then an agent over the results. CodeRabbit runs its fifty analyzers before its agents. Snyk, Pixee and Sonar's CodeFix go straight from scanner finding to patch and never review the diff in general.
- A purpose-trained model instead of a general one. Windsurf's Quick Review runs SWE-check, a bug detection model Cognition says is up to ten times faster than a deep review agent. CodeScene scores code health from git history deterministically and brings in a language model only to propose refactorings. Atlassian's in-house pipeline gates a zero-shot generator with a judge and a small classifier.
Nearly every product with a usage meter now exposes an effort knob, and the knob is where the price list and the benchmarks meet. Copilot sells Lite, Balanced and Max at an estimated 25 cents, 1.50 dollars and 10 dollars a review. Greptile sells Base, Plus and Apex at 1, 3 and 10 credits of a dollar each. Macroscope sells Budget, Balanced, Precise and Ultra at 2.5 to 20 cents per kilobyte of diff. Bugbot has Low, Default, High and Smart, where Smart picks a level from the title, author and a trimmed diff. Claude's local review runs from low to max and the managed service from Quick to Deep. Augment has Thorough and Precise, Qodo has Exhaustive and Precise, Factory has deep and shallow. Cloudflare's in-house system tiers by lines changed: up to ten lines gets two agents on a cheaper model, up to a hundred gets four, more gets the full seven.
What the knob buys is measurable from the public comparisons, and the answer is a few points of recall for a large multiple of price. On Macroscope's model benchmark the most expensive configuration scores 83.9 at 11.58 dollars a pull request and ten minutes, and a mid-effort cheaper model scores 73.5 at 28 cents and about a minute: ten points for forty times the price. On GitHub's open ReviewBench, Copilot Max scores 42.4 and Copilot Lite 36.4 at a published price ratio of forty. GitHub's own A/B test found an ensemble of cheaper Lite reviews addressed 8 percent more findings and cut cost 8 percent against a single stronger run. DoorDash's bench found its scout-plus-strong-model pipeline cost about five times its single-cheaper-model pipeline for about 1.75 times the recall. Nobody has published a case where the top effort level pays for itself in defects per dollar, and the vendors who sell the levels do not claim one.
Models are mostly undisclosed. Of 63 products, those that name the model behind the review are the ones where you choose it: Kilo, Ellipsis, Kodus, Amp, Alibaba's tool and the open-source actions. GitLab names a Claude model served through Google's agent platform. PR-Agent's default configuration names its model. Macroscope names the model behind its check agents. Everyone else says "best-in-class" or nothing, and Claude Code Review states that administrators cannot choose. For a buyer that means the product's quality can change under you with no notice and no changelog line, in either direction. It also means you cannot tell whether the reviewer is the model that wrote the code. The earlier piece reported that review pairs from the same vendor found the same planted errors 52 to 62 percent of the time and pairs from different vendors 37 to 46 percent, so a second reviewer is worth more when it is a different model, and a product that will not name its model cannot promise that.
Important: Products designed or redesigned in 2026 have a verification step between generating findings and posting them. Products designed in 2024 and 2025 post what the model returned, filtered at most by a threshold that often defaults to off.
What it means for us: Ask whether a finding is checked before it is posted and by what. In GitHub's open benchmark nearly every product scores 84 to 90 on precision as graded by its model judge, so the verify step has become the entry ticket, and recall is what still separates them. Why it matters: The verify step is what the effort levels charge for. A reviewer that verifies at Lite effort is a different product from one that generates at Max effort, and the price list does not tell you which you are buying.
Carry forward:
- Specialists plus a judge is the shape in-house teams build and the shape the standalone bots describe; the agent-plus-verifier shape is the 2026 addition.
- Effort levels buy a few points of recall for ten to forty times the price on every published comparison that reports both.
- Model names are disclosed only where you pick the model, so the product's quality can drift under you.
Level 4: What it may do
This level answers: once it has a finding, what is the product allowed to do, and who switched the approval on?
Authority rises in seven steps, and every product's documentation puts it on one or more.
- Before the pull request exists. Windsurf's Quick Review reads the local tree before a push, Claude's local review command reads the working tree, Junie runs read-only in the editor and the CLI, Amp reviews in a thread, and Google's Jules critic reviews the agent's own patch before the agent submits it. Nothing is posted anywhere.
- Comments only, with an explicit promise. Copilot in Azure DevOps "always leaves a Comment review", never approves or requests changes, and does not satisfy required-reviewer policies. Claude Code Review posts a check run that never concludes as a failure and "never approves and never blocks". Atlassian's reviewer posts comments only when it finds issues. Stage, Codex, Jules and Tenki post comments and nothing else.
- Suggested patches the author can apply in one click. Copilot, CodeRabbit, CodeAnt and Macroscope attach suggestions. Vercel attaches only suggestions that passed the build and tests in its sandbox.
- A status check that can block. CodeRabbit's pre-merge checks, Macroscope's check run agents, Ellipsis's pass or fail, Sentry's check, Sonar's quality gate, CodeAnt's gates, Harness's merge gating. Bugbot's check is neutral unless a setting makes it fail on unresolved issues. Devin blocks only if the host marks its commit status as required.
- Commits to the branch. Bugbot's Autofix commits or opens a branch, up to three attempts per pull request, billed as agent usage. Gitar commits fixes and CI repairs, "only on green". Vercel commits on command. Baz's Fixer, cubic's auto-fix, DeepSource's Autofix, Augment's PR Fixer, Macroscope's fix-it-for-me, Devin's Auto-Fix and Snyk's Agent Fix commit or open a pull request. Pixee only ever opens fix pull requests. Kiro and Codex start a cloud task that can push. A reviewer that edits needs the do-no-harm gate the earlier piece asked for: Vercel and Gitar run the build and the tests before anything is committed; for the others the documentation says that a fix is committed and not that it is checked, so read that before switching the step on.
- Hands the finding to a coding agent. Bugbot to the Cursor agent, Copilot to its cloud agent in preview, CodeAnt with a "Prompt for AI Agent" button, cubic to several agents, Amp by piping its output into the main agent. This is the step the add-on family does by design and the standalone bots reach through plugins.
- Approves. Thirteen products have an approval path: GitHub Copilot, GitLab Duo, Greptile, cubic, Devin, Macroscope, CodeRabbit, Ellipsis, Baz, Factory, LinearB, Gitar and Augment. Kodus has an auto-approve documentation page I did not read. Stage syncs approvals made in its interface. PR-Agent has an auto-approval setting that defaults to off and a code path that is commented out. Only Baz and LinearB go further: Baz's Merger agent returns merge, reject or escalate, and LinearB routes and auto-approves inside a workflow engine. Devin's documentation says its approver "does not merge".
Who ships the approval switched on is the useful question, and the answer is almost nobody. Copilot's approval is off by default and when an administrator enables it, it is the only one in the survey that satisfies a required-approval rule; a new push dismisses it. GitLab's is beta behind a feature flag, off by default, and even when on "does not count toward required approvals". Greptile's is beta and fires only on a clean five-of-five confidence under a risk cap. cubic ships it disabled with a Shadow mode that records what it would have approved and a Live mode with policies for low-risk only, a never-approve list of paths, and an option to exclude external contributors. Macroscope's Approvability is off, GitHub only, has a Preview Mode, never approves Macroscope's own pull requests and is described as not a fail-closed gate. CodeRabbit's is off and needs a paid tier. Devin's native approve and its rubric-based Autoapprover are beta, re-check on every push and can withdraw. Ellipsis approves only if the configuration says so and never when a reviewer stopped early. Baz approves only through a rule with limits on repositories, authors, paths, line counts and severity. Factory is the one product whose documentation says it approves when it finds no issues, with no switch described. Gitar's approval is on its Pro plan. Augment's Risk Analyzer approves low-risk changes with a stated justification.
The only large-scale evidence on machine approval comes from inside Meta. Its RADAR system auto-approves low-risk diffs and had handled more than 535,000, landing more than 331,000, an approval rate of 60.31 percent. The diffs it approved had a revert rate one-third of, and an incident rate one-fiftieth of, the diffs it did not handle. Those numbers describe selection as much as judgement: RADAR picks the diffs it is confident about, so the comparison group is the harder diffs. The useful part for a buyer is the shape of the deployment: a risk model decides which pull requests the approver may touch, the approver runs only there, and the reverts are measured. cubic's Shadow mode and Macroscope's Preview mode are the commercial versions of that shape.
Two more authority details matter when agents write the pull requests. Several products exclude bot authors by default: Greptile does not spend credits on pull requests from dependency bots, and Sentry excludes accounts marked as bots from its contributor count. Atlassian's reviewer runs only when the author triggers it, which an agent cannot. And a reviewer that reads its instructions from the head branch, as Level 2 noted for Copilot, can be told by the pull request what to approve.
Important: Thirteen of 63 products can approve a pull request. In nearly all of them the switch ships off, is in beta, or runs in a shadow mode, and only Copilot with an administrator's consent counts toward a required approval.
What it means for us: The approval decision is yours, not the vendor's, and the two safe ways to make it are already in the products: run a shadow mode for a month, then compare what it would have approved against what was later reverted, which is the escaped-defects-per-reviewed-change number the earlier piece named as the one that is hard to game. Why it matters: The one published deployment of machine approval at scale, inside Meta, approves 60 percent of changes and measures the revert rate of what it approved. No commercial vendor publishes that number for its own approver.
Carry forward:
- Comment only is the default for the model vendors and the platform natives; commit-and-fix is the default for the add-ons; approval is a paid, off-by-default feature of the standalone bots.
- Only Copilot's approval can satisfy a branch protection rule, and only when an administrator turns it on.
- Shadow modes exist in two products and are the right first step for anyone switching an approver on.
Level 5: Whether it learns
This level answers: when the team pushes back on a finding, does the next review change, and can anyone see how?
Four mechanisms appear in the documentation, and roughly half the products have none.
- An explicit command. CodeRabbit stores "learnings" from replies addressed to it, shows them in a settings page behind an administrator gate, and exports them only on Enterprise. CodeAnt stores an instruction given in a reply. Kodus has a remember command with an optional approval gate for model-generated memories. Bugbot has a remember command too. Semgrep's triage memories record why a finding was marked a false positive and apply that reason to similar findings later.
- Reactions and replies read automatically. Greptile learns from thumbs up and down, from replies, and from comparing a pull request's first and last commit to see which suggestions were taken. cubic turns a reply into a learning only if it states a reusable rule, can create, improve, remove or keep a learning, and runs a weekly cleanup that merges duplicates and archives weak ones. Bugbot mines rules from reactions, replies and human reviewer comments when a pull request is merged or closed, promotes the ones that gather positive signal and disables the ones that gather negative signal with no thresholds published, and bills each learning run as usage. Bito learns only from negative feedback. Baz creates a memory when similar feedback arrives more than once, versions the resulting reviewer prompt, and lets a team revert it or turn new memories off by default.
- Mining the team's history. Qodo's Rule Miner, in beta, turns years of accepted human review comments into rules, weights them by code ownership and decays them when ignored. cubic mines "senior reviewer" learnings from named engineers' past comments. Revix extracts rules from the existing code and names the rule in every comment. Baz recommends reviewer prompts from recurring feedback. Augment's review memory captures comments, reactions, addressed changes and the outcome at merge, weighting explicit human feedback higher. Continue's retired Checks were set up by an agent reading past review comments with the GitHub CLI. In-house, DoorDash builds reviewer profiles from AGENTS.md, pull request history, Slack and incidents.
- Nothing, or memory of facts only. PR-Agent has no learning loop. Macroscope describes none. Copilot's memory stores repository facts, and whether a reaction changes a later review is not documented. GitLab's Flow reuses earlier threads on the same merge request only. Graphite shows a dashboard of downvote and acceptance rates and states no learning. Claude Code Review, Codex, Sentry and the platform natives generally describe no loop.
Three properties separate the loops that are safe to run from the ones that are not:
- Visibility. Whether the team can read the rule the product learned. CodeRabbit, cubic, Baz, Kodus, Greptile, Qodo and Revix show learned rules in an interface; Bugbot's are auto-promoted and shown in its dashboard; Semgrep's memories were not confirmed as editable.
- A gate. Whether a human approves a learned rule before it applies. Kodus and Baz have one, CodeRabbit gates who may teach, cubic gates by requiring a reusable rule. Bugbot's auto-promotion and its billing of learning runs put the cost of the loop on your meter and the control with the vendor.
- Where the rule goes. The property the earlier piece ended on, and the one no product has.
Every mechanism above changes the reviewer. None of them writes anything into the instruction file the coding agent reads, so the learned rule silences the comment on the next pull request and leaves the agent making the same mistake, and of the fourteen products that read AGENTS.md none documents writing to it. The practice the earlier piece held up, Google's per-check not-useful rate with an owner and a threshold that disables the check, has no commercial equivalent either; Graphite's dashboard of downvote and acceptance rates is the closest surface, and it is per product, not per rule.
The number no vendor publishes is how much the loop changes precision or acceptance. Cursor comes closest, with a resolution rate rising from 52 percent in July 2025 to 78 percent in April 2026 and more than 44,000 learned rules across more than 110,000 repositories, but the rate is judged by a model and spans every other change the product made in those months, so it cannot be attributed to the loop. The closest figures that isolate written rules come from in-house systems. Atlassian's team found that adding written guidelines raised its judge score by about five points, against one to three for the ticket text. Cloudflare wrote that telling the model what not to flag "is where the actual prompt engineering value resides". Uber reports that 75 percent of its reviewer's comments are rated useful and more than 65 percent are addressed, against 51 percent for human comments, but does not separate the learning loop from the rest. Semgrep is the one vendor that publishes a weak number about itself: 41 percent agreement with human experts on which findings are false positives, in an older engineering post. The field data on a commercial product without a visible loop is sobering: a study of CodeRabbit comments in open-source repositories found 36.4 percent accepted, 7.3 percent discussed and 56.3 percent rejected (arXiv 2607.03316). Whether a learning loop moves that split is the experiment nobody has published.
Carry forward:
- About half the products learn from reactions or history; the standalone bots do, the platform and model-vendor natives mostly do not.
- Visible, gated rules exist in seven products; auto-promoted rules billed to your meter exist in one.
- No vendor publishes how its learned rules change precision, so the loop is a feature you test yourself, by reading the rules it learned after a month.
- The loop changes the reviewer and never the agent; the rule that would prevent the mistake has to be moved into the instruction file by hand.
Level 6: How it bills
This level answers: what is the meter, what does the example team pay at 300 and at 600 pull requests a month, and why did five vendors change the meter in one year?
Eight meters cover the paid products. Each is listed with the vendors on it and the price they publish.
- A seat per developer, reviews unlimited. CodeRabbit at 24, 48 and 72 dollars a month on annual billing, charged only for developers who open pull requests, with a per-file overage and an hourly cap of 5 to 12 reviews per developer. Graphite at 20 and 40 dollars. Sourcery at 12 and 24 dollars with limits counted in diff characters. Codacy at 18 dollars for every git contributor. Revix at 20 and 40 euros. Stage at 30 dollars. Gitar at 20 and 40 dollars. Squire and Korbit at 12 to 50 dollars on pages of uncertain age.
- A seat plus an allowance of lines. cubic at 40, 99 and 200 dollars for 40,000, 80,000 and 160,000 reviewed lines, pooled, with generated files discounted. Bito at about 12 dollars with 5,000 lines included and 5 dollars per extra thousand. DeepSource at 24 dollars plus 8 or 15 dollars per 10,000 processed lines beyond a 100 dollar yearly credit.
- Credits per review, priced by effort. Greptile at 1, 3 or 10 dollars a review by tier, no seats, bot authors excluded. Qodo at 1.2 cents a credit in pooled packs from 30 dollars, about 139 credits and 1.67 dollars a review by the vendor's own pack sizes. GitLab at a flat quarter credit, about 25 cents, "regardless of merge request size". Atlassian at 2,000 credits a developer, 20 to 75 reviews. Dromeas at 25 cents a credit with an unpublished credit count per review. Entelligence at 750 dollars for 300 reviews and 15 engineers, 1 dollar per extra review.
- Kilobytes of diff. Macroscope alone: 2.5 to 20 cents a kilobyte by mode with a minimum of 25 cents to 2 dollars a review, each push billed as its own review, no seats, and a vendor average of 95 cents with a median of 50 cents.
- A run, on every push. Cursor Bugbot since June 2026: no seat, an average of 1.00 to 1.50 dollars a run by the vendor's claim, one run per push unless a setting limits it to one per pull request. Learning runs and Autofix are billed on top.
- Tokens plus a fee. GitHub Copilot converts tokens to credits at a cent each, plus Actions minutes on private repositories, with the vendor's estimates of 25 cents, 1.50 dollars and 10 dollars a review by effort; Azure DevOps bills the same meter to an Azure subscription. Claude Code Review bills tokens to the organisation with "no flat per-review price" and a March 2026 vendor average of 15 to 25 dollars that the October documentation no longer repeats; Ultrareview shows 5 to 25 dollars in a dialog before each run. Ellipsis bills provider tokens plus 10 percent and no seats. Augment bills provider tokens plus 40 percent inside flat plans of 20 and 100 dollars. Vercel bills the provider rate plus 25 cents per million tokens. Kilo, Kodus, Amp and JetBrains bill tokens at the provider rate with no markup, and Kodus adds an 8 dollar seat.
- A contributor, counted by activity. Sentry at 40 dollars per active contributor with two or more pull requests in the month, bots excluded. Semgrep at 30 dollars a contributor with 20 AI credits each. Snyk at a flat 25 dollars for up to ten developers, then one credit per active contributor per day. CodeScene at 18 and 27 euros per author who committed in the last three months. SonarQube at 34 dollars for up to 100,000 lines in the repository, a meter that ignores pull requests entirely.
- Bundled in something you already pay for. Codex inside ChatGPT plans from 20 dollars a seat with no stated review quota. Gemini's reviewer inside a Code Assist seat with a quota of at least 100 reviews a day. Devin's reviewer in agent compute units from a shared pool, with public pull requests free on its website. Jules's critic inside a task quota. Windsurf's Quick Review free. Harness, Tabnine, Panto and Pixee publish no price at all; Pixee says it charges per finding resolved.
The example team has ten engineers, 300 pull requests a month, a median diff of 9 kilobytes, and one in five pull requests over 1,000 lines. Its monthly bill at 300 pull requests, from the published numbers, and the change when the agents double the count to 600:
- Seat plans hold still. CodeRabbit 240 to 720 dollars, Graphite 200 to 400, cubic 400 with the line allowance unspent, Sourcery 120 to 240, Codacy 180, Baz 300, Stage 300. The same at 600.
- Line meters rise with the lines. Bito about 410 dollars rising to about 950 because the included 50,000 lines are far below the team's 108,000. DeepSource about 240 in seats plus 86 to 162 in lines, the line part doubling.
- Per-review meters double. GitLab 75 to 150 dollars in credits above the Premium seats. Copilot Lite 75 to 150, Balanced 450 to 900, Max 3,000 to 6,000, above Business seats of 190 that include 190 dollars of shared credits. Macroscope 150 to 300 at the median, 285 to 570 at the average. Greptile 300 to 600 on Base, 3,000 to 6,000 on Apex. Qodo about 500 to 1,000. Bugbot 300 to 450 doubling to 600 to 900 at one run per pull request, and double that again if each pull request gets two pushes. Claude Code Review 4,500 to 7,500 doubling to 9,000 to 15,000 at the March average, before Team seats of 200 or 1,000.
- Contributor meters hold still if the agents are not counted. Sentry 400 dollars for ten active contributors; if the agent commits under a human account it stays 400, and if under a bot account the bot is excluded.
- Free: Windsurf's Quick Review, the open-source tools on your own key, where one action's maintainer reports a tenth of a cent per pull request on a small model and small fixtures.
The spread at 300 pull requests runs from nothing to 7,500 dollars a month for products that, on the independent benchmarks in the next level, land within 20 points of each other. At 600 the seat plans are the same price and every usage plan has doubled, which is the whole pricing story of 2026 in one sentence.
Who moved to usage, and when, in the vendors' own words. Cursor announced on 11 May 2026 that Bugbot would drop its 40 dollar seat for usage billing, with existing customers moving at their first renewal after 8 June. GitHub announced on 27 April 2026 that premium requests would become token-based credits from 1 June, writing that "a quick chat question and a multi-hour autonomous coding session can cost the user the same amount" and that "the current premium request model is no longer sustainable". Macroscope's pricing page answers "why usage-based instead of per-seat" with "Seats are no longer a useful proxy for how much code gets reviewed and processed." Greptile moved from seats with included credits to credits alone during 2026, Qodo from seats to pooled credits, Ellipsis from a 20 dollar seat to tokens plus 10 percent, Vercel from 30 cents a review to tokens, GitLab to its flat quarter credit in March, and Atlassian is moving its reviewer into Rovo credits in December. CodeRabbit, Graphite, Sourcery, Codacy, Bito and Kodus stayed on seats, and CodeRabbit added a per-file overage and agent minutes on top. Nobody moved from usage to seats.
Who is billed decides whose budget notices. GitHub bills the pull request author for automatic reviews, the requester for manual ones, and the organisation for bot-authored pull requests; Atlassian bills the author's credits and stops silently when they run out. Claude, Devin, Cursor, Qodo and Greptile bill the organisation or the account that enabled the reviewer. For a team where agents open the pull requests under a service account, the GitHub rule routes the whole cost to the organisation, and the Atlassian rule means the service account's credits decide whether reviews happen at all.
Open source gets reviewed free by eleven vendors on stated terms: CodeRabbit on public repositories, Greptile for OSI-licensed non-commercial projects, Sourcery, Korbit, Codacy and CodeAnt on public repositories, DeepSource up to 1,000 pull requests a month, Qodo and Gitar by application, Devin on any public GitHub pull request without an account, and GitHub's Actions minutes for Copilot review on public repositories. Macroscope, Bugbot, Claude, Graphite, cubic and Ellipsis publish no open-source offer.
Important: When agents write more of the code, a seat price falls per pull request and a usage price rises with it, and the meter decides which side of that line you are on. Five of the ten most-used reviewers moved to usage between March and June 2026, and none moved the other way.
What it means for us: At 300 pull requests a month the example team pays 120 to 720 dollars on any seat plan and 75 to 7,500 on a usage plan. At 600 the seat bill is unchanged and every usage bill has doubled. Ask two questions before the vendor's name: is the meter a seat or a run, and does a push count as a run. Why it matters: The vendors said why they moved. GitHub: a chat question and a multi-hour agent session "can cost the user the same amount". Macroscope: seats "are no longer a useful proxy". They are pricing for a world where the pull request count is set by agents, and the seat plans that remain are the ones betting that it is not.
Carry forward:
- Eight meters, and the only one that ignores pull request count entirely is the seat with unlimited reviews, which six standalone bots still sell.
- Vendor averages per review span a factor of a hundred, from a quarter to 25 dollars, for products within 20 benchmark points of each other.
- Per push versus per pull request is stated clearly by two vendors and left unstated by most; it is the multiplier that turns an estimate into a surprise.
Level 7: Reading the comparisons
This level answers: thirteen head-to-head comparisons exist, so why does the same product score 22 on one and 82 on another, and which number should a buyer believe?
The public record is thirteen comparisons that put several products on the same pull requests, plus a shelf of academic benchmarks that test models rather than products. Who ran each one is the first fact to read, because it predicts the winner.
- Vendor-run, vendor wins. Augment benchmarked seven tools on 50 pull requests and finished first at F1 59 with Bugbot at 49, Greptile 45, Codex 41, CodeRabbit 39, Claude Code 31, Copilot 25; it published the data. Macroscope tested 118 planted bugs across 45 repositories and caught 48.3 percent with 2.55 comments a pull request, against CodeRabbit's 45.8 percent with 10.84 comments, Bugbot's 42.4 with 0.91, Greptile 23.6 and Graphite 18.3; it reports no precision and says it tuned its own pipeline on the results. Qodo injected 580 issues into 100 pull requests, gave every tool the same rules as an AGENTS.md, and placed its exhaustive mode first at F1 60.1, with Augment 44.1, Copilot 42.8, Cursor 39.3, Greptile 39.0, Codex 37.6, CodeRabbit 28.0 and Sentry 23.7; Qodo's own write-up calls itself "still vendor-run". Greptile's 50-bug set in July 2025 had Greptile at 82 percent, Bugbot 58, Copilot 54, CodeRabbit 44 and Graphite 6. Tenki's 122-bug set has Tenki first at F1 41.7 by eight tenths of a point over Devin. DeepSource's 165 JavaScript and TypeScript vulnerabilities had DeepSource at F1 84.5 with perfect precision, Bugbot 80.5, Devin 78.1, Codex 77.7, Greptile 68.6, Claude's security review 62.4 and CodeRabbit's CLI 36.0; the data is in a public repository. Alibaba, PR-AF and CodeAnt each publish a set on which they lead. In every vendor-run comparison the vendor's own product finishes first, with one exception below.
- Sponsored. Signal65, paid by Qodo in March 2026, reports Qodo with 129 true positives and 30 false, CodeRabbit with 93 and 4 and the most criticals, Bugbot 71 and 3, Copilot 74 and 41, Greptile 38 and 6. The precision numbers favour CodeRabbit and Bugbot; the recall numbers favour the sponsor.
- Independent, offline. Martian ran a shared set of 50 pull requests with 173 agreed golden comments through three model judges. Recomputing F1 from its published data with one judge: Qodo's extended mode 64.4, cubic 62.4, Augment 61.5, GitLab 54.2, Macroscope 53.5, Greptile 52.4, Bugbot 50.8, Copilot 50.4, Devin 50.4, Claude Code 48.7, Kodus 44.8, CodeRabbit 43.8, Graphite 13.0. Switching the judge moves individual products 5 to 10 points, and cubic and Greptile each quote a snapshot of this board on which they are first.
- Independent, online. Martian also scores live pull requests, more than 200,000 so far. CodeRabbit quotes a first place on that board with F1 51.2 in early 2026 and 57.5 by July.
- Independent, open, and the nearest thing to an exception. GitHub's ReviewBench, 219 pull requests from 187 repositories in 19 languages, with an open harness, a model as grader, a golden set built from human reviews, follow-up commits and tool output including Copilot's own, and a live leaderboard. On 30 October 2026 the top entries are research systems, not products: OhMyBug 69.3, an intent-review agent 62.6, a university engine 59.6. Among products, Copilot Max is first, seventh overall, at 42.4 and about 16 minutes a pull request, then Devin 37.0, Copilot Lite 36.4, Qodo 35.1, Codex 27 to 30, cubic 27.3, Greptile 27.2, Cursor 17.3. CodeRabbit and Augment are absent. At launch Copilot led the board outright and the trade press said so; research entries have since passed it. So GitHub's product leads the products on GitHub's benchmark, on a golden set its own findings helped build, and the board is not free of the runner either. What sets it apart is that the harness is open: a buyer can rerun it on their own pull requests instead of trusting the chart.
- Field observations. A practitioner who works at Sentry, one of the four vendors tested and the one with the fewest findings, ran four tools on 146 pull requests and 679 findings over three weeks on one team, with the employer disclosed: CodeRabbit posted 281 findings with 2.3 percent judged wrong, Bugbot 128 with 4.8 percent, Greptile 120 with none, Sentry 46 high or critical with none wrong at the critical level; and 93.4 percent of the 617 flagged locations were flagged by one tool only. AIMultiple's 309 pull requests put CodeRabbit on top at 51 percent of its findings.
The same product's range across these sets is the fact a buyer should carry. CodeRabbit scores between 26.7 and 60.2. Copilot between 21.4 and 62.6. Greptile between 22.1 and 82. Bugbot between 17.3 and 80.5. cubic between 27 and 66. Graphite is last on every set that includes it, usually with high precision and almost no recall, which is consistent with a product whose documentation still marks related-file context as coming soon. Six reasons the numbers cannot be merged, each visible in the method sections:
- What counts as a bug differs, from planted syntax errors to agreed human comments.
- What counts as a hit differs, from same line to same intent.
- False positives are counted by three incompatible rules or not at all.
- The product version, settings and effort level are rarely stated.
- The date matters, because the products changed pipelines within the year.
- Four of the sets reuse the same 50 pull requests, so they are not independent samples.
Precision is the one number that has converged: on ReviewBench nearly every product sits between 84 and 90 as graded by its model judge, which the earlier piece showed agrees with humans about as well as humans agree with each other, and on the DEV field test the wrong-finding rates were under 5 percent. Recall is where the products differ, and recall is what the vendor-run sets are built to show.
The academic shelf adds three results a buyer can use:
- Merging reviewers raises recall substantially. SWR-Bench finds the best single model at F1 19.4 and merged reviews up to 43.7, and the 93.4 percent single-tool overlap in the field test says the same thing about products.
- Repository-level context helps recall little and hurts precision in two independent studies, SWE-PRBench and AACR-Bench.
- Executable tests cut everyone down. On c-CRAB, where a finding counts only if a test proves the bug, Claude Code reaches 32.1 percent, Devin 24.8, PR-Agent 23.1 and Codex 20.1, with the union at 41.5.
Important: In every vendor-run comparison the vendor's own product finishes first. GitHub's open benchmark is the nearest thing to an exception: Copilot leads the products but sits seventh overall behind research systems, on a golden set its own findings helped build. Its harness is open, which is a reason to rerun it rather than to trust its chart.
What it means for us: Read a comparison's method before its chart: who ran it, what counted as a bug, whether false positives were counted, and whether the 50 pull requests are the same 50 everyone reuses. Then look at precision, which has converged, and treat recall as the vendor's claim until the independent boards agree. Why it matters: The products you are choosing between differ by less than the same product differs between benchmarks. The number that would settle it, defects fixed per dollar in your repositories, is one no benchmark measures and the only one you can measure yourself.
Carry forward:
- Thirteen comparisons, nine of them vendor-run or sponsored, and the runner leads all nine.
- Precision has converged above 84 on the open board as a model judge grades it; recall separates products and is what vendor sets are designed to show.
- Two reviewers together catch much more than one, in both the academic sets and the field test, which is an argument for a cheap second reviewer over an expensive first one, on a different model vendor, since same-vendor pairs miss the same things.
Level 8: Fit
This level answers: which family for which team, and when does building your own make sense?
The seven families map onto team situations, and the mapping follows from the five choices rather than from the vendor pitch.
- A team on one git host whose spend is already on that platform gets the platform native by default, and should check two things: whether the meter is per review or per seat, since GitHub, GitLab and Atlassian all moved to usage, and whether the reviewer reads the ticket system the team uses, since that is where the platform natives have an edge nobody else can copy. Atlassian for Jira acceptance criteria, with the earlier piece's measurement in mind that ticket text moved Atlassian's own reviewer by one to three points, and Sentry for a team whose defects show up as production errors first.
- A team whose pull requests come from one coding agent gets that agent's add-on with the least friction, because the fix loop is already there. Bugbot for Cursor shops, Devin Review for Windsurf and Devin, Codex review for a Codex shop, Claude Code Review for a Claude Code shop. The cost of that convenience is the meter: Bugbot bills per push, Claude Code Review bills tokens at the highest published average in the survey, and neither names its model. The second cost is the one the earlier piece measured: the add-on reviews with the vendor's own model, most likely the one that wrote the code, and same-vendor review pairs miss the same errors far more often than cross-vendor pairs. Keep the add-on for the fix loop, and put the cheap second reviewer from Level 7 on a different model vendor.
- A team with written rules, a spec per feature, and a review culture it wants to encode gets a standalone bot, because that is where the learning loops, the instruction-file readers, the ticket readers and the approval switches live. Of the nineteen, six are large enough to run every benchmark: CodeRabbit, Greptile, Qodo, cubic, Macroscope and Graphite. Within those the choice is the meter again. CodeRabbit and Graphite are seats; Greptile, Qodo and Macroscope are usage; cubic is a seat with a line allowance that sits in between.
- A team that already runs a scanner keeps the scanner for the candidates it finds and adds one general reviewer beside it, because the scanner vendors with a model layer fix what the rules find and do not review the diff for logic. Sonar is the exception, having bought one.
- A team with more regulatory constraints than money runs the open-source tools on its own model key. PR-Agent runs on seven hosts from one configuration file, including Gerrit and CodeCommit, which no commercial product reaches. The cost is the model bill, which Cloudflare's in-house tiers put at 20 cents for a small change and 1.68 dollars for a full multi-agent review, and the absence of a learning loop, a verifier or a benchmark score.
- A team that wants a spec reviewer rather than a bug finder has three choices: Baz scores each requirement as met, partly met or not met and can run the branch; cubic and Qodo check the change against the linked ticket; and everyone else needs the spec pasted into the instruction file.
Building your own is the seventh family, and fifteen companies have said what it cost them. The costs cluster:
- Upsun. About 50 cents a review on GitLab CI with a Claude agent and a sandbox.
- Cloudflare. An average of 1.19 dollars and a median of 98 cents across 131,246 runs, with a 90th percentile of 2.36 and tiers from 20 cents for trivial changes to 1.68 for full seven-agent reviews.
- DoorDash. About 3 dollars a review against 5 to 20 for the products it tried. On its own bench, 3.91 dollars at 53.6 percent recall and 87 percent precision for its scout-plus-strong-model design, against 75 cents at 30.7 percent recall for a single cheaper model.
- Wealthfront. About 4 dollars and ten minutes, and it says it would pay 20 and wait fifteen.
- Anthropic internal. An average of 15 to 25 dollars in March.
Against the commercial averages of a quarter to 1.50 dollars for most usage products, the in-house systems pay more per review, by choice, for things no product sold them:
- Rules mined from their own history.
- A model they pick and can change.
- Context from Slack, incidents and databases.
- Willingness to wait ten minutes.
- Telemetry that measures whether findings led to code changes.
DoorDash reports that 60.2 percent of its settled high and critical findings led to a code change, up from 46 percent with the third-party agent it replaced. Uber reports 75 percent of comments rated useful on more than 65,000 diffs a week. Microsoft reports a 10 to 20 percent cut in median completion time across 600,000 pull requests a month and gives no model or cost. Shopify's chief technology officer said on a podcast that serial passes by expensive models beat parallel cheap agents and that the company uses its own.
The in-house posts are also where the failure modes are written down, which no product page does. Ionix had a sandbox that silently ran nothing and an unpinned CLI that broke every review. Upsun's reviewer told an engineer that a Go version that existed did not. Cloudflare counts break-glass merges past its reviewer at 0.6 percent. Meta found that showing reviewers a suggested patch made them 5 percent slower, so it shows patches to authors only. No in-house post compares its system with a commercial product on a shared set, so the claim that the house system is better is, in every case, a claim.
The honest frame for the build decision is the one DoorDash gives: about five times the cost for about 1.75 times the recall, and a reviewer that engineers act on 60 percent of the time instead of 46. A team that cannot measure whether its reviewer's findings led to code changes cannot make that trade, and should not build. A team that can has a number no vendor will give it.
Carry forward:
- Platform natives win on the ticket and error data they alone can read; add-ons win on the fix loop; standalone bots win on rules, learning and approval; scanners do not review logic; open source wins on hosts and cost.
- In-house systems cost 50 cents to 4 dollars a review and pay it for control, context and measurement; the published commercial averages run a quarter to 1.50 dollars for most products.
- The one metric that would decide any of this, findings that led to code changes per dollar, is measured by DoorDash, Meta and Uber internally and by no vendor publicly.
Products observed
One line per product, in family order. Reads is the top rung of the context ladder the documentation supports. Acts is the highest authority step. Bills is the meter and the published price. Status is noted where the product is retired, retiring, acquired or of doubtful liveness. All prices are the vendor's published list on 30 October 2026.
Standalone hosted bots
- CodeRabbit. Reads: sandbox clone, 50+ analyzers, CI failure logs from five systems, linked issues, AGENTS.md and rival rule files. Decides: analyzers then agents then filtering. Acts: comments, status check, approval off by default on paid tiers. Learns: replies, admin-gated, export on Enterprise. Bills: seats 24 to 72 dollars, per-file overage, hourly cap. Note: the most benchmarked product; free on public repositories.
- Greptile. Reads: a repository graph built at onboarding, a rules folder, eleven instruction-file formats including rivals'. Decides: Base, Plus, Apex tiers. Acts: comments, confidence score, TREX test runs, auto-approve in beta on five-of-five confidence. Learns: thumbs, replies, first-versus-last commit. Bills: credits at 1, 3 or 10 dollars a review, no seats, bot authors excluded.
- Qodo. Reads: Software Map, cross-repository, tickets, Figma, standards. Decides: multi-agent with a precision filter, Exhaustive or Precise. Acts: comments, requirement-gap findings, rule enforcement. Learns: Rule Miner in beta mines accepted human comments, ownership-weighted, decaying. Bills: pooled credits at 1.2 cents, about 1.67 dollars a review by pack size, no permanent free tier.
- Graphite. Reads: the diff and rule files by glob; related-file context marked coming soon. Acts: comments, chat; the merge queue is separate. Learns: dashboard rates only. Bills: seats 20 and 40 dollars. Note: owned by Cursor since December 2025; last on every benchmark that includes it.
- Macroscope. Reads: diff plus code reached through parsers for seven languages, Markdown instructions. Decides: Budget to Ultra modes; check-run agents on a named model. Acts: comments, fix-it-for-me, check runs as required checks, Approvability off by default and not fail-closed. Learns: none described. Bills: kilobytes of diff, 2.5 to 20 cents, minimum 25 cents to 2 dollars, each push billed.
- Ellipsis. Reads: a sandbox per reviewer with install hooks, so tests can run. Decides: up to 64 YAML-defined reviewers with budgets. Acts: comments, pass or fail, approve or request changes by configuration. Bills: provider tokens plus 10 percent, no seats, support packages 5,000 to 15,000 dollars.
- Baz. Reads: embedded index, tickets, Figma, docs, agents' instruction files at any depth, cited in each finding. Decides: five specialist agents plus a spec reviewer that can run the branch. Acts: comments, Fixer commits, a Merger agent returning merge, reject or escalate, auto-approve by rule. Learns: memories with versioned, revertible prompts and governance. Bills: 30 dollars a seat plus credits for Fixer sessions.
- cubic. Reads: full codebase and linked repositories, issues from four trackers, README, AGENTS.md, rivals' files and four agents' skills. Decides: model routing, incremental per push, a nine-minute Ultrareview. Acts: comments, auto-fix, auto-approval off with Shadow and Live modes. Learns: replies and thumbs, only if a reusable rule, weekly cleanup, senior-reviewer mining. Bills: seats 40 to 200 dollars with pooled line allowances.
- Bito. Reads: symbol index and embeddings, static tools, Jira, five instruction-file formats. Decides: five specialists combined and filtered. Acts: comments, suggestions, summary. Learns: negative feedback only. Bills: about 12 to 25 dollars a seat plus 5,000 lines, 5 dollars per extra thousand.
- Kodus. Reads: diff plus repository search, CLAUDE.md and AGENTS.md, Jira or Linear for business-logic validation. Acts: comments, suggestions; an auto-approve page exists. Learns: remember command with an admin gate. Bills: free self-hosted community edition; Teams 8 dollars a seat plus tokens at provider rate. Note: open core, publishes production data openly.
- Entelligence. Reads: linked codebases, guidelines, AGENTS.md, production and incident context. Acts: comments, summaries, a priority that marks merge-blocking findings. Learns: learnings for recurring false positives. Bills: 750 dollars for 15 engineers and 300 reviews, 1 dollar each beyond.
- Sourcery. Reads: the diff and review rules of up to 3,000 characters. Decides: one pass as the rate limits imply. Acts: comments, summary, re-review on request. Bills: seats 12 and 24 dollars with caps in diff characters, re-reviews at a tenth of the cost.
- Tenki. Reads: diff and repository context. Acts: two comments, a findings-by-severity report and an overview. Bills: 1 dollar a review from workspace credits, 100 dollars free; other pages say tokens or minutes. Note: publishes a self-ranked benchmark.
- Dromeas. Reads: diff; details sparse. Decides: seven agents and a model council that must agree; the same checks run on trunk after merge. Acts: comments; an auto setting exists. Bills: credits at 25 cents, credits per review unpublished.
- Revix. Reads: the repository, from which it mines rules. Acts: comments, each naming the rule that fired. Learns: editable mined rules. Bills: 20 and 40 euros a seat, free for open source. Note: launched on Product Hunt the day of this survey.
- Stage. Reads: the diff, ordered into reading sections with a what-to-review list per section. Acts: comments and approvals synced from its own interface. Bills: free on public repositories, 30 dollars a seat on private. Note: review as a reading-order problem, not a detection problem.
- Gitar. Reads: pull request, codebase, team conventions, CI logs, Jira, Linear, Slack. Acts: one consolidated comment, fix commits "only on green", auto-approve and merge blocking on Pro. Bills: seats 20 and 40 dollars, Enterprise per pull request. Note: owned by Sonar since May 2026.
- Korbit. Reads, decides: not documented, docs host gone. Bills: 12 to 18 dollars a seat on third-party pages; the pricing page returns a 404. Status: doubtful, no 2026 activity found.
- Squire. Reads, decides: not documented, docs return 404. Bills: 20 and 50 dollars a seat. Status: doubtful, footer dated 2024.
Platform natives
- GitHub Copilot code review. Reads: repository on demand, Copilot instruction files and AGENTS.md from the head branch, GitHub and Playwright MCP servers on by default. Decides: Lite, Balanced, Max with a tuned model mix and no picker. Acts: comments, suggestions, hand-off to the cloud agent, approval off by default and the only one that satisfies a required-approval rule when an administrator enables it. Bills: tokens as cents of credit plus Actions minutes, estimates of 25 cents, 1.50 and 10 dollars, billed to the author.
- GitLab Duo code review. Reads: a pre-scan bundle of diffs, related files, tests and dependencies, capped near a megabyte, no further fetching, no AGENTS.md. Decides: a two-stage flow on a named Claude model. Acts: comments; approval beta behind a flag, not counting toward required approvals. Bills: a flat quarter credit a review regardless of size since March 2026.
- Copilot in Azure DevOps. Reads: pull request and repository, custom instructions capped at 4,000 characters. Acts: always a comment review, never approves or blocks. Bills: the same credit meter as GitHub through an Azure subscription. Status: preview.
- Atlassian Rovo Dev reviewer. Reads: the pull request and the linked Jira work item's acceptance criteria; skips over 10,000 lines. Acts: comments only when issues are found; only the author can trigger. Bills: 2,000 credits a developer on a 20 dollar seat, moving into Rovo credits from December 2026 as the standalone product ends; stops silently when credits run out.
- Vercel Agent review. Reads: every human-readable file, eleven instruction-file formats in priority order, 50 kilobyte cap. Decides: writes a patch per finding and runs the real build, tests and linters in a sandbox; shows only what passes. Acts: one-click suggestions, fix commits on command. Bills: provider rate plus 25 cents per million tokens, from a flat 30 cents a review before June 2026. Status: beta.
- Harness AI code review. Reads: the diff grouped by change and ranked by risk, plus a delivery knowledge graph with past incidents. Acts: comments, labels, reviewer suggestions, merge gating. Bills: not public. Note: bought Augment's assets in October 2026.
- LinearB. Reads: diff plus repository context. Acts: comments, auto-approve on a clean result, routing inside a workflow engine. Bills: 29 dollars a contributor with a 50-seat minimum and 1,000 credits, 100 per automated pull request; a product page says bundled at no extra charge.
- Sentry Seer review. Reads: file names, diffs and pull request text per the docs, and error and trace data per the product page; the two statements are not reconciled. Decides: predicts which errors the change will cause; filters style by design. Acts: comments and a status check. Bills: 40 dollars per active contributor with two or more pull requests, bots excluded.
Model-vendor natives
- Claude Code Review, managed. Reads: diff and surrounding code read-only, REVIEW.md and CLAUDE.md from the base branch, no builds or tests. Decides: find, verify, rank, post; Quick, Standard, Deep; no model choice for admins. Acts: comments and a check run that never fails; never approves. Bills: tokens to the organisation, a March average of 15 to 25 dollars not restated at general availability in October.
- Claude local review and Ultrareview. Reads: working tree, branch or pull request with CLAUDE.md; Ultrareview clones the branch to the cloud. Decides: one subagent at low to max effort; Ultrareview reproduces each finding. Acts: findings in the session, an apply flag, a plain comment on GitHub. Bills: plan usage; Ultrareview 5 to 25 dollars a run after three free.
- OpenAI Codex review. Reads: the pull request and repository, the closest AGENTS.md with a code-review heading. Decides: posts only P0 and P1. Acts: comments; a fix command starts a cloud task; a security review in preview. Bills: inside ChatGPT plans from 20 dollars a seat, no quota stated.
- Gemini Code Assist on GitHub. Reads: diff and configured repository, a styleguide file, a severity threshold defaulting to medium. Acts: comments and summary. Bills: a Code Assist seat with at least 100 reviews a day. Status: consumer version shut 17 July 2026, new sales stopped 9 October 2026.
- Jules critic. Reads: the agent's own patch, single pass, no tools. Acts: sends findings back to the agent; posts nothing on a pull request. Bills: inside Jules task quotas. Note: the one reviewer that exists only inside the writing agent.
- Amazon Q, CodeGuru and Kiro. Reads: the pull request for Q; repository code for CodeGuru. Acts: Q posts a summary and suggested fixes on open only; Kiro is a coding agent with no documented reviewer. Bills: free with limits; paid Q subscriptions end April 2027. Status: retiring.
Coding-assistant add-ons
- Cursor Bugbot. Reads: diff, existing comments and files on demand; only its own BUGBOT.md, settings from the base branch; skips large and generated files. Decides: agent design since late 2025, Low to Smart effort. Acts: comments, Autofix with three attempts, hand-off to the Cursor agent; neutral check by default. Learns: rules mined from reactions and replies, auto-promoted, billed. Bills: usage per run, 1.00 to 1.50 dollars average by vendor claim, no seat since June 2026, per push by default.
- Devin Review and Windsurf Quick Review. Reads: diff and existing comments; rivals' rule files from CodeRabbit, Greptile, Cursor and Windsurf. Decides: Normal or Ultra; Quick Review runs a purpose-trained bug model before the push. Acts: native approve or request changes, Auto-Fix sessions, a rubric-based Autoapprover in beta that re-checks each push and does not merge. Bills: agent compute units from a shared pool, Teams at 80 dollars plus 40 a seat; public pull requests free; Quick Review free.
- Amp review. Reads: the agent explores the repository; checks are Markdown files per folder. Decides: one agent per check in parallel. Acts: findings in the editor or terminal, piped into the main agent. Bills: tokens at provider price, no review fee.
- Augment. Reads: a context engine, repository guidance, review memory, tickets through MCP. Decides: Thorough or Precise on the legacy bot; a fleet with a Risk Analyzer on the new one. Acts: comments, PR Fixer, low-risk auto-approve with a justification. Bills: tokens plus 40 percent inside 20 and 100 dollar plans. Status: standalone bot sunsetting; assets to Harness October 2026.
- Zencoder. Reads, decides: no named reviewer; multi-model cross-review in the editor. Bills: credits per seat, 40 to 175 dollars; bring-your-own-key uses no credits but keeps the seat fee.
- Tabnine. Reads: the diff in a CLI example; rules inferred from repositories at the 2024 launch. Bills: not public; the pricing page redirects. Status: acquired by Tricentis July 2026.
- Factory Droid review. Reads: the changes with repository context. Decides: deep or shallow; a model alias that upgrades itself. Acts: comments, suggestions, approval when no issues are found. Bills: plans from 20 dollars with no review meter.
- JetBrains Junie review. Reads: diff plus project search and guidelines; never edits, builds or commits. Acts: findings only, in the editor, CLI or CI. Bills: AI plans at 8.33 and 25 dollars with credits; bring-your-own-key at provider rate.
- Kilo code reviewer. Reads: diff plus repository context, AGENTS.md or CLAUDE.md. Decides: the model you pick, with a severity threshold. Acts: comments. Bills: provider rate with zero markup; the vendor publishes token counts to show a cheap model costs cents.
- Sweep. Status: pivoted from a pull request bot to a JetBrains assistant; no current reviewer.
- Continue Checks. Reads: each check ran as a full agent with files, bash and a browser. Acts: pass or fail status per check. Status: retired after Cursor acquired Continue in June 2026.
Static analysis and security vendors with a model layer
- Semgrep Assistant. Reads: the finding and surrounding code. Decides: rules first, then a true-or-false-positive label and a proposed fix. Learns: triage memories. Bills: 30 dollars a contributor with 20 credits, 1 per finding analysed, 20 per autofix. Note: publishes its own weak number, 41 percent agreement on false positives.
- Snyk DeepCode. Reads: scanned code and a data-flow graph. Decides: symbolic analysis with a fix model, no general diff review. Acts: checks, suggested and committed fixes. Bills: 25 dollars flat up to ten developers; Enterprise one credit per active contributor per day.
- SonarQube and Gitar. Reads: changed code and project history for the gate. Acts: quality gate that can block, CodeFix patches, a Remediation Agent; Gitar is the LLM reviewer. Bills: 34 dollars per 100,000 lines of repository, ignoring pull request count. Note: the only scanner vendor that bought an LLM reviewer.
- DeepSource. Reads: diff, static results and agent-chosen context. Acts: comments, gates, Autofix commits. Bills: 24 dollars a seat plus 8 or 15 dollars per 10,000 processed lines. Note: publishes full benchmark data in a public repository.
- Aikido and Trag. Reads: agentic review beyond the diff; details sparse. Acts: comments and Autofix patches. Bills: 300 and 600 dollars per block of ten users plus a credit wallet, one credit per deep review. Note: Trag's team acquired August 2025.
- Pixee. Reads: scanner findings. Acts: opens fix pull requests, never reviews. Bills: per finding resolved, quote only.
- CodeScene. Reads: changed files and their history for a deterministic code-health score. Acts: pass or fail gate, refactoring proposals from an agent. Bills: 18 and 27 euros per author active in three months.
- Codacy. Reads: the diff, related files, the Jira key and its epic; stores nothing. Decides: static analysis combined with an AI pass. Acts: a reviewer run by button, platform gates. Bills: 18 dollars per git contributor on Team; free for open source.
- CodeAnt. Reads: the diff; marketing says full codebase, the docs do not. Decides: LLM review plus SAST, four severities. Acts: suggestions, a prompt-for-agent button, blocking gates on secrets and critical issues. Learns: instructions given in replies. Bills: 24 to 30 dollars a seat, unlimited reviews, free for open source.
- Panto. Reads: diffs with dynamic analysis to infer intent. Decides: more than 30,000 security rules plus several models. Bills: not public for review.
Open source and do it yourself
- PR-Agent. Reads: compressed diff, AGENTS.md, skills, Jira, capped at 32,000 model tokens by default. Decides: one call per command, a self-reflection filter at a threshold of zero. Acts: comments, descriptions, labels, patches; auto-approval off and commented out. Bills: free, your model bill. Note: moved from Qodo to a community organisation in 2026; runs on seven hosts including Gerrit and CodeCommit.
- Gito. Reads: the diff, extra files and Jira or Linear text when configured. Acts: comments, summary, a local report. Bills: free, your model bill; runs on coding-agent CLIs and local models.
- Shippie. Reads: diff then an agent loop with tools; AGENTS.md; an MCP client for ticket and docs servers. Bills: free, your model bill.
- PR-AF. Decides: a review plan, focused agents, findings challenged before display. Models named: GLM, DeepSeek and Opus class. Bills: free. Note: ranks itself first on its own set.
- Alibaba Open Code Review. Reads: diff then whole files and search, bundled per sub-agent. Decides: plain code picks files and fixes comment positions; the model reviews each bundle; a reflection step re-checks. Acts: comments to GitLab, Gerrit, Bitbucket and others. Bills: free. Note: self-ranked benchmark.
- OpenHands review plugin. Decides: one agent loop with a review skill; random model selection per review for A/B tests. Acts: comments through GitHub. Bills: free, your key.
- Generic LLM actions. Reads: the diff in chunks, with lockfiles and generated code dropped in the better ones. Decides: one pass; one project runs two providers and merges. Acts: comments capped at five by default in one project. Bills: free; one maintainer reports a tenth of a cent per pull request on a small model.
In-house systems with a public write-up
- Cloudflare. A coordinator with up to seven specialists and a judge pass on GitLab CI, tiered by lines changed, three model families. 131,246 runs on 48,095 merge requests. Average 1.19 dollars, median 98 cents. Break-glass merges 0.6 percent. No precision or recall published.
- Uber uReview. Filter, three assistants, a grader with a threshold, deduplication. More than 90 percent of about 65,000 weekly diffs. 75 percent of comments rated useful; more than 65 percent addressed against 51 for human comments. Median four minutes.
- Meta. Three systems: suggested fixes applied 19.7 percent of the time and shown to authors only; RADAR auto-approving 60.31 percent of more than 535,000 diffs; Spotlight, a generator and critic that cut tokens five-fold at higher judged quality.
- Google. Machine-learning edits resolving 7.5 percent of comments in a 2024 paper; a comment generator in a second paper.
- Atlassian. A zero-shot generator, a judge and a small classifier gate, reading pull request, files, diff and Jira. More than 54,000 comments, 2.1 a pull request. Resolution 38.7 percent against 44.5 for humans; cycle time down 31 percent.
- DoorDash. Scout, two deep reviewers, a disprove step, a fixer, on full clones; profiles from AGENTS.md, history, Slack and incidents. More than 10,000 pull requests a week. 60.2 percent of settled high and critical findings led to code changes. About 3 dollars a review; 3.91 dollars at 53.6 percent recall on its own bench.
- Wealthfront. One model leading, one prosecuting, one defending; about 80 engineer-written checks; database access. About 4 dollars and ten minutes; would pay 20.
- Ionix. Dropped a commercial reviewer for a Codex CLI on its own Azure tenancy, a different stack from its authoring tool. Only critical and high, a concrete failure scenario required, zero findings allowed. Two documented failures: a silent sandbox and an unpinned CLI.
- Upsun. A Claude agent on GitLab CI in a sandbox with Linear through MCP. More than 1,000 merge requests, about 50 cents a review. One documented hallucination about a Go version.
- Microsoft. More than 90 percent of pull requests, 600,000 a month, 10 to 20 percent faster median completion. No models, cost or accuracy.
- Anthropic internal. Parallel agents, verification, ranking; about 20 minutes; never approves. Substantive comments rose from 16 to 54 percent; under 1 percent marked incorrect; 15 to 25 dollars a review.
- Ericsson, Ramp, Shopify, Vercel. A paper without numbers; a secondhand account; a chief technology officer saying serial expensive passes beat parallel cheap ones; a product rather than a post.
Decision guide
- Your pull requests come from one coding agent and you want the loop closed. Use: that agent's add-on, Bugbot, Devin Review, Codex review or Claude Code Review. Then check: whether a push counts as a run, and set the reviewer to once per pull request before the agents start pushing.
- You pay a git host already and the budget owner wants one invoice. Use: Copilot, GitLab Duo or Atlassian's reviewer. Then check: the included credits per seat against your pull requests per developer, and who is billed when a service account opens the pull request.
- Your defects are spec mismatches more than bugs. Use: Baz, cubic or Qodo, which read the ticket, or any instruction-file reader with the spec in the file. Then check: whether the product cites the requirement in the finding, as Baz does.
- Your defects show up as production errors first. Use: Sentry's reviewer, or Harness if you are on it. Then check: what data actually leaves your account, since Sentry's two pages disagree.
- You want the bill fixed no matter how many pull requests the agents open. Use: a seat plan, CodeRabbit, Graphite, Sourcery, Codacy, or cubic's pooled lines. Then check: the hourly or character caps and the per-file overage, which are where seat plans leak.
- You want to pay only for what runs. Use: Greptile, Macroscope, GitLab or Copilot Lite. Then check: the effort tier, because Base to Apex and Lite to Max are each a tenfold price step for a few points of recall.
- You are deciding whether the reviewer may approve. Use: cubic's Shadow mode or Macroscope's Preview mode for a month. Then check: how many of its would-be approvals were later reverted, and whether your host requires an approval it would count, which only Copilot's does.
- You run Gerrit, CodeCommit or an air-gapped host. Use: PR-Agent or Alibaba's tool on your own key. Then check: that the self-reflection threshold is raised above zero, or every finding posts.
- You already run Semgrep, Snyk or Sonar. Use: keep it, and add one general reviewer; Sonar's own Gitar if you want one vendor. Then check: that the reviewer does not re-post the scanner's findings, which doubles the comment count.
- You want two opinions cheaply. Use: one usage-metered reviewer at low effort beside your main one, from a different model vendor than the one that writes your code. Then check: the overlap after a month; the field test found 93 percent of locations flagged by one tool only.
- You want the same finding to stop coming back. Use: a product whose learned rules are visible and gated, CodeRabbit, cubic, Baz, Kodus, Greptile, Qodo or Revix. Then check: that someone on the team moves each rule into the instruction file the coding agent reads, because no product does, and the reviewer's rule only silences the comment.
- You are considering building. Use: the Cloudflare and DoorDash write-ups as the design, and DoorDash's trade of five times the cost for 1.75 times the recall as the budget. Then check: that you can measure findings that led to code changes, because without that number the build cannot be judged.
Takeaways
- Sixty-three reviewer products exist with a public page, eight of them retired or retiring and six acquired since mid-2025; count on about 55 live ones, and expect the standalone bots to be the ones that change hands.
- Every product reads the diff; the differences you pay for are what else it reads, what it is allowed to do, and which meter it bills on.
- A product that will not name its model cannot promise it is not the model that wrote the code, and review pairs from one vendor miss the same errors far more often than pairs from two.
- Fourteen reviewers now read the coding agents' instruction file, so a team writes its rules once; Bugbot and GitLab are the notable exceptions.
- Only two vendors state that reviewer instructions come from the protected branch; Copilot reads them from the branch under review, which an agent can edit.
- Products redesigned in 2026 verify findings before posting; precision on the open benchmark has converged at 84 to 90, and recall is what still separates them.
- Effort levels buy a few points of recall for ten to forty times the price on every comparison that reports both, and no vendor claims the top level pays for itself.
- Thirteen products can approve a pull request; nearly all ship the switch off, in beta or in shadow, and only Copilot's approval, administrator-enabled, counts toward a required approval.
- The one published machine-approval deployment at scale, inside Meta, approves 60 percent of changes and measures the revert rate of what it approved; no vendor publishes that number.
- About half the products learn from reactions or history; seven show the learned rules with a gate, one auto-promotes them and bills the learning run; none publishes what the loop does to precision, and none writes the rule where the coding agent would read it.
- Eight meters exist, vendor averages per review span a quarter to 25 dollars, and the example team pays 120 to 720 dollars a month on seats or 75 to 7,500 on usage for products within 20 benchmark points of each other.
- Five of the ten most-used reviewers moved from seats to usage between March and June 2026 and none moved back; at double the pull request count every usage bill doubles and no seat bill moves.
- In every vendor-run comparison the vendor's product finishes first; on GitHub's open benchmark Copilot leads the products and sits seventh behind research systems, and the harness is open, so rerun it on your own pull requests rather than trust either chart.
- Two reviewers catch far more than one in both the academic sets and the field test, where 93 percent of flagged locations came from a single tool; a cheap second reviewer on a different model vendor beats an expensive first one.
- In-house systems cost 50 cents to 4 dollars a review and buy control, context and the metric no vendor publishes, findings that led to code changes per dollar; if you cannot measure that, buy.
References
Product documentation and pricing, read 30 October 2026:
- CodeRabbit: https://docs.coderabbit.ai (pr-reviews/cicd-pipeline-analysis, knowledge-base/code-guidelines, pr-reviews/automatic-approvals, knowledge-base/learnings, management/plans); https://www.coderabbit.ai/pricing
- Greptile: https://www.greptile.com/docs (code-review-bot/graph-based-codebase-context, auto-approve-prs, training-the-learning-system, billing-seats); https://www.greptile.com/pricing
- Qodo: https://www.qodo.ai/pricing/; https://docs.qodo.ai/pricing-and-usage.md; https://docs.qodo.ai/governance/rule-enforcement/rule-miner.md; https://docs.qodo.ai/code-review/overview.md
- Graphite: https://graphite.com/docs; https://graphite.com/pricing
- Macroscope: https://docs.macroscope.com (pricing, detection-mode, custom-instructions, check-run-agents, fix-it-for-me); https://macroscope.com
- Ellipsis: https://www.ellipsis.dev/docs/code-review; https://www.ellipsis.dev/pricing
- Baz: https://baz.co; https://docs.baz.co; https://www.baz.co/pricing
- cubic: https://docs.cubic.dev (ai-review/custom-context, issue-analysis, auto-approval, ultrareview, account/ai-review-usage); https://www.cubic.dev/pricing
- Bito: https://bito.ai/pricing; https://docs.bito.ai/ai-code-review-agent/overview
- Kodus: https://kodus.io; https://docs.kodus.io; https://github.com/kodustech/kodus-ai; https://kodus.io/data/
- Entelligence: https://entelligence.ai/pricing; https://docs.entelligence.ai/code-review
- Sourcery: https://sourcery.ai/pricing; Tenki: https://tenki.cloud/products/code-reviewer; Dromeas: https://dromeas.ai; Revix: https://revix.ai; Stage: https://stagereview.app; Korbit: https://korbit.ai; Squire: https://squire.ai/pricing
- Gitar and Sonar: https://www.sonarsource.com/products/gitar/; https://www.sonarsource.com/plans-and-pricing/gitar/; https://www.sonarsource.com/plans-and-pricing/
- GitHub Copilot: https://docs.github.com/en/copilot/concepts/agents/code-review; https://github.com/features/copilot/plans; https://github.blog/2026-05-01-github-copilot-is-moving-to-usage-based-billing/; the 27 April 2026 pricing announcement on github.blog
- GitLab: https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/; https://docs.gitlab.com/user/gitlab_duo/customize_duo/review_instructions/; https://about.gitlab.com/blog/agentic-code-reviews-with-flat-rate-pricing
- Azure DevOps: https://learn.microsoft.com/en-us/azure/devops/repos/git/copilot-code-reviews
- Atlassian: https://www.atlassian.com/software/rovo-dev/pricing; https://www.atlassian.com/licensing/rovo-dev; https://support.atlassian.com/rovo/docs/rovo-dev-rollout/
- Vercel: https://vercel.com/docs/agent/pr-review; https://vercel.com/docs/agent/pricing
- Harness: https://www.harness.io/blog/shipped-in-august-2026; LinearB: https://linearb.io/platform/ai-code-reviews; https://linearb.io/pricing
- Sentry: https://sentry.io/product/ai-code-review; https://docs.sentry.io/pricing/quotas/manage-seer-budget
- Claude Code: https://code.claude.com/docs/en/code-review; https://code.claude.com/docs/en/code-review-local.md; https://code.claude.com/docs/en/ultrareview.md; https://code.claude.com/docs/en/code-review-costs.md; https://claude.com/blog/code-review; https://claude.com/resources/articles/code-review-is-now-generally-available
- OpenAI Codex: https://learn.chatgpt.com/docs/third-party/github; https://learn.chatgpt.com/docs/pricing.md; https://learn.chatgpt.com/docs/security/security-review
- Gemini: https://docs.cloud.google.com/gemini/docs/code-review/review-repo-code; https://developers.google.com/gemini-code-assist/docs/deprecations/consumer-code-review; Jules: https://developers.googleblog.com/meet-jules-sharpest-critic-and-most-valuable-ally/; https://jules.google/docs/usage-limits/
- Amazon: https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/github-code-reviews.html; https://kiro.dev/pricing
- Cursor Bugbot: https://cursor.com/docs/bugbot; https://cursor.com/blog/building-bugbot; https://cursor.com/blog/may-2026-bugbot-changes
- Devin and Windsurf: https://docs.devin.ai/work-with-devin/devin-review; https://devin.ai/blog/devin-review-windsurf; https://windsurf.com/pricing
- Amp: https://ampcode.com/news/liberating-code-review; https://ampcode.com/docs/pricing
- Augment: https://www.augmentcode.com/product/code-review; https://docs.augmentcode.com/codereview/overview; https://docs.augmentcode.com/models/token-based-pricing.md
- Zencoder: https://zencoder.ai/pricing; Tabnine: https://docs.tabnine.com/main/getting-started/tabnine-cli/examples/code-review.md; Factory: https://docs.factory.com/software-factory/code-review-ci; https://factory.com/pricing; Junie: https://junie.jetbrains.com/docs/junie-review-agent.html; Kilo: https://kilo.ai/code-reviewer-pricing; https://blog.kilo.ai/p/we-analyzed-how-much-kilo-code-reviewer; Sweep: https://github.com/Sweepai/sweep; Continue: https://continue.dev; https://hn.svelte.dev/item/47049848
- Semgrep: https://semgrep.dev/pricing; https://docs.semgrep.dev/semgrep-assistant/overview; Snyk: https://snyk.io/plans/; https://snyk.io/platform/deepcode-ai/; DeepSource: https://deepsource.com/pricing; https://deepsource.com/benchmarks; https://github.com/DeepSourceCorp/benchmarks; Aikido: https://www.aikido.dev/pricing; https://www.aikido.dev/code/pr-review; Pixee: https://www.pixee.ai/pricing; CodeScene: https://codescene.com/pricing; https://codescene.io/docs/developer-tools/pr-refactoring-agent.html; Codacy: https://www.codacy.com/pricing; https://docs.codacy.com/codacy-ai/codacy-ai/; CodeAnt: https://www.codeant.ai/pricing; https://docs.codeant.ai/llms.txt; Panto: https://getpanto.ai/pricing; https://docs.getpanto.ai/code-review/overview
- Open source: https://github.com/The-PR-Agent/pr-agent; https://docs.pr-agent.ai; https://github.com/Nayjest/Gito; https://github.com/mattzcarey/shippie; https://github.com/Agent-Field/pr-af; https://github.com/alibaba/open-code-review; https://docs.openhands.dev/sdk/guides/github-workflows/pr-review; https://github.com/villesau/ai-codereviewer; https://github.com/presubmit/ai-reviewer; https://github.com/cirolini/genai-code-review
Comparisons and benchmarks:
- Augment, seven tools on 50 pull requests: https://www.augmentcode.com/blog/we-benchmarked-7-ai-code-review-tools-on-real-world-prs-here-are-the-results
- Macroscope, 118 bugs: https://macroscope.com/blog/code-review-benchmark; https://macroscope.com/benchmark
- Qodo, 580 injected issues: https://www.qodo.ai/blog/how-we-built-a-real-world-benchmark-for-ai-code-review; https://github.com/agentic-review-benchmarks/benchmark-pr-mapping
- Greptile, 50 bugs: https://www.greptile.com/benchmarks
- Tenki: https://tenki.cloud/benchmarks/code-reviewer; https://tenki.cloud/blog/ai-code-review-tools-comparison-2026
- Martian: https://codereview.withmartian.com; https://github.com/withmartian/code-review-benchmark; cubic's reading: https://www.cubic.dev/blog/cubic-is-the-best-ai-code-reviewer-on-martian-s-benchmark
- GitHub ReviewBench: https://github.blog/ai-and-ml/github-copilot/reviewbench-an-open-benchmark-for-ai-code-review/; https://review-bench.ai; https://github.com/review-bench/ReviewBench
- Signal65 for Qodo: https://signal65.com/wp-content/uploads/2026/03/Signal65-Insights_Evaluating-AI-Code-Review-Tools.pdf
- Field tests: https://dev.to/_vjk/best-ai-code-reviewer-in-2026-1c0f; https://aimultiple.com/ai-code-review-tools; CodeAnt's 200,000 pull requests: https://www.codeant.ai/blogs/ai-code-review-benchmark-results-from-200-000-real-pull-requests
- CodeRabbit on model choice: https://www.coderabbit.ai/blog/gpt-51-for-code-related-tasks-higher-signal-at-lower-volume
- Papers: SWR-Bench arXiv 2509.01494; c-CRAB arXiv 2603.23448; CRBugBench arXiv 2610.13668; AACR-Bench arXiv 2601.19494; SWE-PRBench arXiv 2603.26130; CodeRabbit in the wild arXiv 2607.03316; AIDev arXiv 2604.03196; judge agreement at Beko arXiv 2604.24525; arXiv 2509.13650; arXiv 2608.21311