GitHub Copilot Moves to Token Billing June 1 What to Know

Starting June 1, GitHub Copilot usage-based billing replaces the flat-rate premium request model across all plans. Code completions stay free and unlimited. Everything else (Copilot Chat, agent mode, cloud agents, code review) now draws from a monthly AI credit allotment sized to match your plan price, where 1 credit equals $0.01.

The base subscription prices are not changing. Pro stays $10/month. Pro+ stays $39/month. Business stays $19/user/month. But the value you get for that price now depends on what you actually do with Copilot, not just whether you are a subscriber.

Why GitHub Is Making This Change Now

The structural problem with flat-rate premium request billing became obvious as agentic coding features matured. GitHub CPO Mario Rodriguez explained the tension directly: "Today, a short chat question can cost the user just as much as an autonomous coding session lasting several hours." Two subscribers paying identical monthly fees could be consuming a hundred times different amounts of compute.

Copilot launched as an autocomplete tool and the flat-rate model made sense for that use case. But agent mode, Copilot Workspace, and cloud agents changed the economics dramatically. A single agentic session that reads your entire codebase, writes tests, opens a pull request, and runs CI can make dozens of model calls and consume thousands of tokens. Charging the same as a quick snippet suggestion was never going to hold.

The June 1 change is GitHub's way of making the pricing reflect the actual compute cost of the features vibecoders are increasingly using every day.

The structure effectively splits Copilot into two tiers of usage: free-as-before (inline completions, Next Edit Suggestions) and metered-from-June-1 (everything agent-adjacent). If you have been leaning heavily on agent mode or Copilot Chat for your daily work, your effective cost per month is about to change.

What Actually Changes on June 1

Three concrete things shift.

First, premium request units disappear. The old model counted each "premium" interaction (a chat message, a multi-file edit, an agentic step) as a single request against your monthly allowance. The new model counts the actual tokens involved: input tokens, output tokens, and cached tokens. A longer conversation or a larger context window costs more credits than a short one.

Second, model choice becomes explicitly cost-sensitive. Heavier frontier models consume more credits per interaction. GitHub's docs note that annual plan holders who stay on request-based billing rather than switching to usage-based will see model multipliers climb sharply on June 1 as well (Opus 4.7 to a 27x multiplier; GPT-5.4 from 1x to 6x). On usage-based billing, you simply pay the token rate for whatever model you use, so the multiplier system does not apply, but heavier models still cost more per interaction.

Third, code review via Copilot in pull requests will also consume GitHub Actions minutes starting June 1, in addition to AI credits. Teams running automated code review on every PR now have two billing meters running for that single feature.

The practical implication depends entirely on your workflow. If Copilot means inline autocomplete with occasional light chat, June 1 changes almost nothing for you. If agent mode has become a regular part of your day, you need to look at your projected numbers before the switch happens.

Who Gets Hit Hardest by This Change

Three developer profiles should pay close attention before June 1.

Heavy agentic users are the most exposed. If you use Copilot agent mode to autonomously refactor files, run multi-step debugging sessions, or generate scaffolding across a codebase, each of those sessions now draws from your credit pool. A long agentic session using a frontier model on a large codebase can consume a meaningful fraction of a Pro allotment in one sitting. Visual Studio Magazine reported one developer projecting April costs of around €67 ballooning to approximately €966 under the new model (an extreme case, but it shows how agentic intensity amplifies the change).

Teams using Copilot for automated code review are the second group. Copilot code review in pull requests now runs against both AI credits and GitHub Actions minutes. Organizations with high PR volume and automated review enabled need to model this before June 1, not after the first billing cycle.

Developers on annual plans who do not migrate to usage-based billing face a different version of the same problem. Their request-based model multipliers increase sharply on June 1, reducing the effective value of each request if they are using heavier models.

The developers least affected are those who use Copilot primarily for inline completions or occasional light chat. For them, the June 1 transition is largely administrative, and the preview dashboard will confirm as much.

How to Check Your Exposure Before June 1

GitHub launched a preview billing dashboard in early May that shows your projected costs under the new model based on your actual usage history. This is the single most useful step you can take before June 1.

To access it: go to your GitHub billing settings, find the Copilot usage section, and enable the preview. The dashboard uses your historical usage to project what you would pay under token-based billing. If your projected monthly cost stays near your current plan rate, you are fine. If it spikes, you have a decision to make with nine days left to make it.

Three responses to what you find:

If projected costs are close to your current rate: no change needed. Monitor usage after June 1 and adjust if needed.

If projected costs are substantially higher: compare Claude Code (flat-rate subscription, no per-token billing for included usage) and Cursor (flat-rate, agent-first pricing) against what you would pay under the new Copilot model. Run the numbers for your actual workflow, not theoretical usage.

If you mostly use completions anyway: consider downgrading to Copilot Free (2,000 code completions per month included) and redirecting the subscription cost to a tool better suited to your actual usage pattern.

The preview dashboard is available now. Checking it takes five minutes. Not checking it means your first variable bill in June will be your data point, which is a worse way to find out.

Developer reaction to the announcement has been mixed. Some have appreciated the transparency (knowing what a session actually costs is genuinely useful information). Others are concerned about unpredictability. The GitHub community discussion thread raised questions about rollover behavior, credit visibility during sessions, and whether real-time cost feedback would be surfaced in the editor before you commit to a long agentic task.

What This Means For You

The Copilot billing shift is a signal beyond its immediate impact. Flat-rate pricing for agentic coding tools was always a temporary market condition. As agents become central to developer workflows rather than a premium curiosity, the economics of unlimited-but-throttled models stop working. Expect other AI coding tool providers to face the same pressure over time.

For vibecoders specifically, this makes the implicit cost of an agentic session visible for the first time. That visibility is useful, even when the numbers are uncomfortable. It forces a real accounting of which workflows justify frontier-model compute and which are better served by lighter tools.

• If you use Copilot mostly for completions: check the preview dashboard once, confirm your costs are stable, then move on. This change is not really aimed at you.
• If you are a heavy agentic user: run the preview dashboard today, compare your projected spend against Claude Code Max or Cursor Pro, and make an informed decision before June 1.
• If you manage a team: audit your organization's Copilot usage pattern before the transition. Teams with high agentic intensity should model the new costs now rather than explaining a surprise budget overage in July.