What an AI code review costs: Auditor's model for each role, priced

Auditor has no seat price. Every review is a set of ordinary model requests made under your team's Auditor key, and you pay for those requests the way you pay for any other: the provider's list price for the tokens used, plus the 7.5% platform fee.

That makes the cost of a review something you can work out. This article lists the model behind each part of a review, shows the arithmetic, and gives the costs we measured in our eval.

The model for each role

A review has two layers. The rules pass checks the conventions your repository writes down. The deep review looks for bugs: find passes propose findings and a verifier checks each one before it's posted. A description can be written alongside, and documentation sources are read ahead of time.

The rules model bills input tokens only, so a rules pass on a small pull request usually costs a fraction of a cent. You can change the find, verify and description models on the Auditor page, for the team or one repository. The choices are limited to models your Directives allow, and if a Directive later blocks one, the review uses an allowed model and the check run says so.

Prices are before the platform fee, from the catalog on Oct 23, 2026.

The arithmetic for one review

Each call costs its input tokens times the input price plus its output tokens times the output price. A review adds up its calls and the fee goes on top.

Here is a Standard review worked through, with token counts we picked to show the arithmetic. They aren't measurements. Say each find pass reads 15,000 tokens of diff and file context and writes 1,000, and the verifier reads 10,000 and writes 1,000:

Three things move the total:

• Input is most of it. The find passes read the same diff three times. A bigger diff costs more on every pass.
• The verifier is pricier per token, but reads less. It sees each finding with the code around it, not the whole change. A clean change with nothing to verify makes only the three find calls.
• Thorough adds exploration. Each of its four passes can spend up to eight rounds reading and searching the repository, and the verifier up to five. Every round sends the conversation so far again, so input grows with each one, and the cost depends on how much the passes choose to read.

Standard has a ceiling you can work out. Each find prompt is capped at 90,000 characters of diff and 110,000 of file context, roughly 50,000 tokens, and each answer at 4,000 tokens. So one pass costs at most about $0.14 and three about $0.42, before the verifier and the fee. Pull requests over 3,000 changed lines skip the deep review by default. Thorough has no such fixed ceiling, which is what the spend caps below are for.

What the eval measured

Our eval runs the deep review on 22 pull requests with bugs we planted, using the default find and verify models. Its cost is estimated from each call's token usage and catalog prices, before the platform fee. These are the Oct 11, 2026 results:

The caveats matter here. The bugs are seeded and the answer key is ours. The eval covers the deep review only: no rules pass, descriptions or static analysis. 22 cases is a small sample, and most of the repositories are tiny, so Thorough has little to explore. Expect Thorough to cost more on a real repository than it did here. The method and every result are in How we measure an AI code reviewer.

Changing a role's model

For the same token counts, a review's cost moves with the model's price per token. Put a model with half the input price on the find passes and the find calls' input costs half as much. Token counts aren't the same across models, though, and a model that writes more or explores more can cost more than its prices suggest.

Price isn't the only thing that changes. A cheaper model may miss bugs the default finds, or describe a change less accurately, and our eval has only measured the default find and verify models. If you change a role's model, compare a few reviews in Logs before and after, for cost and for what was found.

Keeping spend bounded

• Monthly cap. The most Auditor may spend in a UTC month across every repository. It's a budget on the Auditor project, so every Auditor request is checked against it, and once it's reached new reviews are skipped with a neutral check run.
• Per pull request cap. The most Auditor may spend on one pull request across its reviews and fixes. It's checked before each review starts.
• When reviews run. The default reviews a pull request once, when it opens. Reviewing every push multiplies the cost by the number of pushes, though an incremental review reads only the commits since the last one.
• Where to see it. The check run shows an estimate, the Auditor page shows this month's cost per repository, and every request is in Logs under the review's run id.

Team budgets in Directives still apply on top of both caps.

Per review or per seat

The two models charge for different things.

A per-seat price is fixed per developer per month. It's predictable, and it doesn't change with how many pull requests a developer opens or how large they are. A developer who opens two pull requests a month costs the same as one who opens forty.

Per-review pricing follows usage. A quiet month costs little and a busy one costs more. Cost scales with the size of each change rather than with headcount, and a repository you rarely change costs next to nothing. The trade-off is that the bill is less predictable, which is why the caps exist.

To compare them for your team, divide a seat price by your expected cost per review. At the eval's means with the fee included, about $0.04 on Standard and $0.12 on Thorough, each $10 of monthly seat price buys about 250 Standard reviews or about 80 Thorough ones. At the real-file cases' Thorough mean, about $0.31 with the fee, it buys about 30. Your reviews will differ from both, so the most reliable figure is a month of your own reviews in Logs.