Copilot Code Review Now Eats Your Actions Minutes

On April 27, GitHub announced that Copilot code review would start consuming GitHub Actions minutes. The change went live on June 1, 2026. If you run Copilot reviews on private repos, each one now draws from the same Actions minute pool your CI jobs use.

That sounds minor until you look at the billing math. For teams running dozens of PRs per day, review minutes stack on top of CI minutes and compete for the same finite quota. And if you're using AI coding agents that open PRs at machine speed, the compounding gets ugly fast.

What Actually Changed on June 1

Copilot code review used to run as a static model call. You'd request a review, Copilot would analyze the diff, and that was it. No Actions runner involved.

GitHub rebuilt the review system on an agentic tool-calling architecture. The code review agent now pulls in broader repository context, runs on GitHub-hosted runners (standard 2-core Ubuntu Linux by default), and uses tool calls to gather information beyond the immediate diff. That's a genuine improvement in review quality. But it means every review now spins up compute on GitHub's infrastructure.

Each review is now billed two ways:

1. AI Credits under GitHub's new usage-based billing model (replacing the old premium request units)
2. GitHub Actions minutes consumed from your plan's included entitlement for private repositories, with overage billed at standard Actions rates

This applies across Copilot Pro, Pro+, Business, and Enterprise plans. Public repos remain free from Actions minute deductions, but most commercial codebases are private.

The Billing Math

Let's walk through a concrete scenario. Take a 20-engineer team on GitHub Team (3,000 included Actions minutes per month) that merges about 30 PRs per day.

Copilot code review runs on standard 2-core Linux runners at $0.006 per minute. If each agentic review takes roughly 5 minutes of runner time (the agent needs to check out the repo, gather context via tool calls, run its analysis, and post comments), here's what that looks like:

• 30 PRs/day × 5 minutes = 150 review minutes per day
• 150 minutes × 22 working days = 3,300 review minutes per month
• That's already 3,300 minutes, more than the entire 3,000-minute Team plan quota

And that's just reviews. Your CI pipelines still need minutes too. If your test suites, linting, and deployment workflows already consume 2,000 minutes per month, you're now looking at 5,300 total minutes against a 3,000-minute quota. The 2,300-minute overage costs $13.80 at standard Linux rates.

$13.80 doesn't sound catastrophic. But the point isn't the dollar amount at this volume. It's the billing model change: review cost is now a variable that scales with PR volume, diff complexity, and how aggressive the agent's tool-calling is. You can't predict next month's bill from this month's.

Enterprise plans get 50,000 included minutes, which provides more headroom. But even there, review minutes are invisible additions to your Actions consumption that won't show up as a separate line item until you go looking.

Agent PRs Make This Worse

The 30-PR-per-day scenario above assumes human developers writing code. But that number is increasingly unrealistic as a ceiling.

Cursor, Claude Code, and GitHub's own Copilot coding agent all open PRs at machine speed. A team using these tools might generate 100 or more PRs per day, not 30. If Copilot code review is enabled as a required check on those repos, every agent-authored PR triggers an agentic review that consumes Actions minutes.

Run the same math at 100 PRs per day: that's 11,000 review minutes per month, costing $66 in raw Actions compute. Add CI minutes for those same PRs, and the total escalates. The compounding effect is what catches people off guard. Each agent-authored PR consumes Actions minutes three times over: once for the review, once for the CI pipeline, and again if the review suggests changes that trigger a follow-up push and re-run.

Tenki's Model: Outside the Billing Loop

Tenki's Code Reviewer charges $1 per review. That's the whole price. No Actions minutes consumed, no AI credit deductions from your GitHub account, no variable compute costs that fluctuate with diff size or tool-call depth.

The architectural difference matters. Tenki runs its review agent on its own infrastructure. When you request a review, Tenki's systems analyze the PR, post comments, and that's it. Your GitHub Actions quota is untouched. Your CI minutes remain available for CI.

For that 20-engineer team merging 30 PRs per day:

• 30 PRs/day × 22 days × $1 = $660/month with Tenki
• That number is the same whether diffs are 10 lines or 1,000 lines
• Zero impact on your Actions minute quota

Is $660 more than $13.80 in Actions overage? Obviously. But the Copilot number is misleading because it excludes the Copilot subscription itself ($19/seat/month for Business = $380/month for 20 engineers), the AI credits consumed per review, and the opportunity cost of those Actions minutes not being available for CI. The true Copilot cost is the subscription plus credits plus Actions minutes, not just the minutes alone.

There's also the quality question. Tenki's public benchmark shows a 68.9% recall rate (catching 84 out of 122 known bugs in the test suite) with an F1 score of 41.7. Copilot code review scored 24.6% recall and a 21.4 F1 on the same benchmark. You're paying more per review with Tenki, but you're catching nearly three times as many bugs.

The Broader Pattern: GitHub as Variable Cost Center

Copilot review consuming Actions minutes isn't an isolated decision. It fits a pattern where GitHub is converting platform features from fixed costs into usage-based billing.

GitHub Code Quality, announced recently, introduces per-committer pricing for quality scoring features. Copilot itself moved to usage-based billing on June 1. Actions minutes were always metered, but now more features draw from that same pool. Each of these changes is individually reasonable. Collectively, they make GitHub's total cost harder to forecast.

For engineering managers trying to set quarterly budgets, this is a real problem. You used to know what GitHub cost: seats times price. Now you need to model PR volume, agent adoption curves, diff complexity distributions, and Actions minute consumption patterns. That's FinOps work that didn't exist six months ago.

Tools that bill outside GitHub's metering system act as a hedge. Tenki's per-review price doesn't fluctuate with Actions consumption, doesn't compete with your CI quota, and doesn't change because GitHub decided to route another feature through the Actions billing layer. The cost is PR count times $1. That's a number you can put in a spreadsheet and trust next quarter.

What to Do Right Now

If you're running Copilot code review on private repos, check your June Actions usage now. GitHub's billing dashboard shows minute consumption, but it won't break out which minutes came from code reviews versus CI. You'll need to cross-reference with your Copilot usage metrics to get a clear picture.

A few things worth doing this week:

1. Audit your June Actions bill. Compare it to May. Any unexpected increase is likely Copilot review minutes.
2. Set an Actions budget. GitHub lets you cap Actions spending at the organization level. Set one if you haven't already.
3. Project forward. If you're planning to increase agent usage (Cursor, Claude Code, Copilot coding agent), multiply your expected PR volume by 5 minutes and add it to your Actions forecast.
4. Evaluate alternatives. If predictable billing matters to you, look at review tools that run outside the Actions billing loop entirely.

GitHub made Copilot code review better by making it agentic. But they also made it more expensive in a way that's easy to miss until the bill arrives. The question isn't whether the new architecture is an improvement. It is. The question is who pays for the compute, and whether that cost model works for your team at the PR volumes you're heading toward.