What are GitHub AI Credits?

GitHub AI Credits are the usage meter GitHub Copilot switched to on June 1, 2026, replacing the older premium-request counter. One credit equals one cent of model usage. Each paid Copilot plan includes a monthly credit pool ($15 on Pro, $70 on Pro+, $200 on Max), and chat, agent mode, code review and the Copilot CLI draw it down. Plain code completions do not use credits and stay unlimited on every paid plan. When the pool runs out, you buy more at a cent per credit, capped by a budget you set.

That change turned Copilot from a flat subscription into a subscription plus a meter, which quietly moved it into the same billing shape as most of the category. Here is what the credits are, what burns them, and how to keep the bill under control.

How much is one GitHub AI Credit?

One GitHub AI Credit is worth one cent of underlying model usage. That one-to-one mapping to a real cost is why GitHub calls the model token-based rather than request-based: instead of counting how many premium requests you made, it charges for the model work each request actually consumed. A short chat message costs a few credits; a long agent run that reads files, plans, edits and tests can cost many more, because it makes far more model calls.

The practical upshot is that no two tasks cost the same. Under the old premium-request system, one request was one request. Under credits, the price of a task is only clear after you run it, which is exactly the property that makes usage-based billing hard to forecast.

What uses GitHub AI Credits?

Not everything Copilot does draws credits, and knowing the split is the key to controlling the bill. Code completions and next-edit suggestions, the everyday autocomplete most developers use most of the time, are unlimited and free on paid plans. Credits are consumed by the heavier features: chat, agent mode, Copilot code review and the Copilot CLI.

The pattern is that the more autonomous the feature, the faster it spends. An agent run touches many files and makes many model calls, so a developer who leans on the agent all day will drain a credit pool that a developer who only uses autocomplete would never notice.

How many credits does each plan include?

Copilot Pro includes $15 in monthly credits, Pro+ includes $70, and the individual Max plan includes $200. Copilot Business and Enterprise pool credits across the whole organization rather than giving each seat a fixed amount, and GitHub points buyers to sales for the current pooled terms. When a pool is exhausted, you can buy more credits at a cent each, and both individuals and organizations can set a spending cap so the meter cannot run away. The GitHub Copilot pricing page lays out the allowance on every tier.

How do you keep GitHub AI Credit usage down?

Three habits keep the meter honest. First, reserve the agent for tasks that genuinely need it and keep unlimited autocomplete for everyday work, since that is where most of the value sits at zero credit cost. Second, set a hard budget cap so a runaway agent session cannot produce a surprise invoice. Third, give someone ownership of the pool on a team plan: because credits are shared, it helps to route the credit-heavy work to the right owner rather than letting every developer draw on the pool without visibility.

None of this is unique to GitHub. Usage-based billing is now the default across AI coding tools, and the reasons are the same everywhere: running an agent has a real per-task cost that vendors pass on. We walk through that shift in why AI coding tools use credits, and compare which tools meter and which bill flat in the AI coding tool pricing comparison.

Why did GitHub switch to AI Credits?

The switch from premium requests to credits was about matching the price to the real cost of the work. A premium request was a flat unit no matter how much model work it triggered, which meant a quick question and a sprawling agent run counted the same. That worked while most usage was chat, but agents changed the shape of the bill: a single autonomous task can make dozens of model calls, and charging one flat request for it left GitHub absorbing wildly variable costs. Tying the meter to a cent of model usage passes that variability through transparently.

For buyers, the honest read is that credits are fairer per task and harder to forecast per month. You pay closer to what each task truly costs, which is defensible, but your monthly total now moves with how hard your team works, which the flat premium-request model hid.

How do AI Credits compare to premium requests?

The difference is granularity. Premium requests counted actions; credits count consumption. Under the old system you could reason about your allowance in whole requests, and a heavy task and a light one drew the same. Under credits, the same allowance stretches further on light chat and disappears faster on agent runs, so two developers on identical plans can have very different months. If you are used to thinking in premium requests, the mental shift is to stop counting actions and start estimating model work, because that is what the meter now measures.

Credits versus a flat bill

AI Credits are a fair way to price variable work, but they move the budgeting risk onto you: the tool now has a reason to do more, and your invoice follows. The alternative is a flat plan with no meter at all. Agentcode charges one monthly price from $29 with no credits and no per-task counter, so an agent that opens pull requests on GitHub or GitLab costs the same in a busy month as a quiet one. It does not do editor autocomplete, so for many teams the real question is not credits versus flat, but which tool to run for which job.