GitHub Cut Your Team's Copilot AI Budget Up to 44%. The Price Tag Didn't Move.

The day the meter started running

For most of Copilot's life, the pitch was simple: pay a flat monthly fee, use the model as much as you want. That ended on June 1, 2026. GitHub moved every plan, Free, Pro, Pro+, Max, Business, and Enterprise, onto “GitHub AI Credits”: a metered currency where 1 credit costs exactly $0.01, and every chat message, every agent run, every input, output, and cached token gets priced at the underlying model's real API rate and subtracted from a monthly pool. Unused credits don't roll over. They expire at the end of the billing cycle, every cycle, for every plan.

GitHub announced the change on April 27, 2026, gave a five-week preview window, and flipped the switch on June 1. For Business and Enterprise customers moving off the old model, GitHub added a temporary sweetener: promotional credit boosts for June, July, and August, on top of the new baseline. That promotional period, and its scheduled expiration on September 1, is most of this story.

What actually happened when the meter started running

The theory behind usage-based billing is that it makes cost proportional to value: light users pay less, heavy users pay for what they use. In practice, the first weeks of June produced a wave of very public, very specific complaints, not in a random forum, but in GitHub's own community discussions product. Discussion #198015, “GitHub Copilot AI Credits Are Unfair, Expensive, and Killing Real Development Workflows,” opened June 4 and pulled in 394 reactions and 96 comments within days, an unusually loud response for a vendor's own feedback channel.

The numbers inside that thread are specific, not anecdotal hand-waving. One developer reported their monthly bill going from $295 to over $1,000. Another described a routine website build that normally ran $150-200 in tokens instead costing $700 across 4 days, same scope of work, new meter underneath it. A Copilot Pro+ subscriber, whose plan carries a 7,000-credit monthly allowance, reported burning through the entire pool in 2 days of ordinary work. Others on the 20,000-credit Max plan described the same allowance gone in hours, not weeks. The thread's own title, “unfair, expensive, and killing real development workflows,” is a direct quote from the original poster, not editorializing.

The cushion nobody had to think about

What most of that June backlash didn't know, or didn't need to know at the time, is that GitHub had quietly built a temporary subsidy into the team plans. From June 1 through August 31, 2026, a Copilot Business seat cost $19 a month but carried $30 in AI Credits: 158% of the sticker price. An Enterprise seat cost $39 and carried $70: 179% of the sticker price. For three straight billing cycles, organizations paying per seat were getting 50-80% more usable AI work than their invoice implied, and because the extra credits just showed up in the pool, most finance teams had no reason to notice the gap between what they were billed and what they were actually granted.

That cushion was never presented as permanent. GitHub's own April announcement scoped it explicitly to the June-August transition window. It was, by design, a shock absorber for the move to metered billing, not a new baseline. But a temporary subsidy that quietly makes your bill look fine for three months is exactly the kind of thing that's easy to stop noticing, right up until the month it goes away.

September 1: the cliff

It went away on schedule. On September 1, 2026, Business accounts dropped from 3,000 credits per seat to 1,900: a 37% cut in usable AI work. Enterprise dropped from 7,000 credits per seat to 3,900: a 44% cut. In both cases, look at the number that actually appears on the invoice, the seat price, and it did not move. $19 is still $19. $39 is still $39. Nothing in either plan's marketing page, name, or sticker price changed on September 1. What changed sits one layer down, in a backend allowance table that determines how much of that unchanged price actually buys.

# What actually changed on September 1, 2026
plans = {
    "Business": {"seat_price": 19, "credits_before": 3000, "credits_after": 1900},
    "Enterprise": {"seat_price": 39, "credits_before": 7000, "credits_after": 3900},
}

for name, p in plans.items():
    cut_pct = (1 - p["credits_after"] / p["credits_before"]) * 100
    print(f"{name}: seat price ${p['seat_price']}/mo unchanged, "
          f"credits {p['credits_before']:,} -> {p['credits_after']:,} "
          f"({cut_pct:.0f}% cut)")

# Business: seat price $19/mo unchanged, credits 3,000 -> 1,900 (37% cut)
# Enterprise: seat price $39/mo unchanged, credits 7,000 -> 3,900 (44% cut)

The standing deal individual developers get

Set that against the plans billed to individuals rather than organizations, and the asymmetry gets sharper. Copilot Pro costs $10 a month and includes $15 in AI Credits: 150% of the price. Pro+ costs $39 and includes $70: 179%. Max costs $100 and includes $200: exactly double. None of those ratios were scoped to a promotional window. They are the plans' standing terms today, the same terms a solo developer paying out of their own pocket has had since the June 1 transition, with no equivalent September 1 cliff on the calendar.

Put the two charts side by side and the pattern is hard to miss: the plans billed per-seat, at organizational scale, are the ones whose bonus credits were explicitly temporary and just disappeared. The plans billed to an individual's own card kept a bonus that was never temporary in the first place. If you're the developer actually running the agent, that's a rounding error. If you're the finance team that approved a per-seat Enterprise contract months ago, expecting September's invoice to look like August's, it's a 44% cut that never appeared on any changelog you were likely to read.

Same seat, same credits, 5x spread

Credits are also not a flat currency once you start spending them. GitHub's own per-model pricing table prices output tokens on Claude Sonnet 5 at $10 per million. GPT-6 Astra, on the same table, prices output tokens at $50 per million: a 5x spread, on the identical $19 or $39 seat, purely based on which model your agent happens to call. Claude Opus 5 in its standard mode sits at $25/million output; the same model family in “fast mode” jumps to $50, matching GPT-6 Astra's ceiling. None of that is disclosed anywhere near the plan comparison page. It only shows up once you're already inside the pricing docs, reading a table most subscribers never open.

A team that standardizes its agents on Claude Sonnet 5 and a team that lets every developer pick whatever model feels fastest that day can burn an identical credit balance at a 5x different rate, on the exact same subscription tier, without anyone changing plans or seats.

Why the incentive points the wrong way

Put the pieces together and the org chart works against the fix. The accounts that absorbed the September 1 cut are billed centrally, per seat, to whoever manages the GitHub contract, usually a platform or finance function that sees one invoice a month and no line item for “credits remaining.” The people actually burning those credits, running agents against a real codebase all day, are the ones with the least visibility into a shrinking pool and the least reason to check a backend allowance number that never appears in the product's billing UI until it's empty. The same structural gap that let the June-August cushion go unnoticed while it was generous is the gap that lets the September cut go unnoticed while it's punitive.

What this means if you're paying per seat

None of this makes Copilot a bad product. Usage-based billing is, in principle, a more honest way to price AI work than flat access that assumes every user burns the same number of tokens. The problem isn't the model, it's the visibility: a promotional cushion that inflates real usable value by 50-80% for exactly one fiscal quarter, followed by a scheduled cliff that cuts 37-44% off the same number, with the sticker price held constant through both moves. Anyone budgeting off the seat price alone, which is the only number on the plan comparison page, would have been wrong about their real AI budget twice this year already: once when it was quietly better than advertised, and once when it quietly went back to worse.

The deeper lesson generalizes past Copilot. “Unlimited” and “included” used to be reasonable shorthand for AI coding tools. Under usage-based billing, they describe a metered product where the real price is whatever the per-token rate table says this month, for whichever model got called, adjusted by whatever promotional allowance happens to be active. The number that stays fixed on the invoice was never the number that determined the bill. The one that did move sat one click deeper, in a docs page most subscribers have never opened.

MegaBrain takes the opposite approach on purpose: one gateway across 500+ models, at the real per-token rate, zero markup, with no seat-based allowance table to expire on a schedule and no promotional credit cliff waiting three months out. The price you see is the price the model actually charges, visible per call, not reconciled after the fact against a pool that quietly shrank. Pair it with mhermes, MegaBrain's always-on agent runtime, and the agents burning tokens all day are working against a bill you can actually watch move in real time, not a credits table that resets its own rules every quarter.

Sign up at getmegabrain.com to route your agents across 500+ models with transparent, real-time, zero-markup pricing, instead of budgeting off a seat price that stopped describing your actual AI costs the day usage-based billing shipped.