What GitHub Copilot's move to usage-based billing means if you work from the CLI

On June 1, 2026, every GitHub Copilot plan moved to usage-based billing. The old premium request units (PRUs) are retired. In their place is a token-metered currency called GitHub AI Credits, where one credit is worth one cent, and each model interaction is converted into credits based on the input, output, and cached tokens it consumes, priced at each model's published rate.

GitHub's stated reason is that Copilot stopped being the product it was. A one-line completion and a multi-hour autonomous session used to draw the same charge, and as agentic use became common, that flat model stopped lining up with the compute behind it. Usage-based billing ties the price to the work.

For anyone whose Copilot use is mostly autocomplete, this is close to a non-event. For anyone running Copilot as an agent from the terminal, it changes which decisions carry a cost. Here is what actually shifted, and where it lands hardest.

What replaced what

Before June 1, billing counted requests. Each model interaction cost one PRU, scaled by a model multiplier, and your plan included a monthly allowance of those requests.

After June 1, billing counts tokens. The cost of an interaction depends on the model and how many tokens it moves, input plus output plus cached. Each paid plan ships with a monthly pool of included credits, with the option to set a budget for anything beyond it. Published figures put the included pool at 1,500 credits for Pro, 7,000 for Pro+, and 20,000 for Max, with Business and Enterprise getting pooled per-user allowances.

One detail matters for planning: annual Pro and Pro+ subscribers stay on the old request-based model until their term ends, and some model multipliers went up for them on June 1. So an annual plan does not avoid the change. It defers part of it while making the expensive models cost more of the old allowance.

The half that did not change

The most important thing to know before bracing for impact is what the switch left alone.

Inline code completions and Next Edit Suggestions are still unlimited and still not billed. If your daily Copilot habit is autocomplete in the editor, your costs look the same as they did in May. There is no meter to watch on that surface.

The metering attaches to everything else: chat, and above all the agentic runs that read files, plan, execute commands, and loop. That is the part of Copilot that grew the fastest, and it is the part the new model is built to price.

Why the CLI is where this is felt

From the terminal you choose which model handles a request. Until June, that choice was about quality alone. Reaching for the strongest model on a small task cost nothing visible.

Now the per-token prices sit behind that choice, and the spread between models is wide. One cost analysis of GitHub's published rates noted that output on the most expensive listed model runs many times the cost of the cheapest, enough that picking a heavyweight model by reflex is effectively a billing mistake. Running a frontier model to reformat a paragraph is no longer just overkill. It is billable overkill.

For CLI-heavy and agentic workflows, that turns two ordinary habits into cost decisions: which model you default to, and how long you let a session run. A sprawling, all-day agent session now has a price attached to its length, not only to its outcome.

How heavy is heavy

The included pools sound generous until you see them against real agentic use. On the GitHub community thread, one Pro+ user reported spending around 360 credits in a single ordinary day of development and projected that a normal month would run well past the included 7,000.

That figure is one person's workload, not a benchmark, and how close you come to it depends entirely on how agentic your days are. The useful takeaway is the shape, not the number: under the new model, an "ordinary" day has a credit cost, and for people who lean on agents, that cost can climb faster than the monthly pool suggests.

The new controls, and one wrinkle

Alongside the billing change, GitHub shipped budget controls, including a hard stop when you reach your limit and a usage view that shows credits draining through the month. There is also a pay-as-you-go path that lets you keep working on your current plan after the included credits run out, instead of being forced to upgrade.

The wrinkle worth flagging for teams: Copilot code review now runs on an agentic architecture, and starting June 1 it consumes GitHub Actions minutes on private repositories in addition to AI Credits. So a single pull request review can hit two separate lines of the bill, the model cost and the runner minutes. Public repositories keep free Actions minutes.

What to watch

Whether the switch makes Copilot cheaper or pricier is not a single answer. For autocomplete-first users, it is roughly neutral. For agent-first CLI users, the bill now tracks how aggressively they run sessions and which models they pick, which can cut either way depending on discipline.

Two things are worth keeping an eye on. First, the model price spread rewards matching the model to the task, so a deliberate default model plus selective escalation is now a cost strategy, not only a quality one. Second, the budget hard stop is the cleanest guard against a surprising month, and it is the kind of setting that is better turned on before it is needed than after.

The larger pattern is the one GitHub is explicit about: agentic coding has cloud economics now. The terminal is where that lands first, because the terminal is where the long, autonomous, token-hungry sessions happen.

Sources: GitHub's announcement "GitHub Copilot is moving to usage-based billing" and the June 1 changelog "Updates to GitHub Copilot billing and plans" (github.blog). Included-credit figures are from GitHub Docs; the per-day usage figure is from GitHub Community discussion #192948; model-rate analysis from published Copilot per-token rates.