GitHub's Copilot Cost Dial Spans 14 Models Priced 25x Apart

GitHub put a cost control on Copilot's model router on September 14: three settings called Efficiency, Balance and Intelligence, rolling out in Visual Studio Code, Copilot CLI and the GitHub Copilot app. According to the changelog, Efficiency "prioritizes keeping costs low and suits fast, straightforward tasks", Balance "weighs cost, quality, and latency together, and is a good fit for everyday work", and Intelligence "prioritizes quality and is built for complex tasks".

The same post says the tiers change neither the menu nor the prices. "All three tiers use the same set of available models." "Usage is charged based on the model auto selects, regardless of tier."

Both statements are accurate, and neither one covers the part that reaches the invoice. A tier changes which model is likely to answer you, and the models in that pool are not priced alike: the cheapest costs a twenty-fifth of the dearest, on input and on output.

Making that comparison means pulling two GitHub documents together, which GitHub never does. The changelog runs to a few short paragraphs with no table in it, and the only figure in the body is a 10% discount on usage billed through auto, which GitHub says applies whichever tier you pick.

Fourteen models in the pool, and 25x between the ends

The changelog links the phrase "updated selection of models available" straight to the supported models reference, which names every model auto can pick. As of September 15 that table lists 14. Every one of them is also priced, per million tokens in USD, on the models and pricing page.

Prices are USD per million tokens, from GitHub's rate card on September 15, taking the default-context row for each model. Five of the 14 (Luna, Terra, GPT-5.4, Sol and GPT-5.5) also carry higher long-context rates, which widen the band rather than narrow it: GPT-5.5 on long context lists at $10.00 in and $45.00 out. The pool table itself carries no price column.

On default context the pool runs from $0.20 to $5.00 on input and from $1.20 to $30.00 on output, a factor of 25 at either end. GitHub's top price bracket sits outside the pool: GPT-6 Astra, Claude Fable 5, Claude Fable 5.1 and Claude Opus 4.8 in fast mode all list at $10.00 in and $50.00 out, and none of the four is in the auto table. The cheapest models GitHub sells, Luna and MAI-Code-1.1-Flash, are both inside it.

Call one day of reasonably heavy agent work a million input tokens and two hundred thousand output tokens. Priced across the same published pool:

That arithmetic is ours, run on GitHub's published figures. The 10% discount on usage billed through auto applies across all three tiers, so it moves every row down and leaves the ratio alone. GitHub's wording for who gets it is "paid subscribers" in the changelog and "users on paid plans" in the docs, and neither page breaks out whether Business and Enterprise seats qualify.

Copilot bills in tokens now, with premium requests surviving only for a legacy group. GitHub's request-based billing page states plainly that it "only applies to Copilot Pro and Copilot Pro+ subscribers on an existing annual plan who remained on legacy premium request-based billing after June 1, 2026." Everyone else pays in GitHub AI Credits at one credit to $0.01, metered per token. Under a flat per-request multiplier a tier change would move a bill in steps. Token metering moves it continuously, with the model's rate and with the length of whatever the model decides to write.

A Copilot Business seat costs $19 a month and includes 1,900 credits, which is $19 of model spend. That day of work above eats 2.3% of the seat allowance at Luna rates and 58% of it at GPT-5.5 rates.

The same Business seat allowance covers roughly 43 of those days on the cheapest model in the pool and roughly 1.7 on the dearest.

Nothing GitHub has published says where in that range a tier puts you.

The router scores the whole pool on every prompt

The common mental model for a router is a classifier: something that reads the prompt, decides hard or easy, and forwards the hard ones to the big model. Routers of this class do not generally work that way, and GitHub's own wording rules it out.

A router scores candidates. For each model in the pool and each incoming prompt it estimates expected quality, expected cost and expected latency, then picks whatever maximises a combined objective, roughly quality minus some weight on cost minus some weight on latency. Efficiency, Balance and Intelligence are the weights. Raise the penalty on cost and the router settles for cheaper models more often; lower it and prompts that previously did not justify an expensive model start to clear the bar. The pool never changes, which is exactly what GitHub says happens, and it is why the changelog can also say that even on Intelligence "simpler tasks may use smaller, more efficient models" without contradicting itself.

Setting Intelligence does not pick a model for you. It changes the exchange rate at which the system will trade your money for expected quality. The prompts that flip to something dearer when you move up from Efficiency are the ones already sitting near the decision boundary, and the boundary is not published.

The cost term in that objective is also a forecast of something that has not happened yet. Output dominates these rates, running five to eight times the input price on every model in the pool, and nobody knows how long the output will be until it is written. Two near-identical prompts can produce very different bills without the router having behaved inconsistently at all.

One line in the concept documentation constrains the rest of it: "Routing occurs along natural cache boundaries to avoid additional cache related costs." Switching models mid-conversation throws away the prefix cache held on the old one, and cached input is priced at exactly one tenth of fresh input for all 14 pool models. Re-ingesting a long agent context on a fresh model is a real charge, the same arithmetic that made Anthropic's 75% cache-read cut on Fable 5.1 worth the sums. The router therefore cannot rebid freely from turn to turn. Its choices are sticky inside a session, and an early misjudgement on a long session costs you for the length of that session rather than for one request.

GitHub describes two systems feeding the decision, one tracking "real-time system health and availability" and one that "evaluates task complexity." Neither is quantified. There are no weights or thresholds in the documentation, no account of which prompt features feed the estimate and no worked example. The concept doc also does not name a default tier, and as of September 15 it gives no instructions for changing the tier in any of the three clients. VS Code's 1.137 release notes do not mention the setting either. That reads like a feature mid-rollout rather than anything withheld, but it does mean a team cannot currently look up which tier it is on.

`auto` is not a model in the usage metrics, and there is no tier field

Copilot usage metrics have a `model` dimension. Its documented values include named models such as `gpt-5.4` and `claude-sonnet-4.6`, plus `unknown`, `others`, and `auto`. According to the usage metrics reference, `auto` represents "activity where auto model selection was used and the request was not attributed to a specific model."

So the value records a missing attribution. Every request the router handles lands in a bucket that tells an administrator nothing about what actually served it.

There is no tier field anywhere in the schema. Nothing records whether a request ran under Efficiency, Balance or Intelligence, so no team can reconstruct a tier comparison from telemetry after the fact. The only label available is the date.

The token numbers are thinner than they look. They exist under `totals_by_cli.token_usage` and `totals_by_copilot_app.token_usage`, and nowhere else. The tiers ship on three surfaces. Two of them report token counts, and the largest one, the VS Code editor window, does not. The model breakdowns that do exist, `totals_by_language_model[]` and `totals_by_model_feature[]`, are documented as covering chat activity "not completions."

Three days before the tiers landed, GitHub added VS Code Agents to usage metrics: `daily_active_vscode_agent_users`, `totals_by_vscode_agent` with session counts and user messages, and a per-user `used_vscode_agent` indicator. All of it counts engagement. None of it carries tokens, dollars, models or tiers.

The date boundary is the only join key you get

You can still measure this, but the experiment has to be designed before it starts, because nothing in the system will label it for you afterwards.

The denominator comes from usage metrics and the numerator has to come from billing. Usage metrics carry no cost field at all, so cost per unit of work is a join you perform yourself, and conflating the two will produce a number that means nothing. Plenty of published engineering has the same shape, including Shopify's account of leaving React Native, which measured output in detail and never costed it.

Hold one tier for a full sprint, then swap for a full sprint. The date is the only join key you have, and any mid-sprint adjustment destroys the experiment.

Then wait. GitHub's reconciliation guidance says IDE telemetry is processed asynchronously, that recent days "may appear incomplete or missing", and that data "typically finalizes within three full UTC days." Reading a window on the day it closes will show a decline that is not real.

Normalise before you compare. Cost per user message or per agent session, not total spend, because total spend tracks headcount and sprint intensity and public holidays. The session and message counts added on September 11 work as a denominator for the VS Code Agents window specifically. Reports go back to October 10 2025 with a year of retention, the dashboard shows a 28-day rolling window, and the API and NDJSON exports aggregate daily.

For ground truth on which model actually served a request, the only place to look is a single response: hover in Chat, or the model line in the CLI. It does not aggregate. It is also the one way to check by hand whether Intelligence is genuinely pulling different models for your workload, or whether your prompts were never near the boundary to begin with.

Set the budget first. Budgets can be scoped to an enterprise, organisation, repository, cost centre or individual user, and according to GitHub's budget documentation you have to select "Stop usage when budget limit is reached" for a budget to actually stop anything. User-level budgets "always enforce a hard stop." Otherwise the limit sends an email and "usage will not be stopped."

$19 seats, $0.01 credits and no regional pricing

Copilot's prices are in USD. Credits are defined as $0.01 USD. Seats are $19 and $39. Overage above the allowance is billed at USD per-token rates. None of the documentation cited here describes regional or purchasing-power pricing.

A team billing in dollars absorbs a variable dollar cost without much trouble. A team earning in naira, shillings, cedis or rand pays the same bill in dollars out of revenue that is not, and there the average is budgetable while the variance is not. Auto converts a fixed input, the model your developers chose, into a variable one, the model chosen for them, inside a 25x band whose distribution is undisclosed. The same mismatch shows up in far larger line items, including the dollar-denominated commission structure behind Uber's exit from Nigeria and Uganda, and it does not require any view on the exchange rate to matter. The only control in this system that behaves deterministically is the hard-stop budget.

Gemini 3.6 Flash is in the pool today and deprecated on October 2

MAI-Code-1-Flash was deprecated on September 10, with MAI-Code-1.1-Flash named as the alternative. That swap was clean: the replacement sits in today's auto pool, at the cheapest rate on the card.

The next batch is messier. GitHub announced on September 3 that it will deprecate four models across all Copilot experiences on October 2 2026: Gemini 3.5 Flash, Gemini 3.6 Flash, Kimi K2.7 Code and Claude Opus 4.7. Gemini 3.6 Flash is listed in the auto pool right now. Its named replacement, Gemini 3.8 Flash, is priced identically and is not currently in the auto table.

The concept doc covers this in one line: "Available models may change over time." Normal enough for a model catalogue. It also means the pool a team sets its tier against this week carries a documented expiry date 17 days out, and GitHub has published nothing about what fills the slot.

“The same Business seat allowance covers roughly 43 of those days on the cheapest model in the pool and roughly 1.7 on the dearest.”

Reporting by TechCurrent Staff · TechCurrent