Best AI Code Review Tools in 2026

Who Wins for What

Coding agents now write pull requests faster than people can read them, so the review queue is the new bottleneck. AI pull-request reviewers exist to read every diff first, comment on real defects, and leave humans the decisions. The catch is that eleven credible products price differently (per seat, per credit, per token), support different Git hosts, and publish benchmarks that mostly come from their own labs.

Short version: CodeRabbit is the safest default when your repos span GitHub, GitLab, Bitbucket or Azure DevOps. Greptile is the tool to trial if raw bug detection matters most, with the caveat that its leading numbers are vendor-reported. GitHub Copilot code review is the easiest add-on if you already pay for Copilot. Sourcery and Bito are the budget seats. If you want to own the whole pipeline, the Claude Code GitHub Action and Codex review driven by AGENTS.md give you the most control. Every price below is dated as of Nov 11, 2026.

Official GitHub walkthrough of Copilot code review, from the editor to a pull request on github.com. It is the reference point most other reviewers get compared with.

Quick Picks

If you are still choosing the coding agent that opens those pull requests, start with our guide to the best AI coding agents in 2026, then come back here to pick the reviewer that checks their work.

Master Comparison Table

Every cell was read from the vendor page named in the Sources list on Nov 11, 2026. Where a page did not say, the cell says so rather than guessing. None of the eleven is sold to you here and no vendor paid for placement.

Two honest notes on the table. First, Cursor Bugbot is marked unverified because cursor.com was unreachable from our research machine, and we will not repeat third-party prices as if they were first-party. Second, open source in the strict sense is rare here: several vendors give free reviews on public or open-source repositories (CodeRabbit, Sourcery, Greptile on application, Qodo through a program), but we found no vendor documenting the reviewer itself as open source. If you want fully open code, the closest option is to write your own review job with the Claude Code GitHub Action or an agent in your own CI.

What Context Depth Means

“Context depth” is how much of your repository the reviewer reads before it comments. Tools sit on a rough ladder, and the vendor pages describe different rungs.

• Diff only. The model sees the changed lines and a little surrounding code. Fast and cheap, but it misses callers, contracts and tests elsewhere in the repo.
• Diff plus surrounding files. Claude Code Review describes several agents that read the change alongside the surrounding code, then a verification step that checks findings against the code before posting. It does not build or run your code.
• Repository index or knowledge graph. Graphite Agent and Bito describe codebase-aware or full-codebase context, and Greptile positions itself the same way; Bito's Enterprise tier adds cross-repo impact analysis. CodeRabbit adds linked repositories and MCP connections as plan limits, which is context from outside the diff.
• Agent with tools. Copilot's docs say its review can gather full project context and, in agentic mode, uses GitHub Actions minutes. Codex and the Claude Code GitHub Action are general agents pointed at a PR, so context depends on the checkout and tools you grant.

Deeper context usually means higher latency and cost, and it also means more code leaves your boundary. That is why the self-hosting column matters as much as the benchmark column for regulated teams.

CodeRabbit

What it is. CodeRabbit is a dedicated AI pull-request reviewer that posts summaries, line comments and walkthroughs. Its docs list the widest Git host coverage in this roundup: GitHub.com, GitHub Enterprise Server, GitLab.com, GitLab self-managed, Bitbucket Cloud, Bitbucket Data Center and Azure DevOps.

Pricing (Nov 11, 2026). Essentials is $24 per user per month billed annually ($30 monthly), Team $48 ($60), Advanced $72 ($90), and Enterprise is contact sales. Plans differ in an hourly review allowance per developer (5, 8, 10 and 12), linked repositories (1, 5, 10, 20) and MCP connections (5, 10, 15, 20). The page says there is no total cap on pull requests or repositories, and once the hourly allowance is spent, usage-based reviews continue at $0.25 per reviewed file with an admin-set monthly cap. You are billed only for developers who open pull requests. Public repositories get free reviews, and paid plans have a 14-day trial.

Strengths. Platform breadth is the headline. Configuration is also mature: review behavior lives in .coderabbit.yaml under reviews: with path_instructions and path_filters, and CodeRabbit picks up AGENTS.md and .cursorrules automatically. Commenting @coderabbitai emit path instructions on a PR opens a pull request that adds suggestions from the past 7 days to your config, which is a practical way to turn review feedback into standing rules. It skips lock files, binaries, minified files and generated code by default.

Weaknesses. Per-developer prices climb quickly for larger teams, and the hourly allowances mean a busy repo can slip into per-file billing. Full self-hosting is limited to Enterprise customers with 500+ seats; smaller teams get a private-network option that connects self-managed GitHub, GitLab or Bitbucket without opening inbound access. In Greptile's July 2025 test CodeRabbit caught 44% of bugs, and it ranked fifth on the Martian leaderboard Greptile summarized (both vendor-reported by a competitor).

Best for. Teams on mixed Git hosts, teams that want rule files per directory, and open-source maintainers who want free reviews on public repos.

Greptile

What it is. Greptile is a codebase-aware reviewer. Its pricing is the least conventional here: no seat fees on Pro, just prepaid credits at $1 each shared across the organization.

Pricing (Nov 11, 2026). Starter is free for one active developer with 50 free credits per month and unlimited repositories. Pro is usage-based with a 14-day trial. Per-review costs are Base 1 credit, Plus 3 credits, Apex 10 credits, and a TREX run 3 credits. Qualified non-commercial open-source projects with an OSI-approved license can apply for free access. Enterprise is quoted by sales and is the only tier that lists self-hosting, along with GitHub Enterprise Server and Cloud with data residency, GitLab Self-Managed, Bitbucket Data Center, Gitea, and Perforce with P4 Code Review.

Strengths. Greptile publishes the most benchmark detail of any vendor and leads its own tests (details in the benchmark section, all vendor-reported). The credit model suits teams where a few repos produce most of the PRs, since you pay for reviews, not headcount. Pro also lists Jira, Linear, Notion and coding-agent integrations.

Weaknesses. Usage pricing makes monthly cost harder to predict, and a 10-credit Apex review is ten times the price of a Base review. The pricing page does not name the Git hosts available on Starter or Pro, so confirm GitHub or GitLab support in the docs before you commit. A third-party comparison also reports that automated reviews cannot be enabled on an empty repository, a small setup gotcha.

Best for. Teams that value detection depth over seat predictability, and organizations with one or two high-volume repos.

Graphite Agent (formerly Diamond)

What it is. Graphite is a pull-request workflow product (stacked PRs, merge queue) with AI review built in. The review feature launched as Diamond in March 2025. Graphite's blog lists “Meet Graphite Agent: The next evolution of AI code review” on Oct 7, 2025, and search results for the announcement describe the Diamond name as retired, so we refer to it as Graphite Agent. The blog also lists “Building the future of software development with Cursor” (Dec 19, 2025) and “Introducing Cursor Cloud Agents in Graphite” (Mar 2, 2026). We could not open the post bodies, so the exact terms of the Cursor relationship are not described here.

Pricing (Nov 11, 2026). Hobby is free for personal-account repos with limited AI Reviews. Starter is $20 per user per month billed annually. Team is $40 per user per month billed annually, with unlimited AI Reviews, AI review customizations, automations and merge queue. Enterprise is custom and adds SAML, ACLs, audit logs, GHES support and SLAs. The page states annual billing is 20% off.

Strengths. If your team already uses stacked PRs, review comes bundled with the workflow rather than as a separate vendor. The Team plan has no per-review metering.

Weaknesses. It is GitHub-focused (GHES only on Enterprise), the AI review is most valuable if you adopt the wider Graphite workflow, and the one head-to-head number we found, 6% in Greptile's July 2025 test, predates Graphite Agent and comes from a competitor. Treat it as a weak signal. The pricing page we fetched did not describe Graphite Agent or custom-rule syntax in detail.

Best for. GitHub teams that want stacked PRs, a merge queue and AI review in one product.

GitHub Copilot Code Review

What it is. Copilot reviews pull requests in any language, suggests fixes you can apply in a couple of clicks, and can hand fixes to the Copilot cloud agent, which opens a new PR (public preview). Our guide to Copilot code review with agent skills and MCP goes deeper on the extension points. GitHub's newer GitHub Code Quality is a separate feature and worth reading alongside it.

Pricing (Nov 11, 2026). Per-user monthly prices: Pro $10, Pro+ $39, Max $100, Business $19 per granted seat with 1,900 GitHub AI Credits, Enterprise $39 with 3,900. The Free plan does not include code review. Usage is now measured in AI credits, with GitHub estimating an average of about $0.25 per Lite review, $1.50 per Balanced review and $10 per Max review (Max is in public preview). Users without access have no monthly allowance, so their usage is billed to the organization, and reviews stop when the applicable budget is reached.

Strengths. No new vendor, no new contract, and it works in GitHub.com, the CLI, mobile, VS Code, Visual Studio, Xcode and JetBrains IDEs. Custom guidance is flexible:

.github/copilot-instructions.md          # repository-wide rules
.github/instructions/api.instructions.md   # path-specific rules
AGENTS.md                                # rules shared across AI tools

Reviews read those files from the pull request head branch, not the base branch, which is convenient for iterating on rules and something to remember for security (a PR author can change the instructions that review their own PR). Agent skills can add task-specific review workflows.

Weaknesses. GitHub-first (Azure DevOps is a public preview), no self-host, and credit-based billing makes monthly spend less predictable than a flat seat. In Greptile's 2025 test Copilot scored 54% overall, strong on low-severity findings (87%) and weaker on critical ones (50%). That is a competitor-run, vendor-reported result.

Best for. Organizations standardized on GitHub Copilot that want review without procurement.

Cursor Bugbot

What it is. Bugbot is Cursor's pull-request reviewer, aimed at logic bugs and security issues. Cursor's Bugbot pages and cursor.com were unreachable from our research machine on Nov 11, 2026 (connection refused), so we have not verified plans, platforms, rules or limits from a first-party page.

What we can say, with labels. A web search surfaced Cursor documentation text listing $40 per user per month (20% off yearly) for teams and individuals, with a legacy pooled cap of 200 pull requests per month per license. The same search found a November 4, 2026 blog post and a Cursor forum reply that describe a newer seat-plus-usage model, with roughly $1.00 to $1.50 per run. Those two sources conflict, and neither is a first-party price list we could open, so treat both as unverified and check cursor.com before budgeting. Graphite's blog also lists a relationship between Graphite and Cursor, which makes the two products worth evaluating together if you use both.

Benchmark. Bugbot caught 58% of bugs in Greptile's July 2025 test, second to Greptile itself, with the highest critical-severity rate tied with Greptile (58%). Vendor-reported by a competitor and dated.

Best for. Teams already on Cursor who want a reviewer from the same vendor. Verify price and platform support first.

Qodo Merge

What it is. Qodo Merge is Qodo's pull-request reviewer, listed alongside Git and IDE integrations. The pricing page we fetched lists two plans.

Pricing (Nov 11, 2026). Pro Team is shown at $30 for teams of up to 30 users, with pooled credits at $0.015 each in packs of 2,000, 4,000 or 16,000 per month. The page does not say whether $30 is per user or per team, so ask before you model costs. Enterprise is custom for 30+ users and requires a demo. There is no permanent free tier: new users get a 14-day trial without a credit card, and qualified open-source projects can apply to a free program.

Strengths. Platform coverage matches CodeRabbit on the main hosts: GitHub, GitLab, Bitbucket and Azure DevOps. Enterprise adds on-prem or air-gapped deployment, single-tenant SaaS and Gerrit support, which few rivals offer.

Weaknesses. The credit model and ambiguous $30 figure are hard to forecast, and self-hosting is Enterprise only. Qodo's own benchmark (60.1% F1 over 100 PRs and 580 issues across 8 repos, as summarized by DeepSource) uses LLM-injected bugs with unpublished ground truth, so treat it as vendor-reported and unreproducible.

Best for. Enterprises on Azure DevOps, Bitbucket or Gerrit that need on-prem.

Sourcery

What it is. Sourcery sells AI review of pull requests, with IDE integrations for VS Code and PyCharm listed on its site.

Pricing (Nov 11, 2026). Open Source is free forever for public repos. Pro is $12 per developer per month billed annually ($15 monthly) and covers private repos with higher limits and Jira integration. Team is $24 ($30 monthly) and adds nightly scans of 50 repos, an issues dashboard and analytics. Enterprise is custom and adds self-hosting, GitHub Enterprise Server support, SSO and bring-your-own LLM keys. New users get a 14-day Team trial with no credit card.

Strengths. It is the cheapest paid seat in the roundup, and its pricing page lists custom review rules and auto-approval of low-risk PRs even on the free Open Source plan. It supports GitHub and GitLab, including self-managed GitLab on every plan.

Weaknesses. No Bitbucket or Azure DevOps on the page we read, and self-hosting is Enterprise only. We found no head-to-head bug-catching benchmark that includes Sourcery, so quality claims rest on the vendor's own social card (“finds more issues than any other AI reviewer”), which we have not verified.

Best for. Small teams and maintainers on GitHub or GitLab who want a low per-seat price and custom rules.

Ellipsis

What it is. Ellipsis markets itself with the line “Agents cost tokens + 10%”. The pricing page we fetched reads as an agent platform: agents are defined in YAML in your repository and deployed by pull request, with integrations for GitHub, Linear, Slack, Sentry and Jira, plus a REST API and CLI. The page does not describe pull-request review specifically, so confirm what a review agent looks like before adopting it for this job.

Pricing (Nov 11, 2026). Per-seat price is $0. Managed SaaS charges model tokens at cost plus a platform fee of 10% of token cost. The Your AWS Account option has the same 10% fee plus AWS costs at $0.142 per vCPU-hour and $0.024 per GB-hour of memory, billed by AWS and run in your own VPC. Optional support packages are $5,000, $10,000 and $15,000 per month. No free tier is listed.

Strengths. No seat fee, transparent token pass-through, and the AWS option keeps credentials, code and LLM calls in your environment.

Weaknesses. Spend tracks usage and model choice, support tiers start at $5,000 per month, and we found no independent benchmark. Custom rules are not described by name on the page.

Best for. Teams that want agents defined as code and billed on tokens, and AWS shops that need a VPC deployment.

Codex Code Review

What it is. Codex posts a GitHub review on pull requests, focusing on serious issues. Setup is a repository connection in Codex, then turning on Automatic review under Review code (GitHub push or admin permission required). You can also comment @codex review on any PR, optionally with a focus such as @codex review for issues in the database migration. On GitHub it flags only P0 and P1 issues. A separate Security Review, a research preview, runs with @codex security review or an auto setting.

Custom rules. Codex reads AGENTS.md and applies a ## Code Review Rules section, with repo-wide rules in the root file and service-specific rules in nested files. The docs recommend starting with two or three concise rules and leaving lint and formatting to CI. An example in that shape (the rules are ours, the heading is documented):

## Code Review Rules

- Flag any change that touches billing/ without a matching test in billing/__tests__/.
- Treat new database migrations as P0 if they lack a rollback step.
- Do not comment on formatting or import order; CI enforces both.

For a full walkthrough of rule writing see our guide to Codex code review and AGENTS.md rules.

Pricing and platforms. The GitHub integration page does not state plan availability, a per-review price, or support beyond GitHub, so we do not either.

Benchmark. “ChatGPT Codex Connector” ranked second on the Martian Code Review Bench in Greptile's July 30, 2026 summary (F1 59.4%, precision 73.3%, recall 50.0%), one point of F1 behind Greptile. Vendor-reported by Greptile.

Weaknesses. GitHub only per the page, only top-severity findings on GitHub, and no pricing clarity. Best for teams that already run Codex and keep standards in AGENTS.md.

Claude Code Review and the Claude Code GitHub Action

Anthropic ships three ways to get a review, and the docs themselves warn that several products share the Claude Code name.

Code Review (managed). Available on Team and Enterprise plans for GitHub repositories, including GitHub Enterprise Server and GitHub Enterprise Cloud with data residency. Several agents examine the diff and surrounding code in parallel, a verification step filters false positives, and findings are ranked by severity and posted as inline comments, a summary and a check run named Claude Code Review. A review never approves or blocks the PR. Review levels are Quick, Standard (default) and Deep. Reviews run on Anthropic infrastructure, not in self-hosted environments, read the repo read-only, and do not build or run your code. It is not available with Zero Data Retention, the HIPAA configuration or customer-managed encryption keys. Rules come from REVIEW.md (read from the base or default branch, never from the PR's own changes) and CLAUDE.md.

Pricing. There is no flat per-review price. Billing is by token usage through usage credits, separate from plan usage, and charged to the organization. Cost scales with review level, change size and code complexity. A repository added from the admin page defaults to After every push, the most expensive setting, so switch to Once after PR creation or Manual (@claude review) for a pilot, then read the average cost per repository in admin settings. You can set a monthly spend limit for the service.

Claude Code GitHub Action (DIY). The anthropics/claude-code-action runs Claude Code in your own workflows. You supply the credential (ANTHROPIC_API_KEY, a subscription OAuth token, or Bedrock, Vertex or Foundry via OIDC), and you pay API tokens plus GitHub Actions minutes. The docs publish this review workflow, which uses the code-review plugin:

name: Code Review
on:
  pull_request:
    types: [opened, synchronize, ready_for_review, reopened]
jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read
      issues: read
      id-token: write
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 1
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          plugin_marketplaces: "https://github.com/anthropics/claude-plugins-official.git"
          plugins: "code-review@claude-plugins-official"
          prompt: "/code-review:code-review --comment ${{ github.repository }}/pull/${{ github.event.pull_request.number }}"
          claude_args: '--allowedTools "mcp__github_inline_comment__create_inline_comment"'

With --comment Claude posts inline comments or one summary comment; without it, findings only appear in the run log. It skips drafts, closed PRs, PRs it judges trivial or automated, and PRs that already have a Claude comment. Public-repo fork PRs do not receive secrets, so reviews run only for same-repo branches. Quick setup via /install-github-app works only with github.com remotes; GitLab uses a separate CI/CD integration. Cost controls include --max-turns, workflow timeouts and concurrency limits. Locally, /code-review works on any plan.

Strengths. The most control (prompt, model, triggers, your own runners), cloud-provider routing, and a clear security story for the managed product. If you wire review into agent loops, our roundup of MCP servers for Claude Code covers GitHub tools you can give the reviewer. Weaknesses. Managed review is GitHub only and excluded for ZDR, HIPAA and CMEK orgs; the DIY route means you own the YAML, permissions and bill. We found no independent benchmark of either. Best for teams already on Claude Team or Enterprise, and platform teams that want to own the workflow.

Bito

What it is. Bito's AI Code Review Agent reviews in Git, the IDE and the CLI, with one-click fixes and review analytics.

Pricing (Nov 11, 2026). Team is $12 or $15 per seat per month and Professional $20 or $25; the page shows two prices for each without labeling them, probably a Monthly/Annual toggle, which the page does not confirm. Both include 5K lines per seat per month, then $5 per 1K lines. Professional adds custom review guidelines, learning from feedback, Jira, Confluence and Google Docs integrations and CI/CD pipeline reviews. Enterprise is custom, with cross-repo impact analysis powered by AI Architect, multi-org support, SSO/SAML, a CSM and an SLA. Team is cloud only; Professional can be self-hosted for an extra $5 per seat per month. No free tier is listed, and Professional has a 14-day trial.

Strengths. GitHub, GitLab and Bitbucket support, IDE coverage (VS Code, JetBrains, Cursor, Windsurf), and the cheapest self-hosted route in the roundup. Weaknesses. The line-based overage ($5 per 1K lines beyond 5K) can surprise teams with large diffs, and we found no independent benchmark. Best for small teams that need Bitbucket plus a self-host option without an enterprise contract.

Benchmarks and Independent Data

No neutral, SWE-bench-style standard exists for AI code review. DeepSource, itself a code review vendor, wrote on February 26, 2026 that “each vendor runs their own benchmark, on their own dataset, and wins.” Greptile reported 82% recall on 50 PRs across 5 repos; Augment Code later reported 45% for Greptile on the same repos; Qodo reported 60.1% F1 on its own dataset; Macroscope reported a 48% detection rate on 118 bugs. Those numbers cannot be compared with each other.

Greptile's 50-bug test (July 2025, vendor-reported)

Greptile traced 50 bug-introducing commits across Sentry (Python), Cal.com (TypeScript), Grafana (Go), Keycloak (Java) and Discourse (Ruby), then replayed each bug as a fresh PR in a clean fork per tool. Tools ran on hosted plans with default settings and no custom rules. A bug counted only if the tool left an explicit line-level comment that identified the faulty code and its impact; false positives and style suggestions did not affect the score. The page notes tools change quickly, so results may be stale.

Per-severity, Greptile caught 58% of critical, 100% of high, 89% of medium and 87% of low bugs; Bugbot 58%, 64%, 56%, 53%; Copilot 50%, 57%, 78%, 87%; CodeRabbit 33%, 36%, 56%, 53%; Graphite 17%, 0%, 11%, 0%. Sample sizes are tiny (the critical-severity percentages imply roughly 12 bugs, so one catch moves the rate by about 8 points), the vendor wrote both the dataset and the rules, and the page itself lists Copilot at 54% while the per-repo counts sum to 52%.

Martian Code Review Bench (as of July 30, 2026, via Greptile)

Martian describes its benchmark as independent and open source: it samples public PRs, extracts each reviewer's actionable suggestions, and checks what developers changed afterward. Precision is the share of suggestions that matched a later developer change; recall is the share of developer fixes the reviewer had already flagged. We could read the leaderboard only through Greptile's own post, so the table is vendor-reported by Greptile even though the benchmark is not.

Read the margins: Greptile leads Codex by 1.4 F1 points, and CodeRabbit has the highest recall (51.6%) despite ranking fifth on F1. Copilot, Bugbot, Graphite, Claude, Qodo, Sourcery, Ellipsis and Bito do not appear in that five-row extract. Absence from an extract is not evidence of weakness.

How to Choose

Whatever you pick, run a two-week pilot on real PRs. Count three things: real bugs caught that humans missed, comments developers dismissed as noise, and cost per merged PR. Those three numbers beat any leaderboard. If your reviewer will sit next to autonomous agents that open PRs in isolated environments, our OpenSandbox runtime guide covers where that code runs. For adjacent infrastructure, see our LLM observability and eval tools roundup and the AI agent sandboxes roundup.

Rolling One Out Safely

1. Pick two candidates, one flat-seat and one usage-based, and enable both on a single active repo.
2. Set a spend cap before the first review (CodeRabbit monthly cap, Claude Code Review monthly limit, Copilot AI-credit budget).
3. Write three to five rules in the rules file your tool reads, and tell it to skip formatting that CI already enforces.
4. Keep rules on the default branch where the tool allows it. Claude Code Review reads REVIEW.md from the base branch, while Copilot reads instructions from the PR head branch.
5. Track dismissals for two weeks, then turn rule suggestions into config (for example CodeRabbit's emit path instructions command).
6. Keep humans as required approvers. No tool here replaces branch protection.

How We Evaluated

Every price, plan, platform and rule claim comes from a vendor pricing or documentation page fetched on Nov 11, 2026 and listed in Sources. Where a page was unreachable (Cursor Bugbot, Graphite blog bodies) or silent (Codex plans, Greptile base-plan platforms, Ellipsis review specifics), we say so. Benchmarks are labeled vendor-reported and carry date, dataset size and caveats. We did not run the tools ourselves for this edition, so there are no first-hand accuracy claims. There is no paid placement, no affiliate link and no sponsored label in this ranking. The order of sections follows the brief's tool list, not a score.

Verdict

Choose CodeRabbit if hosting breadth and rule control matter most, Greptile if detection depth matters most and you accept vendor-reported evidence, and Copilot if you want the least new procurement. Sourcery and Bito win on seat price. The Claude Code GitHub Action and Codex review fit teams that already live in those agents and want rules in version control. Cursor Bugbot deserves a trial once you confirm current pricing. No leaderboard here should outweigh a pilot on your own pull requests.

FAQ

Sources

All pages accessed Nov 11, 2026.

Vendor pricing and docs

• CodeRabbit pricing
• CodeRabbit supported platforms
• CodeRabbit review instructions
• Greptile pricing
• Graphite pricing
• Graphite blog index
• Graphite AI reviews docs
• GitHub Copilot code review docs
• GitHub Copilot plans
• GitHub Copilot plans and pricing
• Qodo pricing
• Sourcery pricing
• Ellipsis pricing
• Codex GitHub integration docs
• Claude Code Review
• Claude Code Review costs
• Claude Code GitHub Actions
• Bito pricing

Benchmarks and commentary

• Greptile, AI Code Review Benchmarks (July 2025, vendor-reported)
• Greptile, Martian Code Review Bench summary (July 30, 2026, vendor-reported)
• DeepSource, Every AI code review vendor benchmarks itself (Feb 26, 2026)
• Cursor forum, Bugbot pricing feedback (unverified for pricing)

Video

• GitHub, Using GitHub Copilot for code reviews: from VS Code to github.com