If you opened your Copilot bill in June and felt your stomach drop, you're not imagining things. Developers across Reddit, X, and GitHub's own forums have been posting screenshots of monthly costs leaping from $29 to $750, or $50 to $3,000. The word "10x" is getting thrown around a lot, and in some agentic workflows, it's closer to 50x.

But here's the part that gets lost in the outrage: GitHub didn't raise its prices. Not the sticker price, anyway. What changed is how you get charged, and for heavy users, that distinction turns out to matter enormously.

Here's what actually happened on June 1, 2026, and how to think about it.

What GitHub actually changed

On June 1, 2026, GitHub moved every Copilot plan from flat-rate subscriptions to usage-based billing. The old system counted "premium requests" (PRUs). The new one runs on GitHub AI Credits, and credits get consumed based on token usage: input, output, and cached tokens, priced according to the published API rate for whichever model you're using. One AI Credit equals one cent.

The base subscription prices didn't move at all:

• Copilot Pro: $10/month, including $10 in monthly AI Credits
• Copilot Pro+: $39/month, including $39 in monthly AI Credits
• Copilot Business: $19/user/month, including $19 in monthly AI Credits
• Copilot Enterprise: $39/user/month, including $39 in monthly AI Credits

So if the price is the same, where's the 10x coming from? The answer is that your monthly fee no longer buys unlimited use. It buys a fixed allotment of credits. Once you burn through them, you either purchase more at published rates or you stop. Whatever you used to do "for free" under the flat rate is now metered against that allotment.

The detail most people miss

Code completions and Next Edit Suggestions are still included in every plan and do not consume AI Credits. If autocomplete is your main workflow, your bill is essentially unchanged.

The metering only bites on chat, agent mode, agentic coding sessions, and code review. That's where the eye-watering numbers come from, which brings us to the real cause.

Why agentic usage is the real culprit

GitHub's own explanation is worth taking at face value: Copilot is not the product it was a year ago. It went from an in-editor autocomplete assistant to an agentic platform that runs long, multi-step sessions, iterating across entire repositories using the newest (read: most expensive) models.

The problem with flat-rate pricing is that it charges a quick one-line chat question and a multi-hour autonomous coding session exactly the same amount. GitHub had been absorbing the gap. Usage-based billing closes it.

The catch is that agentic sessions are token-hungry in ways that aren't obvious. Every time an agent pulls a large chunk of your codebase into context "just in case," you pay for those input tokens whether or not they contributed anything. A session that drags 100,000 tokens of context into the window when 20,000 would do is quietly inflating your bill by 80% on the input side alone. Multiply that across a team running agents all day, and the math gets ugly fast.

This is the uncomfortable truth underneath the backlash. The 10x isn't a rate hike. It's the first time many teams are seeing the actual compute cost of workflows they built during the era when that cost was hidden.

A few more changes are worth knowing

The billing model wasn't the only thing that shifted on June 1.

Fallback models are gone.

Previously, when you exhausted your premium requests, Copilot would quietly drop you to a lower-cost model so you could keep working. That safety net is gone. Now your usage is governed strictly by available credits and admin budget controls. When the credits run out, you're done until you buy more.

Code review now also eats Actions minutes.

Copilot code review moved to an agentic architecture that runs on GitHub Actions. Reviewing a pull request now counts against your included Actions minutes, billed at the same per-minute rates as any other Actions workflow, on top of the AI Credits it consumes.

Annual plans are being retired.

If you're on an annual Pro or Pro+ plan, you'll keep your PRU-based pricing until it expires (though model multipliers increased on June 1 for annual subscribers). After expiry, you move to Copilot Free unless you switch to a monthly paid plan. Convert early, and GitHub will prorate credits for the time remaining.

Businesses get a temporary cushion.

To soften the landing, existing Business and Enterprise customers automatically receive promotional included usage for June, July, and August: $30/month in credits for Business, $70/month for Enterprise. There's also pooled usage, so one team member's unused credits aren't stranded, and admins now get budget controls at the enterprise, cost-center, and user level.

What this means if you run agentic workflows

For teams whose Copilot use is mostly autocomplete and the occasional chat, this is close to a non-event. For teams that have leaned into agent mode across large codebases, it's a budgeting problem that needs attention before the next billing cycle closes.

A few things that move the needle:

• Scope your context. Point agents at specific files or modules instead of letting them index the whole repository. Trimming context from 100k to 20k tokens cuts your input cost by roughly 80%.
• Batch your chat sessions. Every session carries fixed overhead from system prompts and context setup. Five focused questions in one session cost less than five separate sessions.
• Watch the dashboard. GitHub's billing view shows per-model token consumption. Export it before your first full bill lands so you understand which workflows are actually expensive.

The broader lesson is that "unlimited" was always a temporary subsidy, and the agentic era made it untenable. The teams that adapt fastest will be the ones who treat AI compute as a measurable, optimizable cost rather than a flat line item, the same way they already treat cloud spend.

That shift in mindset, from "set it and forget it" to deliberate orchestration of where and how agents run, is exactly where tooling like WorkflowFiesta earns its keep. When you can see which agents are consuming what, route work to the right model for the job, and keep multi-agent pipelines from burning tokens on redundant context, usage-based pricing stops being a nasty surprise and becomes something you actually control.