AI Features Now Run on Your Runners

On April 27, GitHub quietly posted a changelog entry that most engineering managers will skim past: Copilot code review will start consuming GitHub Actions minutes on June 1, 2026. Read it again. Every AI-powered code review on a private repo will now eat from the same pool of Actions minutes your CI builds depend on.

This isn't just a Copilot billing change. It's the first time GitHub has explicitly billed an AI feature through Actions infrastructure, and it reveals a pattern that will only grow: AI-native features consuming runner compute in ways that don't show up as a distinct line item. If your team can't separate AI-triggered runner usage from developer-triggered CI jobs today, June 1 will make that gap visible on your invoice.

The pattern, not just the announcement

Copilot code review runs on GitHub's agentic tool-calling architecture. That architecture executes on GitHub Actions using GitHub-hosted runners. Until June 1, those minutes are absorbed by GitHub. After June 1, they count against your plan's included minutes for private repos, with overages billed at standard Actions rates.

But code review isn't the only Copilot feature that burns Actions time. Copilot cloud agents already run on Actions runners. GitHub's own April 27 changelog notes that the cloud agent starts 20% faster with Actions custom images. That's not a coincidence. It's infrastructure convergence: GitHub is collapsing AI compute and CI compute onto the same billing plane.

The same day, GitHub also announced the shift to usage-based billing with AI Credits. Each Copilot code review will be billed in two ways: AI Credits for the inference cost, plus Actions minutes for the runner compute. That dual billing model is the template. Expect more features to follow it.

Why this is a visibility problem first

The cost itself might be manageable. The real problem is that you won't be able to tell where it's coming from.

GitHub's billing report shows total Actions minutes consumed per repository. It doesn't distinguish between a Copilot code review run, a Copilot cloud agent session, and your regular CI pipeline. They all show up as workflow runs against the same minute pool. If your Actions bill jumps 30% in July, you'll need to dig through workflow run logs to figure out how much of that was AI and how much was your test suite.

GitHub does offer Copilot usage metrics and Actions metrics as separate views, but there's no single dashboard that correlates the two. You're left cross-referencing Copilot review counts against Actions billing reports manually. For a team running 30+ Copilot reviews a day across a dozen repos, that's not a five-minute task.

This is also where the billing change intersects with org structure. Copilot code review can be enabled for non-licensed users via direct org billing. That means contributors outside your Copilot seat count can trigger Actions minutes on your tab. If you haven't reviewed who has code review access, you should do that before June 1.

How runner choice changes the math

GitHub's changelog notes that Copilot code review supports self-hosted runners and larger GitHub-hosted runners, both billed at different rates than the standard runners. That's worth paying attention to because the per-minute rate varies significantly by runner type.

Standard GitHub-hosted Linux runners (2-core x64) cost $0.006 per minute. That's the baseline rate most teams are on. For a single Copilot code review that takes 5 minutes of runner time, you're looking at $0.03. Sounds trivial. Now multiply that by 40 reviews per day across your org, five days a week. That's $30/week, or roughly $130/month, just for the Actions minutes portion of code review. The AI Credits charge is on top of that.

And those numbers assume standard runners. If your org has configured larger runners (4-core, 8-core, or GPU-backed), the multiplier goes up fast. GitHub's billing docs list larger Linux runners at rates proportional to core count.

The alternative is running those reviews on cheaper infrastructure. Tenki's x64 runners cost $0.002 per core-minute, compared to GitHub's $0.003 per core-minute on standard 2-core runners. That's a 33% reduction on the compute side alone. For that same 40-reviews-per-day org, the Actions minutes cost drops from roughly $130/month to about $87/month. Not transformative by itself, but the savings compound when you add regular CI workloads that also run on the same runners.

What to do before June 1

GitHub's own recommendations focus on reviewing billing settings and confirming budget controls. That's table stakes. Here's what actually matters for cost visibility:

1. Label your AI-triggered workflows

If Copilot code review triggers a workflow run, that run should be identifiable in your logs. Use workflow naming conventions or job-level labels that distinguish AI-initiated runs from human-initiated ones. GitHub's Actions metrics API lets you query workflow runs by name and status. If you can filter by a naming convention like copilot-review-*, you can at least approximate the split.

2. Set per-workflow spending limits

GitHub now supports budgets for Actions spending. Set one. Not just a global budget, but per-product budgets that let you cap Actions spending separately from other metered products. This won't stop the spending, but it'll alert you before it gets out of hand.

3. Audit who can trigger Copilot reviews

Since non-licensed users can trigger code reviews billed to your org, review the list of contributors with access. Remove access for anyone who doesn't need it. This is the simplest way to cap unexpected consumption.

4. Evaluate your runner cost

If Copilot code review and cloud agents are going to add a persistent baseline load to your Actions minutes, every dollar of per-minute cost reduction matters. This is where switching to cheaper runners pays off. On GitHub-hosted standard runners, you're paying $0.006/minute for a 2-core Linux box. On Tenki, the equivalent is $0.004/minute. The gap widens further at higher core counts.

The bigger picture: AI compute is CI compute now

GitHub's announcement frames this as a billing adjustment. It's bigger than that. The decision to run Copilot features on Actions infrastructure means AI and CI are no longer separate cost categories. They share runners, they share billing, and they share minute pools.

For platform teams that already track CI cost carefully, this means your cost model just got a new variable you didn't budget for. For teams that don't track CI cost at all, the June 1 bill might be the first time anyone asks "why did our Actions spend jump?"

The fix isn't complicated, but it does require action before June 1: get visibility into what's running on your runners and at what cost. Set budgets. Label workflows. And if your per-minute runner rate is higher than it needs to be, that's the easiest lever to pull.

Tenki runners plug into your existing GitHub Actions setup with no workflow changes. They're 30-50% cheaper than GitHub-hosted runners on real workloads, and Tenki's usage dashboard shows job-level time so you can separate AI-triggered runs from human-triggered CI spend. If the June 1 shift is going to add a new line to your bill, you should at least be able to read it.