On June 1, 2026, GitHub Copilot’s billing model flipped from flat-rate subscriptions to usage-based AI Credits across all plan tiers. Pro is still $10 a month. Pro+ is still $39. Business is still $19 per user. Enterprise is still $39 per user. A new Copilot Max plan launched the same day at $100 a month for heavy agentic users. None of the existing plan prices changed on the invoice line. What changed is what those numbers buy.

Each plan now ships with a monthly AI Credits allowance — Pro gets 1,500 credits, Pro+ gets 7,000, Business gets 1,900 per user, Enterprise gets 3,900 per user. Individual plans include both base credits equal to their dollar price and a flex allotment on top; Business and Enterprise track 1:1 with plan price. One credit equals one cent of model usage. Once you blow through the allowance, every additional credit comes out of your card on file at the same penny-per-credit rate. There’s no monthly cap. There’s no fallback model. And for the developers who built their workflows around the agentic surfaces GitHub spent the last year shipping, the new math is brutal.

The early projections from heavy users on developer forums put agentic session costs at 10x to 50x what flat-rate Copilot used to absorb. One developer working primarily in Copilot Coding Agent modeled their previous $39-a-month bill against a typical month of agentic work at the new rates and landed at roughly $750 a month. That’s not a worst-case projection from a vendor critic. That’s a back-of-envelope from a paying customer with public receipts.

Quick Summary: What Changed on June 1, 2026

Detail	Info
Effective date	June 1, 2026
What changed	All Copilot plans converted to usage-based AI Credits
Plan prices	Pro $10/mo · Pro+ $39/mo · Business $19/user · Enterprise $39/user · Max $100/mo
Credit allowance	Pro: 1,500 · Pro+: 7,000 · Business: 1,900/user · Enterprise: 3,900/user · Max: 20,000 (1 credit = $0.01)
Still free	Code completions, Next Edit Suggestions
Removed	Fallback model (no degraded service after allowance)
Reported cost impact	10x–50x increase for agentic power users
Official source	GitHub Copilot billing docs

Bottom line: Code completion stays free. Agentic work just got expensive. If your team built workflows around Copilot Chat agents or Copilot Coding Agent, you need a spending cap and a routing plan before next week’s invoice.

---

What Actually Happened on June 1

GitHub framed the change in its June 1 changelog as a “more transparent, more flexible billing model for AI features.” The plain-English translation is that every interaction with Copilot’s agentic surfaces now meters against a credit balance, and once the balance hits zero, additional usage rolls onto the credit card.

The mechanics, in the order they affect a developer’s day:

Code completions are still free. Ghost-text suggestions in the editor — the original Copilot product — do not consume AI Credits. They never will, according to the billing documentation. The same applies to Next Edit Suggestions, the feature that proposes the next edit in a sequence after you accept a completion. If your entire use of Copilot is autocomplete in VS Code or JetBrains, your bill stays at the flat plan price and nothing changes.

Everything agentic meters. Copilot Chat conversations, Copilot Coding Agent tasks, agentic PR reviews, code-review agents, the new test generation flows, and the Workspace-style multi-step planning surfaces all draw from the AI Credits balance. Each turn debits credits based on which model is invoked and how many tokens the request consumes.

The fallback model is gone. Before June 1, when a Copilot user hit a rate limit or capacity issue, the service would silently route to a lower-tier model so requests still completed. As of June 1, that fallback is removed. Either you have credits and the requested model is available, or the request is rejected. The vendor framing is “no more surprise quality degradation.” The user framing is “no more soft cushion when capacity is tight.”

Individual plans include base and flex allotments. GitHub’s May 2026 announcement restructured the credit allowance for all three individual tiers simultaneously. Pro at $10 a month gets 1,000 base credits plus 500 flex — 1,500 total. Pro+ at $39 gets 3,900 base plus 3,100 flex — 7,000 total. The new Copilot Max plan at $100 a month gets 10,000 base plus 10,000 flex — 20,000 total — designed for developers running sustained agentic workflows. Business at $19 per user gets 1,900 per seat. Enterprise at $39 per user gets 3,900 per seat. The flex allotment is designed to adapt as model economics evolve, so treat it as the current baseline rather than a permanent guarantee. Once you’ve consumed the full allowance, every additional credit is a pass-through at $0.01 each.

No cap by default. A user with autopay enabled and the spending controls left at default can run an unbounded agentic session and receive an unbounded invoice at the end of the month. GitHub ships per-user and per-org spending limits as a configurable control, but the default is “no limit.” That default is the part that will produce the loudest July invoices.

Why the Agentic Math Looks 50x Worse

The reason power users are seeing 10x to 50x cost increases isn’t because the per-token price is high. It’s because agentic workloads consume vastly more tokens than the chat-and-completion patterns the old flat rate was tuned around.

A standard Copilot Chat turn might run a few thousand tokens of input and a few hundred tokens of output. At the new pricing, that’s pennies. A Copilot Coding Agent task that plans a multi-file change, reads a dozen source files for context, drafts a diff, runs tests, and iterates on failures can easily consume 100,000+ tokens across the orchestration. At penny-per-credit rates, a single non-trivial agentic session lands in the $1 to $5 range. Run twenty of those a day and the math compounds quickly.

The published comparison to Microsoft’s own internal coding workloads — the same scale story as our Polaris coverage, which detailed Copilot’s shift away from OpenAI’s GPT-4 Turbo — illustrates the shape. Polaris’s mixture-of-experts architecture is cheaper to serve per token than dense transformers, which is why Microsoft can absorb the model swap inside existing plan prices for completions. The agentic surfaces still call the full model for every step of the orchestration loop, which is where the metered cost adds up.

For the developer who modeled $39 a month at flat-rate and $750 a month at metered rates, the breakdown looked something like this:

• ~15 Copilot Coding Agent tasks per month at 4,000 credits each ≈ 60,000 credits/month → $600/month
• ~50 Copilot Chat conversations per month at 200 credits each ≈ 10,000 credits/month → $100/month
• ~20 agentic PR review sessions per month at 500 credits each ≈ 10,000 credits/month → $100/month
• Pro+ allowance covers the first 7,000 credits → -$70/month
• Plan price → $39/month
• Total: roughly $769/month, close to the developer’s published $750 estimate

That’s a single developer who was a heavy agentic user on the old plan. For the median Copilot user — completions and the occasional chat — the new pricing is roughly neutral or slightly cheaper. For the long tail of light users who barely touched chat, the new pricing is a small win because the credit allowance covers their usage with room to spare. The 10x-50x story is real and the “your bill is going down” story is also real. They describe different users.

How AI Credits Actually Bill

The mechanics of a single credit deserve a closer look because the framing “1 credit = $0.01” hides where the variance actually lives.

A credit is a unit of metered model usage, not a fixed token count. The number of credits a request consumes depends on:

1. Which model is invoked. Polaris-default chat turns are cheaper per token than premium model routing. Frontier-tier reasoning models (when Copilot routes to them for hard problems) cost more credits per token than the default coding model.
2. Token volume in and out. Input context — file contents, conversation history, retrieved code — all counts. Output tokens count. The longer the request and response, the more credits consumed.
3. Tool calls and orchestration overhead. Agentic flows that invoke search, file reading, terminal execution, and test runs each generate additional inference calls. Every step of the orchestration is its own metered request.
4. Multi-turn context. Long Copilot Chat threads that carry context across many turns pay for the cumulative context window on each new turn. A chat with 30 turns of conversation costs much more per new question than a chat with 3 turns.

The practical result is that two users running the “same” agentic workflow can produce wildly different credit consumption depending on context size, model routing, and whether the workflow includes multi-file reads. GitHub publishes a per-feature credit estimate inside the Copilot billing documentation, but the actual usage is highly variable. Budget against the high end of the published range, not the average.

What’s Still Free (And Worth Defending)

The free tier of usage inside the paid plans is worth defending because it covers the workflow that most Copilot users actually run.

Code completions. The ghost-text autocomplete in your editor. Unlimited. Same model that was serving you on May 31. The only meaningful change is that as of Project Polaris, the default completion model is Microsoft’s first-party mixture-of-experts architecture rather than GPT-4 Turbo — but that’s a quality story, not a billing one.

Next Edit Suggestions. The feature that proposes the next edit in a sequence based on the pattern of what you just accepted. Also unlimited. This is the surface that bridges single-line completion and full agentic work, and GitHub is keeping it free specifically because it’s the on-ramp to the paid surfaces.

Inline code suggestions across all supported languages. Including the low-resource languages — Rust, Haskell, OCaml — where Polaris’s specialized expert modules improved completion quality. The Rust developer who couldn’t get useful Copilot suggestions in 2024 is in a different position in June 2026, and that improvement lands inside the free completions tier.

For a developer whose Copilot use is bounded by completions and Next Edit Suggestions, the June 1 change is a non-event. Your bill stays at $10 a month. Your editor experience stays the same. The credit allowance you don’t use rolls forward… actually, no — credits do not roll forward. Each month resets to the plan allowance. The unused portion is forfeit. That detail matters for irregular users who might intend to “save up” credits for a heavy month. The plan doesn’t work that way.

How to Cap Your Spend This Week

Three concrete steps that every paid Copilot user should take before the June invoice cycle closes.

1. Set a spending limit. The default is “no cap.” Inside the Copilot billing settings at the organization or individual level, set a hard cap on overage spending. Pick a number you’d be willing to see on a credit card statement and use that as your ceiling. The control is opt-in and the default behavior of unbounded overage is the single biggest source of upcoming surprise invoices.

2. Audit your agentic usage. Pull your existing usage patterns from the Copilot dashboard. The view distinguishes completion usage (free) from agentic usage (metered). For most teams, the audit will show that agentic usage is concentrated in a small number of power users and a few specific workflows. That distribution is the input to the routing decision.

3. Decide what stays on Copilot. For workflows that are heavily agentic and high-value — Copilot Coding Agent tasks for migrations, agentic PR review, long Chat sessions for architecture discussions — the new pricing might still be the right deal. For workflows where the agentic surface is convenient but the work could be done with a different tool, the math may now favor Claude Code or Cursor on a different pricing model. The point is to make the decision deliberately rather than letting the invoice make it for you.

The Competitive Frame: Copilot vs Claude Code vs Cursor

The June 1 change reshapes the developer-economics comparison in ways that matter more than the headline rates suggest.

Against Claude Code. Claude Code is API-priced — every token in and out hits the Anthropic API rates directly. After the Opus 4.8 Fast Mode price cut, Anthropic’s premium tier is at $10 input / $50 output per million tokens. That’s roughly comparable to Copilot’s new metered rates for equivalent agentic work, depending on which Copilot model gets invoked. The honest read: Copilot used to be cheaper than Claude Code at the seat level for any developer doing more than light usage. After June 1, that gap closes or inverts entirely.

Against Cursor. Cursor sits in a hybrid spot — $20/month with unlimited Auto mode completions plus a $20 credit pool for manually-selected frontier models. Cursor’s model means a typical developer hits the metered tier less often than a typical Copilot user will hit the new credit overage. For Cursor’s existing users, June 1 is a recruitment opportunity. The cursor-vs-claude-code-vs-copilot frame just shifted in Cursor’s favor for the price-sensitive segment.

Against everything else. Windsurf, Google Antigravity, and the long tail of IDE-resident AI tools all watched their value proposition improve overnight without shipping a single line of code. The pricing dynamic that made Copilot the conservative default for enterprise procurement teams — predictable per-seat costs — is now a liability. Procurement teams who normalized on Copilot specifically because the budget was easy to model are about to discover that their model was modeling the wrong product.

The broader pattern matters. The DeepSeek 75% price cut and the Anthropic Fast Mode cut both reduced developer-economics friction. The Copilot move increases it. For the first time in a year, the most expensive coding assistant for heavy agentic users might be the one with the biggest installed base.

Where GitHub Is Likely Right (And Where It’s Likely Wrong)

A balanced read on the decision itself.

Where the move makes sense. Agentic workloads consume orders of magnitude more inference than completion workloads, and flat-rate pricing was subsidizing the heaviest users at the expense of the lightest. From a vendor margin perspective, the flat-rate model was losing money on the top 5% of users and overcharging the bottom 50%. Metered billing is the rational response. The decision to keep completions free preserves the on-ramp that brought most users to the platform. That’s defensible.

Where the move is a strategic mistake. Three things.

First, the no-cap default is a customer-experience landmine. The first wave of $750 invoices from developers who didn’t realize the autopay was unbounded will produce a public relations cycle that lasts longer than the savings on the billing change. Vendors with similar metered models — AWS, Vercel, Render — all ship hard-cap defaults precisely because the alternative is unsurvivable. GitHub chose to ship without one. That decision will get revisited.

Second, removing the fallback model removes the soft landing that made Copilot’s reliability story credible. Enterprise procurement teams that signed Copilot specifically because “it just works” now have to evaluate a tool that hard-fails when capacity is tight. That’s a different product than what was sold.

Third, the timing — three months before the Anthropic IPO window and two months before Project Polaris ships as Copilot’s default model — concentrates too much customer-facing change into a single quarter. A pricing change of this magnitude deserved its own news cycle, not a stack of overlapping product announcements that diffuse the message.

Our Take

The June 1 change is the right billing model packaged in the wrong way. Metered pricing for metered workloads is a rational vendor decision and a more honest reflection of what AI features actually cost to serve. The completion tier staying free is a smart preservation of the on-ramp. The credit math is clean enough that any developer can model their expected spend in five minutes.

What GitHub got wrong is the rollout. Shipping no default cap into a customer base that built workflows around flat-rate predictability is the kind of decision that produces the loudest possible feedback loop. The vendor will spend the next four weeks fielding angry support tickets and walking executive customers off the ledge, and the broader market signal — “GitHub is now expensive” — will outlast the actual usage data.

For developers, the practical answer is simpler than the politics. Set a spending limit today. Audit your agentic usage this week. Make a deliberate decision about which agentic workflows stay on Copilot and which migrate to a cheaper alternative. The completion experience is unchanged, and for most developers, the completion experience is what they were actually paying for.

The structural read is that GitHub Copilot is no longer the default conservative choice for enterprise procurement. That title is now contested — by Cursor on the IDE-first side, by Claude Code on the agentic-frontier side, and by the broader set of tools that just got cheaper relative to Copilot without doing any work. For the first time since 2023, the coding assistant market has a real pricing-driven competitive dynamic. The June 1 invoice cycle is going to be loud, and the August 1 procurement conversations are going to be louder.

Frequently Asked Questions

When did GitHub Copilot switch to token-based billing?

June 1, 2026. The change applied to all Copilot plans simultaneously — Pro ($10/mo), Pro+ ($39/mo), Business ($19/user), Enterprise ($39/user), and the newly launched Max ($100/mo). Existing flat-rate plans converted to the new AI Credits model on the same effective date with no grandfathering period for prior pricing.

How does the AI Credits allowance work?

Each plan gets a monthly allowance, with 1 credit equal to $0.01 of model usage. Individual plans include base credits plus a flex allotment: Pro gets 1,500 credits (1,000 base + 500 flex), Pro+ gets 7,000 (3,900 base + 3,100 flex), and Max at $100/mo gets 20,000 (10,000 base + 10,000 flex) — designed for sustained agentic workloads. Business gets 1,900 per user, Enterprise gets 3,900 per user. Once the allowance is exhausted, additional usage bills at the same penny-per-credit rate to the card on file. Unused credits do not roll forward to the next month.

What’s still free under the new billing model?

Code completions and Next Edit Suggestions are free across all paid plans and do not consume AI Credits. That covers the original ghost-text autocomplete experience plus the feature that proposes follow-on edits after a completion is accepted. Inline suggestions across all supported languages, including the low-resource languages where Polaris recently improved quality, all stay free.

Why are some developers reporting 10x to 50x cost increases?

Heavy agentic users — developers running multiple Copilot Coding Agent tasks per day, long Chat sessions, and agentic PR reviews — consumed inference volumes that the flat-rate plan was subsidizing. At metered rates, that volume converts to real dollars. One published estimate moved a developer’s bill from $39 to roughly $750 a month based on a typical month of agentic work. The median Copilot user is unaffected; the impact concentrates on the top 5-10% of usage.

Is the fallback model really gone?

Yes. Before June 1, when capacity was tight or a request exceeded usage thresholds, Copilot would silently route to a lower-tier model so the request still completed. As of June 1, that fallback is removed. Requests either succeed with the intended model or fail outright. The vendor framing is “no surprise quality degradation”; the user-facing impact is fewer soft landings during capacity-constrained periods.

How does this compare to Claude Code and Cursor on price?

Claude Code bills directly against Anthropic API rates — $5/$25 for Standard Opus and $10/$50 for Fast Mode per million tokens after the Opus 4.8 price cut. For comparable agentic work, Copilot’s new metered rates are roughly in the same range. Cursor sits at $20/mo flat with generous premium request quotas before metering. For heavy agentic users, Cursor and Claude Code are now likely cheaper than Copilot for the same workflows.

How do I cap my Copilot spending?

Inside the Copilot billing settings at the org or individual level, set a hard overage limit. The default is unbounded — autopay will charge whatever credits you consume above the included allowance. Setting a cap requires opt-in action. For organizations, the cap can be set per-user or aggregate; for individual Pro users, the cap is a single number. Setting the cap to zero effectively turns off metered billing entirely once the allowance is exhausted.

Does the change affect GitHub Copilot Enterprise differently?

Enterprise plans get the largest per-seat allowance (3,900 credits per user at $39/seat), but the underlying mechanic is identical to the other tiers. The fallback model removal applies to Enterprise as well. Most Enterprise contracts negotiated in 2024 or 2025 against flat-rate pricing will face the same metered conversion, with the per-user allowance acting as a partial buffer. Negotiating against renewal terms is the appropriate response for organizations whose engineering teams skew heavily toward agentic workflows.

Should we move off Copilot?

For teams whose use is primarily code completions, no — the experience is unchanged and the price is unchanged. For teams running heavy agentic workflows where the credit overage is going to dominate the bill, the answer depends on which alternative fits the workflow. Cursor wins on flat-rate predictability for heavy users. Claude Code wins on raw model quality at metered rates. The right move is to audit your usage this week and decide deliberately, before the invoice forces the decision.

---

Last updated: June 2, 2026. Sources: GitHub Copilot billing announcement · GitHub Copilot billing documentation · June 1 changelog · Copilot Coding Agent GA announcement · Anthropic pricing.

Related reading: Microsoft Build 2026: Copilot Gets Its Own AI Model · Claude Opus 4.8 Review · Claude Code Routines Enterprise Guide · Cursor vs Copilot 2026 · Cursor vs Claude Code vs Copilot · Cursor AI Review · DeepSeek’s 75% Price Cut · Anthropic Tops $900B Valuation · GitHub Copilot X Review · Windsurf vs Cursor · Google Antigravity vs Cursor vs Windsurf