On June 1, 2026, GitHub Copilot stopped being an all-you-can-use tool and became a metered one — and the most consequential change is not the price, but what happens when you run out.
Why Copilot now hard-stops instead of degrading gracefully
Copilot now hard-stops when your credits are gone, where it used to keep working at reduced quality. Until June 2026, a developer who exhausted premium requests was silently downgraded to a cheaper fallback model and kept coding without interruption . As of June 1, 2026, GitHub states plainly that "fallback experiences are no longer available," and usage is "governed by available credits and admin budget controls" . When the credits run out, Copilot stops.
The practical difference for a working developer is the failure mode. The old behavior degraded gracefully: hitting a limit cost you model quality, not access. The new behavior fails closed. There is no quieter, cheaper tier waiting underneath — exhaust your allowance and the assistant goes dark mid-task.
This bites hardest because of how budget controls interact with pooled credits. An administrator can set a per-user cap, and that cap can halt one developer's Copilot access even while the organization-level pool still holds unspent credits . A heavy agentic session can drain an individual allowance fast, so the stop can arrive without much warning.
GitHub is candid about the reframing. The company says "Copilot is not the same product it was a year ago" and that "the current premium request model is no longer sustainable" .
"Fallback experiences are no longer available," GitHub states, with usage now "governed by available credits and admin budget controls." (source: GitHub Blog)
Developers noticed. The announcement discussion drew more than 400 comments and roughly 900 downvotes, with users reporting they could burn through a month's allowance in a single agent session . The rest of this guide unpacks what that metered bill actually looks like and how to forecast it.
The Copilot per-million rate table: a 40x spread from cheap to flagship
Under the new model, every metered action converts to GitHub AI Credits at a fixed rate of 1 credit = $0.01 . The base subscription prices did not move — Copilot Pro stays $10/month, Business $19/user/month, Enterprise $39/user/month — but the previously open-ended request pool is now a fixed monthly credit allowance. What you actually consume against that allowance depends almost entirely on which model you route to.
That is where the spread bites. Across GitHub's published per-1M-token rates, the cheapest economy model and the priciest flagship sit roughly a factor of 40 apart on output tokens — the same prompt can cost pennies or dollars depending only on the model selector:
| Model | Input / 1M tokens | Output / 1M tokens |
|---|---|---|
| GPT-5 mini | $0.25 | $2.00 |
| GPT-5.5 | $5 | $30 |
| Claude Sonnet 4.6 | $3 | $15 |
| Claude Opus 4.8 | $5 | $25 |
| Claude Fable 5 | $10 | $50 |
Source: GitHub Copilot models-and-pricing reference . GPT-5 mini output at $2.00/1M versus Claude Fable 5 at $50/1M is the 40x gap in practice — and long-context variants push the top end higher still.
The allowances differ by plan, and the individual versus organization split matters. Per GitHub's billing docs, individual tiers carry Pro 1,500 credits/month, Pro+ 7,000, and a new Copilot Max tier at $100/month with 20,000 credits . Organizations get Business 1,900 credits per user/month and Enterprise 3,900, but those are pooled at the billing-entity level rather than isolated per seat . A 100-seat Business deployment is therefore a shared 190,000-credit pool, where a handful of heavy agent users can draw against colleagues who barely touch Chat.
Not everything meters. Code completions and next-edit suggestions remain unlimited on paid plans — the autocomplete workflow most developers lean on daily is untouched . What draws down credits is the agentic surface: Chat, the CLI, the cloud agent, Spaces, Spark, and third-party coding agents. The practical takeaway is that your bill is now a function of two levers you control — how often you invoke the agent loop, and which model you point it at.
Why flat-rate pricing broke under autonomous multi-file rewrites
Flat-rate Copilot broke because the agent loop is a token furnace, not an autocomplete. A single agent-assisted session can burn $30–$40 of model work, and a complex debugging pass on a flagship (Opus-class) model can exceed 500K tokens — roughly $15 in one sitting . When one user can consume in an afternoon what a fixed seat price assumed for a month, the cross-subsidy that funded "unlimited" stops adding up.
The scale gap is what made the old model untenable. A 2026 arXiv study of token consumption found that agentic coding tasks consume on the order of 1,000x more tokens than code chat or code reasoning, with input tokens — the large-context file reads, tool definitions, and repeated re-prompts that feed each planning step — as the primary cost driver rather than the model's output . Multi-step planning, tool calls, and re-reads across a repo turn a single "fix this" instruction into dozens of metered round-trips.
Worse for any vendor pricing a flat seat: the cost of an identical task is not stable. The same study reports that runs on the same task vary by up to 30x in total token consumption, and that cost predictability is weak — models underestimate their own token use, and higher token use does not reliably improve accuracy . You cannot underwrite a fixed price against a workload whose spend swings 30-fold per invocation and whose extra spend buys no guaranteed quality.
GitHub's own language frames this as a structural concession, not a feature launch:
"The current premium request model is no longer sustainable," — GitHub, on moving Copilot to usage-based billing (source: github.blog) .
Read plainly, that is an admission that the vendor was absorbing inference spikes it could no longer price into a single number. The token meter is the inevitable consequence: when the unit of work is this variable and this input-heavy, the only honest line item is the one that tracks consumption. Which is exactly why how you pool and forecast those tokens — the subject of the next sections — now matters more than the headline subscription price.
How pooled allowances redistribute the bill across your organization
For teams, GitHub Copilot's usage-based model pools credits at the billing-entity level rather than isolating them per seat. A 100-seat Business deployment becomes a single shared 190,000-credit pool — 1,900 credits per user per month, multiplied across the org — in which heavy agentic users draw against the unused allowance of lighter ones . Enterprise plans include 3,900 credits per user per month under the same shared arrangement . The practical effect: spend is averaged across the team, so a few power users running multi-step agent loops no longer trip their own ceiling first — they consume the collective buffer.
That buffer is temporarily larger. From June 1 to September 1, 2026, GitHub is granting promotional pools above the standard allowance — Business orgs get 3,000 credits per user instead of 1,900, and Enterprise gets 7,000 instead of 3,900 . The gap is roughly 58% extra headroom for Business and 79% for Enterprise during the window, which can mask steady-state consumption until it expires.
| Plan | Standard credits/user/mo | Promo credits/user/mo (Jun 1–Sep 1, 2026) | Pooling |
|---|---|---|---|
| Business | 1,900 | 3,000 | Shared at billing entity |
| Enterprise | 3,900 | 7,000 | Shared at billing entity |
Pooling changes the admin role from counting seats to governing consumption. Administrators now set per-user budget caps, decide which models are permitted for which work, and enforce context hygiene — because input tokens and context length drive the bill more than message count . A hard cap can halt one user's access while other pools remain, so budget policy is now an operational lever, not a billing afterthought.
Cursor pushes the same logic further at the enterprise tier, exposing group-level spend limits, organization rollups of spend and token usage, and context-breakdown reporting that shows where tokens go across system prompts, tool definitions, rules, and skills . The convergence is telling: both vendors assume the buyer needs observability and caps, not just license counts — because under metered billing, the question "who is spending the pool" is the one that determines whether the bill stays predictable.
Cursor's approach vs. GitHub's: where the two pricing philosophies diverge
The two products meter the same underlying resource — tokens — but enforce limits at opposite ends. Cursor soft-caps: Individual Pro at $20/month and Teams at $40/user/month each include a set amount of model usage, and once that allowance is consumed, on-demand usage is billed in arrears rather than blocked . There is no hard stop at the included limit — work continues and the overage lands on next month's invoice. Copilot does the reverse: when credits and admin budget run out, access halts. That single design choice — bill-later versus block-now — is the sharpest divergence between the two.
Anthropic's Claude Code sits in a third position: hybrid, not purely metered. It is bundled with Claude Pro ($17/month on annual billing, $20 monthly), Max 5x ($100/month), and Max 20x ($200/month), with usage limits shared across Claude and Claude Code . When a user hits those limits, the options are explicit rather than silent: enable usage credits, switch to pay-as-you-go via a Claude Console account at standard API rates, or wait for the reset window .
Those API rates set the floor for the PAYG path. Per 1M tokens, Anthropic lists Haiku 4.5 at $1 input / $5 output, Sonnet 4.6 at $3 / $15, and Opus 4.8 at $5 / $25, with Claude Code Opus 4.8 fast mode (a research preview) at $30 / $150 on consumption-based plans or via usage credits . The fast-mode premium — six times the standard Opus rate — is a concrete reminder that latency and model tier, not seat count, now drive the bill.
The spectrum across the three vendors is clean:
- Copilot — hard-caps: credits plus admin budget controls can halt access mid-session.
- Cursor — soft-caps: included usage, then in-arrears overage with no interruption.
- Claude Code — bundles first, then optional pay-as-you-go at API rates.
What matters for a buyer is less which mechanism each vendor picked and more that all three have left the flat-rate era. Predictable, all-you-can-use billing is gone across the category; the remaining choice is between a bill that stops you, a bill that surprises you later, and a bill you opt into deliberately.
The September cliff: when promotional allowances expire
The clock that matters most is September 1, 2026. On that date GitHub's promotional organization pools collapse: Business orgs fall from 3,000 to 1,900 credits per user per month — a 37% cut — and Enterprise drops from 7,000 to 3,900, a 44% cut . The base subscription price does not change, so the same invoice line now buys roughly a third to nearly half less metered headroom. For any team whose consumption is not falling at the same rate, that is a direct increase in effective cost starting with the Q4 billing cycle.
The promotional window is doing more than padding allowances — it is masking steady-state economics. Through summer, a Business or Enterprise pool sized at the promo rate absorbs spikes that the September allowances will not. Heavy agentic users already brushing against the higher cap have no slack left once it tightens; their overage simply lands in October and November, charged at 1 credit = $0.01 against the per-model rates published across GitHub's separate billing pages . The pre-cliff months look calmer than the system actually is.
The hard problem is forecasting. No vendor-neutral tooling yet estimates credit burn for a feature branch, a PR review, or a multi-file migration before it executes, and runs on the same task can vary by up to 30x in token use, so a confident pre-flight number does not exist . That leaves observability as the only defense.
- Instrument before the cut, not after. Identifying a consumption pattern in October means the overage has already been billed.
- Set admin budget caps and per-pool limits now, while the higher promo allowance still cushions mistakes .
- Baseline July–August burn per user and model it against the September allowances to see who goes over.
Finance and procurement that wait for the first post-cliff invoice will be reading the damage, not preventing it.
Practical ways to forecast your Copilot bill before the cliff
Start by separating what costs credits from what is still free, because the two move on completely different lines. On paid plans, code completions and next-edit suggestions remain unlimited, while Chat, CLI, the cloud agent, Spaces, Spark, and third-party coding agents draw down your allowance . A developer who lives in autocomplete may never touch the metered pool; one who runs agent loops all day can exhaust a month's allotment in a single session . Audit your own task mix first — the answer to "what will this cost" is mostly a question of how much agent work you do, not how many seats you hold.
Model routing is the next lever. GitHub's per-million rates span GPT-5 mini at $0.25 input / $2.00 output up to long-context GPT-5.5 at $10 / $45 and Claude Fable 5 at $10 / $50 — roughly a 40x spread on input tokens across the range . Send routine work — boilerplate, simple refactors, doc edits — to cheap inference, and reserve frontier models for genuinely hard debugging or multi-file reasoning. Since input tokens dominate the bill and runs on the same task can vary by up to 30x in token use , context hygiene (smaller file reads, scoped prompts) is as important as model choice.
For organizations, the deadline is concrete: promotional Business and Enterprise pools of 3,000 and 7,000 credits per user drop to standard 1,900 and 3,900 on September 1, 2026 . Export per-seat credit consumption now, while the cushion is still in place, to identify the power users who will blow past the standard allowance, and configure per-user budget caps before the reset rather than after the first post-cliff invoice.
The blunt planning rule: heavy agentic users should budget $100+/month regardless of vendor, while completion-first users will likely find bundled allowances sufficient . Treat the next ten weeks as a measurement window, not a grace period — the teams that baseline burn, route models deliberately, and set caps before September will forecast their bills; everyone else will discover them.
Frequently asked questions
If my Copilot credits run out mid-month, does my access stop completely?
It can. The old silent fallback — where exhausting premium requests quietly dropped you to a cheaper model so you kept working — is gone; usage is now governed by available credits and admin budget controls, so a hard cap can halt your Copilot access mid-month . Your options are to wait for the monthly reset, buy additional credits, or switch to pay-as-you-go if your plan supports it .
Do code completions count against the monthly credit allowance?
No. Code completions and next-edit suggestions remain unlimited on paid plans . Credits are drawn down only by interactive and agentic features: Copilot Chat, the CLI, the cloud agent, Spaces, Spark, and third-party coding agents. In practice, a completion-first workflow can stay well within the bundled allowance, while the agent loop is what moves the meter.
Why can the same Copilot task burn wildly different credit amounts on different runs?
Because agentic runs are non-deterministic in token use. A 2026 arXiv study found that runs of the same task vary by up to 30x in total token consumption, with input tokens driving most of the cost and models underestimating their own usage . The variance comes from context window size (file counts, conversation length), the model chosen, and how many tool calls and re-prompts the loop generates before converging.
What is the cheapest configuration for running Copilot in an automated pipeline?
Route to the lightest inference and keep context tight. GPT-5 mini is the cheapest documented model at $0.25 input / $2.00 output per 1M tokens . Scope file reads narrowly to minimize input tokens — the dominant cost driver — and reserve flagship models such as Claude Opus 4.8 ($5/$25) and Claude Fable 5 ($10/$50) for genuinely hard problems, not routine or repetitive pipeline steps .
When do the promotional org credits expire, and how much does the allowance drop?
The promotional pools end September 1, 2026 . Business allowances fall from 3,000 to 1,900 credits per user per month (–37%), and Enterprise drops from 7,000 to 3,900 (–44%) . Organizations that adapted their consumption to the higher promo level without adjusting model routing or caps should expect a substantial Q4 2026 bill increase.
