What Actually Changed on June 1, 2026

Copilot hasn’t been just a code autocomplete tool for a while now. Agent Mode launched in late 2024, multi-file editing arrived, and by early 2026, developers were running hour-long autonomous coding sessions — reading full repositories, making tool calls across dozens of files, and iterating in loops. The old billing model didn’t account for any of that.

Under the previous system, a quick one-line chat suggestion and a full multi-step agent session that rewrites 40 files cost you the same thing: one Premium Request Unit. GitHub absorbed the difference in actual inference costs. That gap became unsustainable.

The new model is straightforward: every time you use Copilot Chat, Agent Mode, or Code Review features, the token consumption is measured — input tokens, output tokens, and cached tokens — and debited from your monthly GitHub AI Credits pool at each model’s published API rate.

Why GitHub Made This Change

I went through the official announcement from Mario Rodriguez, GitHub’s Chief Product Officer, closely. The framing was honest. GitHub called out what most developers already sensed: Copilot in 2026 is a fundamentally different product from what launched in 2021.

The platform now runs long agentic coding sessions — often 20 to 50+ sequential tool calls for a single task. A developer triggering Agent Mode to “refactor the authentication layer and update tests” might cause the model to read a dozen files, generate changes across three modules, run checks, and iterate on errors. That’s a very different computational load from typing a comment and pressing Tab.

“Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount. GitHub has absorbed much of the escalating inference cost behind that usage, but the current premium request model is no longer sustainable.” — Mario Rodriguez, Chief Product Officer, GitHub (April 27, 2026)

Frontier models like Opus 4.8 run at $25 per million input tokens. Flat-rate pricing at $10/month simply doesn’t hold when someone spends three hours with an agent iterating across an entire codebase. The token-based model shifts that alignment back to actual usage.

Plan-by-Plan Breakdown: What You Get Now

Who Is Most Affected by This Change?

Not everyone using Copilot will feel this equally. If you’re mainly accepting inline suggestions and occasionally asking the chat a quick question, you may not notice much difference at all. The credit pool for Copilot Pro ($10 in AI Credits) stretches quite far for that kind of lightweight usage.

The real shift hits two groups hardest: heavy agentic users and enterprise teams.

Heavy Agentic Users

Developers who lean on Agent Mode for long sessions — the type who open Copilot, hand it a high-level feature request, and let it autonomously work through the codebase — are already feeling the burn. Reports surfaced on Reddit within 48 hours of June 1, with Pro+ subscribers hitting their $39 credit cap in a matter of days. One developer described spending the equivalent of €40 in credits over a few days of what felt like “normal” work.

The math explains it. A one-hour agent session doing multi-file reads, code generation, and test iteration can consume between 8% and 12% of a Pro subscriber’s entire monthly credit allotment. Five such sessions and the pool is gone.

Enterprise Admins

For Business and Enterprise teams, the billing mechanics shifted too. Good news: GitHub rolled out a promotional credit boost for June, July, and August — Business plans get $30 instead of $19, Enterprise plans get $70 instead of $39. That buffer should absorb most teams’ transition shock.

The bigger structural change for enterprises is the new pooled credits model. Previously, if a developer didn’t exhaust their monthly PRU allocation, those units just expired. Now, unused credits can pool across the organization — a meaningful improvement for teams with mixed usage patterns.

Old Policy vs June 2026 Policy: Side-by-Side

Is the New Policy Better Than the Old One?

Honestly? It depends on what kind of Copilot user you are. For light and moderate users, the new system is arguably fairer — you’re not subsidising someone running multi-hour agent marathons on the same $10 plan. For power users, it’s a real cost reckoning.

What Happens If You’re on an Annual Copilot Plan?

This is the part that tripped up a lot of people in the announcement, so let me spell it out clearly. If you’re on an annual Pro or Pro+ subscription, you don’t automatically migrate to AI Credits on June 1. You stay on PRU-based pricing — but there’s a catch.

On June 1, GitHub increased the model multipliers for annual plan subscribers only. That means the same models now cost more PRUs going forward until the plan expires, at which point you’re migrated to Copilot Free with the option to upgrade.

• Annual Pro/Pro+ subscribers: stay on PRUs until plan expiry, but face higher model multipliers starting June 1
• Monthly Pro/Pro+ subscribers: automatically migrated to AI Credits on June 1
• Annual subscribers can convert early to monthly and receive prorated credits for remaining annual plan value
• At expiry, annual subscribers transition to Copilot Free unless they manually upgrade

How Business and Enterprise Teams Should Respond

For engineering managers and DevOps leads, the June 2026 changes introduce new budget management responsibilities that didn’t really exist before. Here’s what I’d actually recommend looking at:

1. 1Enable the preview billing dashboard — GitHub launched this in early May, giving billing admins visibility into projected credit consumption before the month ends. Critical for catching runaway agentic sessions early.
2. 2Set budget controls per user and cost center — The new granular budget controls let you cap spending at the enterprise, cost center, and individual user level. If you have a few heavy agent users, cap them separately.
3. 3Review your code review policies — Since code review now also consumes GitHub Actions minutes, audit which PRs trigger automated review and whether the cadence makes sense.
4. 4Use the 3-month promo window strategically — The promotional credit boost (Business: $30, Enterprise: $70) runs through August. Use this window to benchmark actual team usage before setting permanent budget caps.
5. 5Evaluate Agent Mode governance — Some teams may need a soft policy around when Agent Mode is appropriate vs. simpler inline suggestions, to protect the monthly pool for higher-value use cases.

Model Cost Reference: Understanding the Token Rates

The AI Credits system charges based on the model you choose — and the variance is significant. Quick completions use lightweight models. Asking Copilot to run a full agent session with a frontier reasoning model is a very different cost picture.

The big practical takeaway: if you’re doing a routine refactor or want a quick code review, defaulting to a lighter model saves substantial credits. Copilot doesn’t always default to the cheapest model — being deliberate about which model you pick can significantly stretch your monthly pool.

7 Practical Ways to Stretch Your GitHub AI Credits

After spending time with the new billing system, these are the habits that actually make a difference when you’re trying to get the most out of your monthly pool.

Is Copilot Still Worth It After the Pricing Change?

This is the question I’ve been sitting with since June 1. The answer genuinely varies depending on how you use it.

For someone who uses Copilot primarily for inline suggestions, the occasional debugging chat, and a few PR reviews each month — yes, it’s absolutely still worth it. The credit pool at $10/month covers that usage without breaking a sweat. You’ll probably never hit the cap.

For someone running Agent Mode sessions daily, asking Copilot to autonomously tackle entire features or refactors — the calculus is trickier. The $39 Pro+ plan gives you more headroom, but a week of serious agentic development can still push through it. At that point you’re either purchasing additional credits or reconsidering whether a higher tier or alternative tool fits better.

I’ve seen some developers in the community migrate to BYOK (Bring Your Own Key) tools like Cline or Aider, which let you connect your own API keys and control costs at the model level. That’s a viable path for technically comfortable developers who want complete billing transparency. If you’re interested in the broader landscape of vibe coding tools and their pricing models, there’s a lot of legitimate competition now.

Quick Answers: Common Questions About the June 2026 Changes

Does my plan price go up?

No. Plan prices are unchanged. Copilot Pro stays at $10/month, Pro+ at $39/month, Business at $19/user/month, and Enterprise at $39/user/month. What changes is how that money translates to usage.

What happens when I run out of credits mid-month?

Unlike the old model where you could fall back to a cheaper model and keep working, the new system stops AI Credit-consuming features when you hit your limit. Code completions still work — they’re always included. For everything else you’ll need to purchase additional credits or wait for the next billing cycle.

Can I see my credit usage in real time?

Yes. GitHub launched a preview billing dashboard in early May 2026, available through your Billing Overview page on GitHub.com. Admins can see projected costs and individual user consumption.

Are cached tokens really billed?

Yes, but at a significantly lower rate than input tokens. For long context sessions that re-read the same files multiple times, caching reduces costs — but it doesn’t make repeated large-context reads free.

What about GitHub Copilot for Students?

Verified students on the GitHub Student Plan retain access through their student plan terms. The transition to AI Credits applies to commercial plans primarily. Check GitHub’s documentation for the latest student plan terms if your access is through an educational institution.