GitHub Copilot AI Credits explained: how your team's consumption really works

On 1 June 2026, GitHub quietly retired the "premium requests" system every Copilot guide was written about, and moved all plans to usage-based billing with AI Credits. If your team still thinks in "300 requests a month", their mental model is wrong — and wrong mental models are how a team burns its whole monthly pool by the 20th. Here's the new system, explained the way I explain it to the QA teams I train.

What your plan actually includes

• Copilot Enterprise ($39/user/month) includes 3,900 AI Credits per user per month. Copilot Business ($19) includes 1,900. One credit = $0.01, so your credits are literally the plan price converted to usage money.
• Credits are pooled. 100 Enterprise seats = one shared pool of 390,000 credits/month, not individual buckets. Your heaviest user and your lightest user drink from the same jug.
• No rollover. Unused credits are forfeited; the pool resets at 00:00 UTC on the 1st of each month.
• Temporary boost: existing Business/Enterprise customers get a raised allowance from June through August 2026 — so today's comfortable consumption will feel tighter from September. Plan for the real number, not the promo.

What's free and what burns credits

Never consumes credits: code completions and Next Edit Suggestions — the grey autocomplete text your team accepts all day. This stays unlimited on paid plans.

Consumes credits: everything that talks to a model on demand — Copilot Chat, Copilot CLI, the coding/cloud agent, Copilot code review, Spaces, Spark and third-party agents.

The cost formula (teach your team this one line)

Cost = tokens in + tokens out, priced at the chosen model's API rate, converted to credits.

There is no fixed price per question and no fixed "session limit" — a session costs whatever its tokens cost. Three things drive it:

• Model choice. A frontier model can cost many times the base model for the same question.
• Context size. Every file you attach, every repository index chunk pulled in, is input tokens.
• Conversation length. Each follow-up message re-sends the growing history. Turn 20 of a chat can cost more than the first ten turns combined.

Do memory and custom instructions reduce consumption?

This is the question I get most, and the honest answer is: not directly — they are extra input tokens on every request. Files like .github/copilot-instructions.md, organization instructions and personal instructions are injected into each chat request. But two effects usually make a lean instructions file a net saving:

• Cached tokens are cheap. Context that repeats verbatim between requests — which is exactly what instruction files are — is billed as cached input, roughly 10× cheaper than fresh input on many models.
• Fewer wasted turns. When Copilot already knows your stack, naming conventions and definition of done, you skip the correction rounds ("no, we use Playwright, not Selenium…"). Whole turns you don't send are the biggest saving available.

The flip side: a bloated 2,000-line instructions file is a tax on every single request from every user. Keep it to one screen of the things Copilot gets wrong without it.

Do agents reduce the limits? No — use them like a specialist

Agent runs are the most expensive single actions in Copilot: an agent plans, reads files, calls the model in a loop, retries — dozens of model calls for one task. The cloud agent additionally consumes GitHub Actions minutes. Creating your own agents or workflows doesn't raise or reduce any limit; it changes how efficiently credits convert into finished work.

The economics only work when an agent run replaces something longer: one well-scoped agent task ("add validation to these three endpoints, follow the pattern in orders.ts, run the tests") can be cheaper than an hour of meandering chat about the same change. A vague agent task ("improve the codebase") is the most expensive way to be disappointed.

Rule of thumb for the team: completions for typing, chat for questions, agents for well-defined tasks — in that order.

What happens when the pool runs out

• Admins choose per org: allow overage (usage continues at published rates and is billed) or block (AI features stop until the next cycle).
• Budgets can be set at enterprise, cost-center and per-user level. A per-user budget can cut one person off even while the org pool has credits.
• There is no automatic fallback to a cheaper model when a budget is exhausted — it just stops. Don't let a release week discover this for you.

Seven habits that keep consumption down

1. Default to the base model; escalate to frontier models only for genuinely hard problems.
2. Start a new chat per task — long threads re-send their whole history on every turn.
3. Attach the file the question is about, not the folder it lives in.
4. Keep instruction files lean; they ride along on every request.
5. Scope agent tasks tightly and point them at the pattern to follow.
6. Watch the usage dashboard (billing → AI usage) weekly, not at month-end.
7. Set per-user budgets before the first "who spent 40% of the pool?" conversation.

Sources: GitHub's usage-based billing announcement, usage-based billing for organizations, Copilot plans and VS Code's token-efficiency notes. Numbers checked 8 July 2026 — verify against the docs before making budget decisions; this system is new and moving.