Starting today, GitHub Copilot dropped its flat-rate premium request model and switched every plan to token-based AI Credits. For any business running agentic coding workflows, the math just changed in ways the monthly invoice will make very clear, very soon.

Any engineering manager who approved a Copilot Enterprise license this year did it with a predictable number in mind: $39 per seat, per month, with some fuzzy notion of "premium requests" as the cap. Starting today, that number is still $39, but what happens above it just changed entirely. GitHub officially moved all Copilot plans to usage-based billing on June 1, replacing the old premium request model with a token-consumption system called GitHub AI Credits. The plan price didn't move. The exposure did.

This is the kind of infrastructure change that tends to land quietly and then show up loudly on the next invoice.

What actually changed

Under the old model, Copilot tracked "premium requests" - a discrete count that capped how many times you could use a high-quality model in a month. It was blunt and imprecise, but it was bounded. You could overshoot your limit and fall back to a lighter model, but you wouldn't get a bill for it.

The new model works differently. Every Copilot plan now includes a monthly allotment of AI Credits, where one credit equals $0.01. Those credits are consumed by token usage across inputs, outputs, and cached context - the same underlying pricing mechanics that API customers have always dealt with. Code completions and Next Edit suggestions are excluded and remain unlimited. But any chat session, any agent run, any multi-step Copilot task now draws from the pool.

The included allotments match the plan prices: Business customers get $19 in credits per user per month, Enterprise gets $39. GitHub is running a promotional bump through August - Business gets $30, Enterprise gets $70 - to cushion the transition. After that, the pool returns to baseline.

The critical detail is what happens when the pool runs out. Previously, you got a degraded fallback. Now, organizations choose: either hard cap and stop usage, or allow overage at published API rates. There is no automatic safety net.

Why agentic coding changes the math entirely

The shift to token-based billing would be a minor administrative change if Copilot were still primarily an autocomplete tool. It isn't.

Over the past year, Copilot has pushed heavily into agentic mode: autonomous coding sessions where the model plans a task, reads across the repository, runs tests, iterates on failures, and generates large output across multiple files. These sessions are exactly what GitHub has been marketing as the future of developer productivity. They are also, by a wide margin, the most token-intensive thing you can do with the product.

GitHub acknowledged this tension directly in the announcement. They noted that a quick chat question and a multi-hour autonomous coding session now cost the same under the old model, and that GitHub has been quietly absorbing the difference. That era is over. An agentic session that spans an afternoon can burn through $30 to $40 in token consumption, according to estimates circulating in developer communities. Under the old model, that counted the same as asking Copilot to explain a function.

For teams that are primarily using Copilot for chat and completions, the change will be invisible. For teams that have adopted agent mode - the use case GitHub has been actively selling - it is a meaningful repricing, even if the headline number stayed flat.

What this means for business and operations leaders

The practical implication for anyone managing engineering budgets is that Copilot is now variable spend, not fixed spend. That requires different controls and different visibility.

GitHub is giving admins budget management tools: spend caps at the enterprise, cost center, and user level, plus a preview billing dashboard that will show projected consumption before the month closes. The pooling change is also genuinely useful - instead of each seat's unused credits evaporating at month end, they can be shared across the organization, reducing stranded capacity.

But the governance requirement is new. Someone needs to own the Copilot line item the way someone owns AWS spend. That means setting policies on which agents can run, for how long, and against which repositories. Teams that have simply turned Copilot on and let developers use it freely will need to revisit that posture.

There's also a procurement implication. The move to usage-based billing coincides with GitHub pausing self-serve Copilot Business plan purchases - a reliability measure during the transition - which means any team that hasn't formalized their contract may find fewer upgrade paths available until that pause lifts.

The honest caveat

GitHub is being transparent about why this happened, and the reason is cost pressure, not a new customer benefit. Training developers to rely on agentic coding, then repricing the compute that makes it work, is a tension the industry hasn't fully resolved. Some teams may find that agentic workflows they treated as essentially free are now meaningfully expensive at scale. A team of 50 engineers running regular agent sessions could overshoot the included pool every month without a lot of effort.

The promotional credits through August are a buffer, not a solution. The longer-term question is whether the productivity gains from agentic coding justify the variable cost, which is a harder calculation than it sounds when the person doing the coding isn't the one watching the billing dashboard.

The larger pattern

GitHub's move is one data point in a broader repricing of AI that's been underway for several months. The tools that entered the market on flat-rate models are migrating to consumption pricing as their underlying compute costs become visible. Copilot, Cursor, and similar products all face the same structural pressure: agentic use is what they're selling, and agentic use is expensive to serve.

What makes today significant is the scale. Copilot has more than a million organizational users. When the largest AI coding product in the enterprise market shifts from flat to variable, it creates a precedent. The AI tools budget that once looked like a tidy SaaS line item is becoming something that looks more like cloud infrastructure - elastic, useful, and in need of the same kind of governance that cloud infrastructure requires.

Businesses that get ahead of that governance now will be better positioned than those that discover it through an unexpected invoice in July.