Model prices are falling fast. Copilot bills are not.

Three price-reducing announcements landed in Copilot in about a week — one model at 73% lower list price, another at half price. Per-call rates are dropping. Spend per task is not.

Three announcements landed in GitHub Copilot in roughly a week, and all three reduce a price:

MAI-Code-1.1-Flash is rolling out, at what Microsoft describes as 73% lower list price than MAI-Code-1-Flash, "making it a cost-effective option."
Gemini 3.7 Flash reached general availability, a Flash-tier model positioned for agentic coding workflows.
GPT-5.6 Sol is at half price until September 3.

If per-token price were the thing that determined your bill, this would be the cheapest week Copilot has ever had. Many teams will find it isn't.

Price is one term in a product

Spend is not a rate. It's a rate multiplied by a quantity:

credits ≈ price per token × tokens consumed

Every announcement above moves the first term down. None of them move the second term down, and at least one of them moves it up — which is the actual point of the release rather than a side effect.

Read what the Gemini 3.7 Flash announcement claims to improve: "codebase research, and verification during complex coding tasks." Both of those are loops. Research means reading more of the repository before acting. Verification means checking the work and trying again when the check fails. A model that researches and verifies more thoroughly consumes more tokens per task by design, because that is what the improvement is.

So a cheaper, better Flash-tier model is simultaneously cheaper per call and more expensive per task. That isn't a contradiction to resolve. It's the trade the model is offering you, and usually a good one — you're buying more attempts per unit of human supervision.

Cheaper unit prices expand what gets attempted

The second-order effect is larger than the first.

At a high per-token price, a lot of agentic work simply isn't worth running. Nobody points a frontier model at a whole monorepo for a speculative refactor when the reasoning is expensive. Drop the rate by 73% and that calculation flips: work that was uneconomic becomes obviously worth trying, so it gets tried — repeatedly, by everyone, on bigger contexts.

This is the oldest pattern in infrastructure economics. Cheaper units get used more, and total spend rises even as unit cost collapses. It happened with storage, it happened with compute, and there is no reason AI inference would be the exception.

Which means the reasonable expectation for the next quarter is: per-call rates keep falling, and your Copilot bill keeps rising. Both of those can be true at once, and if you only track one of them you will misread the other.

Both bars can shrink and grow at the same time — they measure different things. Proportions are illustrative and depend entirely on your workload mix; the direction of the effect is the claim, not the magnitude.

The metric that survives all of this

Cost per token is a supplier metric. It tells you what you're charged, not what you got, and it will keep improving on its own whether or not you do anything. Reporting it upward is close to meaningless: it goes down while your invoice goes up, which is exactly the sort of number that destroys trust in a dashboard.

The ratio that holds still under a price cut, a model swap, and a routing policy change is cost per accepted change — credits consumed divided by work that actually landed in the default branch.

It survives because both terms move together. Swap to a cheaper model that needs three attempts instead of one and the numerator rises with the denominator flat, so the ratio correctly gets worse. Swap to a pricier model that lands it first time and the ratio correctly gets better. It cannot be gamed by a supplier announcement.

What GitHub gives you, and what it doesn't

Building that ratio is not a matter of turning on a report, and it's worth being precise about why.

The numerator has to be assembled. GitHub's AI credit ledger is one number per user per day — no breakdown by model, no breakdown by surface, lagging roughly two to three days. There is no per-repository or per-team attribution of Copilot spend at all, so anything below the org level is a model you build and should label as one.

The denominator has to come from your own repository data — merged pull requests, commits, whatever you count as landed work — because GitHub does not join spend to output for you.

And both halves have to be captured as they happen. GitHub retains most metric detail for roughly 100 days. A quarter-over-quarter comparison you did not snapshot at the time is not recoverable later, by any tool, including ours.

One correction worth making to the whole conversation

There's a detail that changes where model choice matters at all, and it gets omitted from nearly every "pick the cheaper model" post: code completions and Next Edit suggestions consume no AI credits.

So switching a developer who mostly accepts inline suggestions to a cheaper model saves exactly nothing — that surface was already free. Everything in this article applies only to the metered surfaces: agents, chat, and code review.

Which narrows the problem usefully. You are not optimising a fleet of developers. You are optimising the handful of workflows that invoke agents, and quite possibly the two or three people running the longest sessions. That's a much smaller thing to get right than "roll out a model policy," and it's where the entire delta lives.