Claude Code Review is generally available: how the multi-agent review works and costs

Claude Code Review is the managed pull request reviewer in Claude Code. Several agents read each change alongside the code around it, a verification step checks their findings against the code, and the findings that survive are posted to the pull request as inline comments and a check run. It left research preview on October 15, 2026, and is generally available for Team and Enterprise organizations. A review never approves or blocks a pull request, so the merge decision stays with your team.

This article explains how a review runs, what changed at general availability, how an Owner sets it up, what the review levels and triggers do, and how to estimate spend. It also compares the managed service with the Claude Code GitHub Action. Figures come from Anthropic’s documentation and announcements as of October 2026. Where a number is Anthropic’s own claim, the text says so.

What is Code Review, and who turns it on?

An Owner of your Claude organization turns Code Review on once, in the admin settings. After that, developers need no configuration: reviews start on new pull requests according to each repository’s setting. By default the review focuses on correctness, such as logic errors, security vulnerabilities and broken edge cases, rather than formatting preferences or missing test coverage.

Reviews run on Anthropic infrastructure, so you add no workflow files to your repositories. Inside a review, repository access is read-only. The review reads the diff and the surrounding code, does not build or run the project, and does not push commits.

How does a review run?

A review has four stages, as the documentation describes: find, verify, rank and post. Several agents examine the diff and the surrounding code in parallel. A verification step checks each candidate finding against the code and filters out false positives. The survivors are deduplicated, ranked by severity and posted to the pull request. Code Review chooses the Claude models its reviews run on, and the admin settings offer no model choice, so the review level is the setting you control.

Each review leaves three things on the pull request. Every finding is an inline comment on the line it concerns, a summary sits in the review body, and a check run named Claude Code Review lists the findings in its details. The check run does not conclude as a failure. When nothing is found, its title reads “Code review found no issues”, and Claude posts a short note on the pull request.

Anthropic’s research preview announcement shows how findings scale with change size. On Anthropic’s internal reviews, 84% of large pull requests (over 1,000 lines changed) got findings, averaging 7.5 issues, against 31% of small ones (under 50 lines), averaging 0.5 issues. Engineers marked less than 1% of the findings as incorrect. These are internal figures from the preview, not a benchmark.

What changed at general availability?

Anthropic’s general availability announcement reports three changes: faster reviews, tighter findings and a review level for each repository. They respond to preview teams, who said Code Review caught real issues but that they wanted reviews that were quieter, sized to each change and faster.

• Speed: most reviews now finish about 3x faster, from around 20 minutes to 6 to 10 minutes.
• Quality: findings state the problem, what triggers it and the fix, in a few sentences.
• Flexibility: an Owner sets Quick, Standard (the default) or Deep for each repository, so routine codebases get a quick pass and critical ones a deep review.

Anthropic also reports its own before-and-after figures. Before, 16% of its pull requests received substantive review comments; now 54% do. The announcement frames the tool as closing a coverage gap, while approval stays a human call.

How do admins set up Code Review?

An Owner turns it on under Admin settings > Claude Code, connects GitHub, installs the Claude GitHub App on the repositories and can set a review level and trigger for each one. The steps below follow the setup documentation.

Check eligibility first. Code Review is available on Team and Enterprise plans for repositories on GitHub, including GitHub Enterprise Server and GitHub Enterprise Cloud with data residency. It is not available to organizations with Zero Data Retention or the HIPAA configuration, and organizations that use customer-managed encryption keys cannot use it yet. Code Review is also not covered by Anthropic’s Business Associate Agreement. If developers use Claude Code through Amazon Bedrock, Google Cloud’s Agent Platform or Microsoft Foundry, you still need a Claude organization on one of these plans.

Setup needs the Owner role in the Claude organization, Owner access on the GitHub organization (or an Owner who installs and links the app for you), and write access to each repository you add.

1. Click Allow code review in the Code review section of Admin settings > Claude Code.
2. If a Connect GitHub dialog opens, click Connect. Select your GitHub Enterprise Server instance first if you use one.
3. Install the Claude GitHub App for the organization that owns the repositories, choose the repositories the app can access and approve the permissions. If the browser tab shows Finish connecting GitHub, click it.
4. Select the repositories you want reviewed and click Continue.
5. Click Finish in the Code review is set up dialog. Closing it any other way leaves the repositories added but Allow code review off.
6. Open a test pull request that is not a draft. A check run named Claude Code Review should appear within a few minutes. If the repository is set to manual, comment @claude review to start the first review.

The app requests a permission set broader than a review needs, because other Claude features share it, including the Claude Code GitHub Action and auto-fix for pull requests in cloud sessions. Have your security team read the full list before approving it. A custom GitHub App can cover the Action alone, but Code Review still needs the official app.

Every repository starts on After every push, the setting that runs the most reviews. Change it before a wide rollout, because each extra review adds to spend.

Which review level and trigger suit a repository?

Each repository has one review level, which sets how thorough a review is, and one trigger, which sets when reviews start. Standard is the default, and a repository without its own level follows the organization’s choice.

The three triggers are:

• Once after PR creation: a review runs when a pull request is opened, reopened or marked ready for review.
• After every push: a review runs on each push, and threads resolve automatically once you fix a flagged issue.
• Manual (@claude review): opening or pushing starts nothing. A comment starts one review, and @claude review always also subscribes the pull request to reviews on later pushes.

Drafts and pull requests from forks skip automatic reviews whatever the trigger. Anyone with write access can still request a review with a comment, and that works on drafts and forks too. Developers can change what gets flagged by committing REVIEW.md and CLAUDE.md files to the repository.

What does Code Review cost, and how do you estimate it?

There is no flat price per review. Code Review is billed on token usage through usage credits, separately from your plan’s included usage. The bill goes to your organization, not to the developer who opened the pull request. Spend is the cost of one review multiplied by the number of reviews that run.

A review’s cost scales with its level, the size of the change, the complexity of the surrounding code and the number of candidate issues that need verification. The number of reviews depends on the trigger. During the research preview, Anthropic said reviews generally averaged $15–25, scaling with pull request size and complexity. Treat that as preview-era context; the figure that matters is the Average cost column for your own repositories.

The cost documentation recommends a small pilot before a wide rollout:

1. Set a monthly spend limit for the pilot.
2. Turn on Code Review for a few representative repositories with Once after PR creation or Manual (@claude review).
3. After several reviews have run, read the Average cost column in the Repositories table.
4. Multiply that average by the pull requests the repository opens each month. For After every push, multiply again by the typical number of pushes per pull request.

A hypothetical example, not a figure from Anthropic: suppose a repository’s average is $20, it opens 100 pull requests a month, and under After every push it averages three pushes per pull request. The estimate is $20 × 100 × 3 = $6,000 a month. Under Once after PR creation, the same repository comes to $20 × 100 = $2,000. Drafts and forks get no automatic review, so count only the pull requests that do.

Set a monthly spend limit for the Code Review service at claude.ai/admin-settings/usage; it applies to the whole organization. Reviews are skipped when any of three things runs out: the Code Review spend limit, the organization’s overall monthly limit for usage credits, or the usage credits balance. They are also skipped when what remains is less than the expected cost of one review. The Code Review limit resets at the start of the next billing period, and reviews resume sooner if you raise it.

For Enterprise organizations, the announcement adds an offer: eligible Claude Enterprise organizations can claim at least $10,000 in Code Review credits by January 15, 2027. Credits expire 30 days after you claim them. Terms apply.

Code Review or the Claude Code GitHub Action?

Use managed Code Review when your organization is on a Team or Enterprise plan and you want reviews without workflow files to maintain. Anthropic describes it as the deeper and more expensive option, while the Claude Code GitHub Action remains open source. Choose the action when you are on another plan, or when you want to set the prompt, model, triggers and tools yourself.

With the action, the review is a workflow you own, built on the same Claude Code agent covered in the Claude Code review. The workflow below installs the code-review plugin and runs it on pull requests that open, update, reopen or become ready for review.

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-code.git"
          plugins: "code-review@claude-code-plugins"
          prompt: "/code-review:code-review --comment ${{ github.repository }}/pull/${{ github.event.pull_request.number }}"
          claude_args: '--allowedTools "mcp__github_inline_comment__create_inline_comment"'

Two lines decide where the review goes. The --comment argument makes Claude post its review on the pull request, as inline comments or as one summary comment when it finds nothing. Without it, the findings stay in the workflow run log. Keep the claude_args line even though the skill names the same tool, because the action starts the MCP server that posts inline comments only when --allowedTools names it.

The action skips drafts, closed pull requests, pull requests it judges not to need review, such as automated or trivial ones, and pull requests that already carry a comment from Claude. On public repositories GitHub withholds secrets from fork pull requests, so this workflow reviews only branches in the same repository. Quick setup starts from Claude Code: /install-github-app works only with github.com repositories and needs the GitHub CLI authenticated.

Each run consumes GitHub Actions minutes and API tokens. A subscription token draws on your plan instead of API billing. The documentation suggests capping the work with --max-turns in claude_args and with workflow timeouts.

How do you fit AI review into a process where people approve?

Treat the review as a second reader that finds candidate bugs before a person looks. The person approves, and the review never does. Match depth to risk, decide what gets flagged, and watch noise and spend through the first weeks.

The merge gate stays where your team already defined it. A review never approves or blocks, and the check run does not conclude as a failure, so it cannot gate a merge on its own. Anthropic describes its own use the same way: the review closes a coverage gap, and approval is still a human call.

Then tune. The default focus is correctness, and REVIEW.md or CLAUDE.md files add your own guidance. Code Review reads REVIEW.md from the base or default branch, never from the pull request’s own changes, so a pull request cannot change the rules that review it. Use Deep where a missed bug would be costly, Quick for routine code, and manual triggers on busy repositories where you opt pull requests in one at a time.

If you are starting from agent-written code, write down four things before turning anything on: the level for each repository, the trigger, the spend limit and who approves. Pilot one repository, read a month of findings, then widen. Agent-written pull requests make review the bottleneck, as the review bottleneck post covers. Harness engineering shows how guides and sensors make those pull requests mergeable before a reviewer sees them, and the async workflow post covers the background agents that open them. For help with that kind of rollout, see my AI engineering work.

Sources

1. Claude: Code Review is now generally available (Oct 15, 2026)
2. Claude Code docs: Code Review
3. Claude Code docs: Set up Code Review
4. Claude Code docs: Code Review costs and usage
5. Claude: Code Review research preview announcement
6. Claude Code docs: GitHub Actions