Here we go. GitHub Copilot is the first to throw a stone into the pond, and this may inspire more than one company. The change taking effect today is not just another pricing tweak. It is a market signal: vendors are no longer hiding the inference cost of intensive AI-agent usage behind a flat subscription. GitHub Copilot remains accessible, but the open bar era is fading.

Many developers have become used to letting Copilot Chat, agents and high-end models run for long sessions inside repositories. With the new billing model, that habit becomes something to manage. The pattern is familiar from cloud: first comes productivity, then the invoice reveals the implicit usage.

Key takeaway

Starting June 1, 2026, GitHub moves from premium requests to GitHub AI Credits. Plans include monthly credits, but premium usage can create overages when usage-based billing is enabled.

What changes

GitHub Copilot is no longer only about paying for a seat. The subscription now comes with an AI credit allowance. Those credits cover requests that use premium models or premium capabilities: advanced chat, agents, costlier models and some intensive workflows. Classic code completions remain part of the product promise, but the center of gravity moves to premium models and agentic work.

GitHub's documentation states that included credits expire at the end of each month. If a user goes beyond the allowance and usage-based billing is enabled, the extra consumption is billed. If it is not enabled, premium capabilities stop until the next monthly refresh. Simple rule, big governance impact.

Plans and credits: short version

Quick vocabulary checkpoint before the table: 1 AI credit equals $0.01. Base credits are the fixed credits included with the subscription price. The flex allotment is an additional monthly allowance included on top, but variable: GitHub can adjust it over time as model prices, new models and infrastructure efficiency evolve. Base credits are consumed first, then the flex allotment is applied automatically.

PlanIncludedQuick read
Copilot Free ($0) Limited free allowance to try Copilot. Good for discovery, not for serious professional usage.
Copilot Pro ($10/user/month) 1,500 AI credits per month: 1,000 base credits + 500 flex allotment. The historical individual plan becomes an allowance to monitor when premium models are used.
Copilot Pro+ ($39/user/month) 7,000 AI credits per month: 3,900 base credits + 3,100 flex allotment. More comfortable for power users, but still not unlimited.
Copilot Max ($100/user/month) 20,000 AI credits per month: 10,000 base credits + 10,000 flex allotment. The largest individual plan, useful only when agentic usage is genuinely heavy.
Copilot Business ($19/user/month) 1,900 AI credits per user per month, pooled at the billing entity level. A practical company entry point if allowed models are explicitly managed. Existing customers receive 3,000 credits during the June 1 to September 1, 2026 promotional period.
Copilot Enterprise ($39/user/month) 3,900 AI credits per user per month, pooled at the billing entity level. Better suited to large organizations, but agent workflows can still create drift. Existing customers receive 7,000 credits during the June 1 to September 1, 2026 promotional period.

To read the billing mechanics without getting lost in marketing labels, these are the credit types that matter.

Credit typeWho uses it?What it meansWatch out for
AI credits All Copilot plans. The billing unit for AI usage. GitHub converts consumed tokens into credits based on the model used. 1 credit = $0.01. A long agent session on an expensive model consumes far more than a short question on a lightweight model.
Base credits Paid individual plans: Pro, Pro+, Max. Fixed monthly credits included with the subscription. They match the plan price: Pro 1,000, Pro+ 3,900, Max 10,000. This is the predictable layer: GitHub says it does not change.
Flex allotment Paid individual plans: Pro, Pro+, Max. Additional monthly credits included above base credits: Pro 500, Pro+ 3,100, Max 10,000. They apply automatically after base credits. The important word is flex: this allowance can evolve with model economics and infrastructure efficiency.
Pooled credits Copilot Business and Enterprise. Included credits per user are pooled at the billing entity level. Example: 100 Business seats = 190,000 shared credits. Useful to absorb power users, risky without per-user or cost-center budgets.
Promotional credits Existing Business and Enterprise customers from June 1 to September 1, 2026. During the transition period, Business receives 3,000 credits per user/month and Enterprise 7,000, instead of the standard amounts. Do not build the annual budget on the promo period: after it ends, usage returns to 1,900 and 3,900 credits.
Additional credits Users or organizations that allow overage. When the included allowance is exhausted, usage can continue if an additional dollar budget is configured. Without caps, this is where the FinOps surprise lands.

Watch premium models

The trap is not only request volume. Under the new model, cost depends on the model and the number of tokens consumed: a long frontier-model agent session will cost much more than a short lightweight chat question. And for Pro or Pro+ annual subscribers who remain on legacy premium request billing, GitHub still documents model multipliers: some models can consume 10x, 15x or more. In both cases, the conclusion is the same: two developers can send "one Copilot request" and burn very different amounts of budget.

This is where many developers are having a cold shower. There are plenty of reports of individual users cancelling Pro or disabling usage-based billing because they do not want to risk a monthly bill climbing very high, sometimes with projections above $600. Not every anecdote maps directly to enterprise usage, but the lesson is clear: cost is no longer intuitive.

The risk is not that Copilot becomes unusable. The risk is every team configuring it differently, premium models open everywhere, with no link between usage, value and budget.

— field notes

FinOps enters the IDE

We have seen this movie with cloud: teams gain speed, then the invoice exposes implicit behavior. Coding agents are following the same path. A premium model can be justified for a complex migration, critical review or deep debugging session. It makes much less sense for reformatting three files, generating boilerplate or reviewing a simple test.

The question is not "should we turn Copilot off?". That misses the point. The right question is: which models are allowed, for which profiles, on which use cases, with which budget cap and visibility? That is the same operating model I recommend in an enterprise AI strategy with governance: keep autonomy, but make trade-offs explicit.

Fast decisions

For companies, the first move should be preventing unmanaged overage. Enabling usage-based billing without caps, reporting and model rules is like handing a shared credit card to every coding agent. It may work for a few weeks. It rarely scales well.

Then define a simple matrix: standard models by default, premium models with justification, long-running agents reserved for tasks with a real return. Developers do not need bureaucracy. They need clear rules, an accepted budget and a fast path to request a stronger model when the work deserves it.

On a personal account, the minimum practical move is simple: set a budget and email alerts before enabling overages. It is not glamorous, but it is exactly what prevents end-of-month surprises. For more granular tracking inside VS Code, extensions are starting to appear, such as Tokenyst, which tracks Copilot Chat usage locally, reads Copilot session files, estimates consumed credits and exposes a monthly budget in the sidebar and status bar. Treat it as an operational visibility tool, not as an official accounting source.

Screenshot of the Tokenyst VS Code extension showing consumed Copilot credits, daily usage, model breakdown and repository breakdown
Tokenyst. The Marketplace screenshot shows the kind of view a developer needs: consumed credits, usage pace, model breakdown and repository breakdown. This type of tool helps catch drift before the end of the month.

One last operational point: teams will need to learn how to spend less wastefully. When every agentic session has a cost, prompt quality, context quality and enabled tooling become real FinOps skills.

  • Work on prompts: ask for a precise outcome, provide constraints up front, reduce unnecessary back-and-forth and use solid prompt engineering practices to get to the point.
  • Prepare clear instruction files: document project conventions, useful commands and boundaries, and use files such as CLAUDE.md when the tool supports them well.
  • Use relevant skills: load the right know-how at the right time instead of repeating the full context in every conversation.
  • Disable unnecessary MCP tools: keep only the connectors and tools needed for the task to avoid noise, unnecessary calls and context consumed for nothing.

In short: it will no longer be enough to launch an agent and hope it optimizes everything on its own. Teams will need to think through prompts, instructions and tools to optimize token consumption. I will cover practical token-usage optimization in a future article.

As in the 2026 LLM coding comparison, the winning setup will probably not be one model everywhere. It will be pragmatic routing: sober model for everyday work, premium model for hard tasks, and FinOps tracking to measure what actually creates value.

Sources