Starting today—June 1, 2026—GitHub Copilot is no longer an unlimited AI coding assistant. It's a metered utility.

GitHub announced the change in April, but the transition goes live this morning. Base subscription prices stay the same ($19/user/month for Business, $39/user/month for Enterprise), but how you're billed just changed completely.

If your developers lean heavily on AI-powered chat sessions, autonomous coding agents, or multi-file refactoring, your monthly Copilot bill could double or triple. If they stick to basic code completions, you might actually spend less.

Either way, every CTO, CFO, and VP of Engineering managing GitHub Copilot budgets needs to understand what changed overnight—and what it means for next quarter's software spend.

What Changed: From Unlimited to Pay-Per-Token

The old model: Fixed monthly seat pricing with "unlimited" usage (subject to soft throttling via Premium Request Units).

The new model: Fixed monthly seat pricing PLUS pay-per-token consumption for everything except basic code completions.

Here's the breakdown:

Still Included (Free)

• Code completions (autocomplete suggestions)
• Next Edit suggestions

Now Metered (Consumes AI Credits)

• Copilot Chat (in-editor Q&A)
• Agentic coding sessions (multi-step autonomous work)
• Code review (PR analysis and suggestions)
• Multi-file editing

The New Currency: GitHub AI Credits

GitHub replaced Premium Request Units (PRUs) with GitHub AI Credits. One credit equals $0.01 USD.

Token consumption determines credit usage. Input tokens, output tokens, and cached tokens all count. Each model has different token costs—Opus 4.7 (if you have Pro+ access) costs far more per token than Sonnet 3.5.

Monthly credit allotments:

• Copilot Business: $19 in AI Credits (same as seat price)
• Copilot Enterprise: $39 in AI Credits (same as seat price)
• Copilot Pro (individual): $10 in AI Credits
• Copilot Pro+: $39 in AI Credits

Promotional bonus (June–August 2026 ONLY):

• Business: $30/month (instead of $19)
• Enterprise: $70/month (instead of $39)

After August, organizations drop back to the base allotment. If your team burns through $70/month during the promotional period, expect a budget shock in September.

Why This Matters: Agentic AI Costs 10-100x More Than Autocomplete

GitHub's shift to usage-based billing isn't arbitrary. It's a response to the compute economics of agentic AI.

Code completions (autocomplete as you type) consume minimal tokens. A single completion might generate 20-50 tokens. That's fractions of a cent.

Agentic sessions (autonomous coding tasks that iterate across files, run tests, debug errors, and refactor code) can consume 50,000-500,000 tokens in a single run. That's $5-$50 per session, depending on the model.

Talking to a CTO at a mid-sized SaaS company last week, he mentioned his team's AI usage spiked 40% after GitHub released better agentic features in April. Under the old model, that didn't matter—it was a fixed cost. Under the new model, that 40% increase translates to real dollars.

If you have 100 developers on Copilot Business and each one runs two heavy agentic sessions per week (debugging production issues, refactoring legacy modules, automating test coverage), you could burn through $10,000/month in AI Credits beyond your included allotment.

That's a $120,000 annual line item that didn't exist 60 days ago.

The Technical Perspective: What CTOs and VPs of Engineering Need to Track

From an engineering leadership standpoint, this pricing shift creates three immediate challenges:

1. Visibility Into Developer AI Usage

Most CTOs don't have real-time dashboards showing which developers are running expensive agentic sessions, which are using lightweight code completions, and which are somewhere in between.

GitHub is rolling out budget controls and usage dashboards for admins, but those tools won't prevent overruns—they'll just alert you after the damage is done.

Action item: Set up budget alerts at the enterprise, team, and user levels. GitHub now supports pooled credits (unused credits from light users can offset heavy users), but you need admin-level budget caps to prevent runaway spend.

2. Model Selection Matters More Than Ever

GitHub Copilot supports multiple models: Claude Opus 4.7, Claude Sonnet 3.5, GPT-4o, and others. Each has different token costs.

Under the old PRU model, choosing Opus vs. Sonnet affected how fast you hit your request limits. Under the new model, it directly affects your monthly bill.

Example:

• Sonnet 3.5: ~$3-$5 per million tokens
• Opus 4.7: ~$15-$20 per million tokens

If your team defaults to Opus for every task (because it's "the best model"), you'll burn through credits 4-5x faster than if you default to Sonnet and reserve Opus for complex architectural decisions.

Action item: Educate your team on model trade-offs. Autocomplete doesn't need Opus. Code review doesn't need Opus. Agentic refactoring of 10,000-line modules? Maybe Opus is worth it.

3. Fallback Models Are Gone

Under the old system, when developers hit their PRU limits, GitHub would fall back to a cheaper model (like GPT-3.5) so they could keep working.

That safety net is gone. When your credits run out, Copilot stops working (except for basic code completions). Developers either wait until the next billing cycle, or your organization approves overage spending.

Action item: Don't assume "it'll just keep working." You need budget policies in place BEFORE July 1 (when the promotional credits end).

The Business Perspective: What CFOs and Finance Leaders Need to Know

From a finance standpoint, this is a shift from predictable CapEx to variable OpEx—and it hits software budgets the same way cloud migration hit infrastructure budgets in 2015.

1. Budget Predictability Just Got Harder

You can still forecast a baseline: 100 developers × $19/month = $1,900/month for Copilot Business seats. That part is stable.

But the AI Credit consumption is highly variable. A quiet sprint with mostly bug fixes might cost $2,000 total. A sprint with major feature development, refactoring, and infrastructure changes might cost $12,000.

If you're managing software budgets quarterly, you need to model 3 scenarios:

• Low usage: Developers stick to autocomplete and basic chat (baseline cost only)
• Medium usage: Developers use agentic sessions 2-3x/week (1.5-2x baseline)
• High usage: Developers use agentic sessions daily + code review on every PR (3-4x baseline)

Action item: Ask your engineering leads for historical usage data from April-May 2026 (GitHub should have PRU consumption data). Model what that would cost under the new pricing.

2. ROI Just Became Measurable (And Mandatory)

Under the old model, Copilot was a flat cost. You could measure productivity gains ("developers write 30% more code"), but there was no direct cost-per-outcome metric.

Now there is. If a developer burns $200 in AI Credits to automate a refactoring task that would have taken 40 hours of manual work, that's an easy ROI calculation. If they burn $200 chatting with Copilot about syntax errors that could have been Googled, that's waste.

CFOs should expect engineering leaders to start tracking AI spend per project, per team, and per developer—just like they track cloud compute costs.

Action item: Add AI tool spend as a line item in project budgets. If a major feature is estimated at 500 developer hours, also estimate how much AI credit consumption it will generate.

3. GitHub Actions Costs Are Now Part of the Equation

This is easy to miss, but GitHub's new code review feature runs on GitHub Actions (their CI/CD infrastructure). That means code review now consumes BOTH AI Credits (for the model inference) AND Actions minutes (for the execution runtime).

If your team reviews 200 PRs/month with Copilot, you're now paying:

• ~$0.50-$2 per PR in AI Credits (depending on PR size)
• ~$0.10-$0.50 per PR in Actions minutes

That's potentially $600-$1,200/month JUST for AI-assisted code review.

Action item: Audit your GitHub Actions usage. If you're already close to your included Actions minutes, code review could push you into overage charges.

What Enterprises Should Do This Week

If you manage a team of 50+ developers on GitHub Copilot, here's your 5-step action plan for June:

1. Enable Admin Dashboards and Budget Alerts (Today)

Log into GitHub's billing dashboard and set budget caps at the enterprise level. Don't wait until mid-month to discover your team burned through $10,000 in AI Credits.

GitHub's pooled credits feature is useful (unused credits from junior developers can offset heavy usage by senior architects), but only if you have visibility and control.

2. Audit April-May Usage (This Week)

GitHub should have historical PRU consumption data. Pull that data and model what it would cost under the new token-based pricing.

If your April usage would have cost $8,000 under the new model but you only paid $1,900, you have a problem. The promotional credits ($70/user for Enterprise) will cushion the blow through August, but September is going to hurt.

3. Set Model Defaults (This Week)

Configure GitHub Copilot to default to Sonnet 3.5 (or GPT-4o) instead of Opus 4.7 for most tasks. Reserve Opus for:

• Architectural planning sessions
• Complex refactoring (10,000+ lines)
• Critical production debugging

Developers can still manually select Opus when needed, but the default should be the most cost-efficient model.

4. Educate Developers on Cost Awareness (This Month)

Most developers have no idea how much their AI sessions cost. A 30-minute agentic refactoring session could cost $10-$50 in credits.

You don't need to micromanage every interaction, but developers should know:

• Code completions are free (use liberally)
• Chat is metered (be intentional)
• Agentic sessions are expensive (use for high-value tasks)

Some teams are implementing "AI budgets" per developer (similar to cloud compute budgets per service). Light users with unused credits can transfer them to heavy users, keeping spend balanced.

5. Benchmark Against Alternatives (This Quarter)

GitHub Copilot isn't the only AI coding assistant. Cursor, Cody, Tabnine, and Amazon CodeWhisperer all have different pricing models.

If GitHub's usage-based pricing creates budget uncertainty, it might be worth evaluating competitors with flat-rate pricing. Some teams I've talked to are running pilot programs with 10-20 developers on alternative tools to compare productivity and cost before committing to a single vendor.

The Bottom Line: Budget for Variance, Not Just the Base Price

GitHub's move to usage-based billing is a bet that most developers will stay within their included credits—and that the heavy users who exceed them are willing to pay for the value.

That bet might be right. But CFOs and CTOs managing enterprise AI budgets need to plan for the scenario where it's wrong.

If your team adopted agentic coding workflows heavily in Q1 2026 (when usage was effectively unlimited), don't assume Q3 2026 will cost the same. The promotional credits end in August. The real test comes in September.

Track usage daily. Set budget caps. Educate developers. And be ready to have the "do we need a cheaper AI tool?" conversation if GitHub's metered pricing doesn't align with your team's usage patterns.

The base price didn't change. But the total cost just became a lot less predictable.