A couple of months ago, I wrote a post breaking down GitHub Copilot's billing model: plans, premium requests, model multipliers, the whole thing. Clear tables, real cost math, actionable advice.

On June 1st, GitHub replaced the entire billing system.

Premium requests? Gone. Model multipliers? Gone. The safety net that dropped you to cheaper models when you ran out? Also gone.

So here we are again. I made a video walking through all of this — starting with the big picture and working into the details — and this post covers the same ground for those who prefer to read.

You Get What You Pay For

The super-short version of what changed: now you're only going to get what you actually pay for.

If you're thinking "wait, I was already paying" — you were. But you weren't paying full freight. What you were paying to GitHub wasn't actually covering their costs. And this isn't just a GitHub thing — it's pretty much all the big AI vendors. (I wrote about this in detail if you want the full picture.)

Here's a term you're going to want to pay attention to: inference cost — the cost of running an AI model to generate a response. Every time an AI model generates a response, that's compute power, that's GPU time, that's money. During the free-AI gold rush, the vendors were eating that cost. Now they're passing it through.

Different models cost wildly different amounts. A lightweight model like GPT-5 mini is cheap. Claude Opus is dramatically more expensive. And under the new billing model, you feel that difference directly because you're paying per token, not per request. The gap between a cheap model and an expensive one can be 40x or more per token.

That makes model choice a budget decision, not just a preference.

You Haven't Been Paying What AI Actually Costs

For the last couple of years, AI has felt basically free. You sign up, you get access to incredible models, nobody asks hard questions about the bill. That price you've been paying? It's heavily subsidized. The AI companies are burning through investor capital to build a product they'll eventually, actually, properly charge you for.

Now You're Going to Pay Per Token

So what's a token? A token is roughly a word — sometimes a little less, sometimes a little more. Every time you ask AI to do something, you're spending tokens on the question and on the answer. The more complex the task, the more tokens, the higher the bill.

Your $19/user Copilot subscription was masking that detail. You used powerful models, burned through tokens, and it felt free. You didn't think about efficiency because you didn't have to.

That couldn't last and it didn't. On June 1st, GitHub switched Copilot to token-based billing. You pay for what you consume. More powerful models cost more per token. And the economics of every AI interaction are now visible on your invoice.

The Chain Reaction

When something that felt free starts costing money, there's a chain reaction that most organizations don't see coming:

AI Feels Free → You're on flat subscriptions, unlimited usage, nobody thinking about cost per interaction.

Token Billing Arrives → Suddenly every interaction has a price tag, and more powerful models cost dramatically more per token.

Teams Optimize → Organizations do the rational thing: route tasks to cheaper models, set budgets, optimize spend. Makes total sense.

The 80% Looks Done → The cheaper models produce output that looks good, compiles, runs, passes the eye test. Feels like the job is done.

Who Runs the Last Mile? → But the last 20% — the edge cases, the judgment calls, the subtle stuff — that's still there. And if nobody on the team can tell they're at 80% instead of 100%, that's where things go quietly wrong.

Each step is rational on its own. The problem is what happens at the end when nobody's watching for it.

Vibe-Confidence

You've probably heard of "vibe coding" — you describe what you want to AI, it goes off and generates it, and just like that, it looks amazing. The danger isn't vibe coding itself. It's what I call vibe-confidence: that quite-possibly-false sense of confidence about what was just built. It looks good, therefore it must actually be good. But if you didn't really examine what your AI coding assistant generated for you, you don't have any reason to have confidence in the results.

This pricing change introduces a new wrinkle to the vibe-confidence problem.

When you've been using frontier models, you get used to a certain level of quality and confidence — earned or otherwise. As you switch to cheaper models, you might not be getting the same quality of answer, but it's not obvious exactly when that's happening. The AI result quality might have dropped, but your confidence in the answer might not have dropped with it.

AI gives you the outputs of competence without requiring the inputs of competence, and that gap between what you produced and what you actually understand is where things can go quietly wrong. It's not that cheaper models are bad — it's that you need to pay attention and be skeptical, and that's a people skill, not a model setting.

Which Model for Which Work?

A cheap model handles the first 80% fine — honestly, that's where most of the token volume lives anyway. But somebody still has to run the last mile, and they need to know they're at 80%, not 100%. The real question isn't just which model for which work, it's whether your people can tell where the 80% ends and the last 20% begins. That's the skill that makes model routing actually work.

So this isn't just a billing conversation. Model routing is a quality conversation, and the financial pressure to optimize is about to put that quality question front and center.

OK, with that context — let's get into the specifics.

What Changed on June 1st

Under the old system, every interaction with a premium model consumed one "premium request" from your monthly bucket, scaled by a model multiplier. Sonnet was 1x, Opus was 3x, Opus fast mode was 30x. Coarse, but easy to reason about. And when you ran out, Copilot silently dropped you to cheaper base models.

Under the new system, Copilot bills against actual token consumption — input tokens, output tokens, and cached tokens — priced at each model's published API rate. The billing unit is the GitHub AI Credit, where 1 credit equals $0.01 USD. Each plan includes a monthly credit allowance, and everything beyond that is additional usage you either pay for or don't, depending on your policy settings.

The big change: no more silent fallback to a cheaper model. When your credits are gone, you either set a spending budget to keep going, or you're done until next month.

The practical impact: a quick chat question and an hour-long agentic coding session no longer cost the same. Under premium requests, both were roughly one request. Under AI Credits, the agentic session might burn 50x or 100x more credits because it's consuming vastly more tokens.

The Plan Landscape (July 2026)

Here's the current plan landscape as of July 2026:

Individual plans:

Business plans:

There's also a Student plan (free for verified students with an AI credit allowance), available via the GitHub Student Developer Pack.

The new Copilot Max tier at $100/month is designed for sustained, high-volume agentic workflows — $200 in monthly credits with priority access to new models and features. Most individual developers won't need it.

A few things to notice. Individual plans get more credit value than their sticker price: Pro pays $10 but gets $15 in credits, Pro+ pays $39 and gets $70. GitHub positions this as included usage plus a "flex" allotment. For Business and Enterprise, GitHub doesn't publish specific credit dollar amounts on the plans page — it directs organizations to sales. What is published: Enterprise gets 2x the included usage of Business, and both pool credits across the organization.

One important model access change: Opus-class models are no longer available on the Pro tier. You need Pro+ ($39/month) or above. If you've got developers on Pro who were relying on Opus, they've already noticed.

Also worth noting: Business is now "Contact Sales" rather than self-serve sign-up. And for a limited time through August 2026, existing Business and Enterprise customers receive promotional credits at roughly double the standard allotment. Plan for the step-down to standard rates in September.

Individual plans split their credits into "base" and "flex" allotments. Base credits match the subscription price and never change. Flex allotments are variable additional usage on top that GitHub may adjust over time. Unused credits don't roll over.

"But I Already Pay for Claude Code"

This question hasn't changed since my last post, and it's still what every developer on your team is asking. Why do they need a Copilot seat when they already have Claude Code or ChatGPT on their personal card?

Fair question. But that's their account, their data governance decisions, and zero visibility for you as a manager.

The value of Copilot Business and Enterprise isn't that the AI is better. It's that you get a managed platform: centralized billing with pooled credits, usage dashboards and audit logs, budget controls at the enterprise, cost center, and individual user level, and model access and content exclusion policies. That's governance.

Credits Are Pooled Now

One meaningful improvement: on Business and Enterprise plans, credits are now pooled across the organization. Under the old system, each user had their own isolated bucket of premium requests. If one developer used 50 of their 300 and another needed 400, tough luck — the unused capacity was stranded.

Under pooled credits, an organization's total credit allowance is shared. Light users subsidize heavy users naturally. For a team where usage varies — and it always varies — this is a significant improvement in credit efficiency.

How AI Credits Actually Work

Code completions and Next Edit Suggestions remain free on all paid plans. They don't consume AI Credits. If that's the primary way your team uses Copilot — and for many teams, it is — the billing change is essentially a non-event.

What does consume credits: chat, agent mode, the coding agent, code review, Copilot CLI, and Spark. Basically anything that calls a frontier model for multi-turn conversations or agentic workflows.

Under the old multiplier system, I could tell you exactly what each model cost: Sonnet was 1x, Opus was 3x, fast mode was 30x. Clean tiers. Under token billing, the math is more granular. Cost depends on the model's per-token rate and how many tokens your interaction consumes. But the relative spread is still enormous — cheap models can be 40x less expensive per output token than frontier models.

One analysis estimated that a heavy frontier agent session could consume over 100 credits (more than a dollar) in a single iteration. This isn't hypothetical — developers reported in the GitHub Community discussion watching 82% of their monthly allowance evaporate on day one under the new billing model.

Code Review Now Dual-Bills

Here's a detail that surprised me. Starting June 1st, Copilot code review runs on GitHub Actions infrastructure. So each review consumes both AI Credits (for token processing) and GitHub Actions minutes (for the compute). Two billing meters running simultaneously for the same feature.

If you've got automated Copilot code review running on every pull request across your organization, that's worth tracking — especially if you're already close to your Actions minutes ceiling.

Policy Settings You Need Before Rollout

Three decisions you need to make before deploying Copilot under the new billing model:

AI Credits paid usage toggle. Controls whether developers can exceed their included allowance. If it's off, they hit their limit and stop. If it's on, the org pays for additional usage. Decide before someone discovers Opus in agent mode.

Budget caps at multiple levels. You can now set budgets at the enterprise, cost center, and individual user level. This is a major governance improvement. Without these, there's no ceiling on what a heavy agentic user could spend in a given month.

Model access controls. Control which AI models your developers can use. If you don't want anyone running frontier models with extended context in agent mode, disable them at the org level. This remains the most underused policy setting in Copilot.

These three settings are the difference between a managed AI platform and an open credit card on the table.

Real Cost: Business vs. Enterprise

Base seat prices haven't changed. What's different is the overage math. Under premium requests, overages were $0.04 per request — discrete and predictable. Under AI Credits, overages are per-credit (per-penny) and scale with token consumption, which makes them harder to forecast.

The pooling improvement helps Business plans stay competitive. If 30 of your 50 developers are light users, their unused credits flow to the 20 heavy users. But if a significant portion of your team is running agentic workflows, Enterprise's larger credit pool and better governance tools start looking like the cheaper option when you factor in the admin overhead of managing unpredictable overages.

One more thing: Enterprise requires GitHub Enterprise Cloud at $21/user, so the true Enterprise cost is $60/user/month, not $39. That's always been true, but it changes the math at scale.

The Question Behind the Question

If your team is burning through credits, the question isn't "do we need a bigger plan?" And it's not just about model routing, even though that matters.

The deeper question is: can your people tell where the 80% ends and the last 20% begins?

Under token billing, the financial pressure to use cheaper models is going to be real, and that's not inherently wrong — cheaper models handle the first 80% fine. But somebody still has to run the last mile. Your people need to be paying attention, being skeptical, catching the moments where the answer looks done but isn't quite. That's a people investment, not a model setting, and the teams that make it will get more value from every dollar of AI spend than the teams that don't.

What to Do This Week

1. Audit your policy settings immediately. Is AI Credits paid usage enabled? Do you have budget caps at the enterprise, cost center, and user level? If not, set them now.

2. Educate your team on token economics. Most developers have no idea that model choice is now a direct cost lever. A five-minute conversation about when Opus is warranted versus when Sonnet does the job saves real money.

3. Default to auto model selection. Let Copilot pick the model. You get the 10% discount, and for most tasks, it picks well.

4. Watch your first full billing cycle closely. GitHub's promotional credits for existing Business and Enterprise customers run through August 2026. When those promos end in September, that's when the real bill arrives.

5. Invest in your team's ability to evaluate AI output. Model routing matters, budget caps matter, but the long-term competitive advantage is having humans in the loop who can tell good from plausible, no matter which model produced it.

I've written more about vibe-confidence, AI's last-mile problem, and the economics of AI inference if you want to go deeper on the ideas behind the billing.

The billing model changed. The question that matters didn't.

-Ben