← All posts

FinOpsAid blog

You can now set Copilot's default model centrally. Here's what it's worth.

Most developers never change the default. That's not a criticism — it's how defaults work, and it's why the default model in Copilot has always been the single setting with the most influence over credit consumption. Until September 2, an enterprise couldn't set it.

Now it can, and the timing is almost too neat: GitHub shipped the control in the same week it shipped both the most expensive model on the roster and one of the cheapest.

What changed on September 2

Enterprises can designate a preferred Copilot model as the default for new conversations through enterprise-managed settings (GitHub Changelog, September 2026). It's generally available for Copilot Business and Copilot Enterprise in the GitHub Copilot app, Copilot CLI, and Visual Studio Code.

The per-team part is the useful half. Set the model key as overridable and update team-mappings.json, and enterprise teams can pick their own default while everybody else inherits the enterprise one. So this isn't a single global switch — it's a policy with exceptions, which is the only shape that survives contact with an engineering org.

Note the scope carefully. It sets the default for new conversations. The changelog doesn't describe removing the model picker, so treat this as choosing the starting point rather than locking the roster.

The spread between this month's two new models is 13x

GitHub added three models in the first four days of September: Claude Fable 5.1 on the 1st, Gemini 3.8 Flash on the 3rd, and GPT-6 Astra on the 4th. They are not priced anywhere near each other.

Because Copilot moved to usage-based billing on June 1, 2026, this matters directly. One AI credit equals $0.01, tokens are priced per model, and a Copilot Business seat includes 1,900 credits per user per month at $19 — the allowance is the price. Enterprise includes 3,900 at $39 (GitHub Docs, Models and pricing, retrieved 2026-09-09).

Convert the published output rates into credits and the comparison stops being abstract.

AI credits consumed per one million output tokens, by Copilot model Six Copilot models drawn as horizontal bars scaled to the AI credits consumed per one million output tokens, derived from GitHub's published per-model dollar rates at one credit equals one cent. GPT-6 Astra is 5,000 credits, Claude Opus 5 is 2,500, Kimi K3 is 1,500, Claude Sonnet 5 is 1,000, Gemini 3.8 Flash is 375, and GPT-5.6 Luna is 120. The bar for Astra is roughly forty-two times the length of the bar for Luna, and roughly thirteen times the length of the bar for Gemini 3.8 Flash. A Copilot Business seat includes 1,900 credits a month, which buys about 380,000 output tokens on Astra or about 15.8 million on Luna. Credits are pooled at the billing entity level, so one team's expensive default is spent out of the shared allowance. AI CREDITS PER 1 MILLION OUTPUT TOKENS

GPT-6 Astra 5,000

Claude Opus 5 2,500

Kimi K3 1,500

Claude Sonnet 5 1,000

Gemini 3.8 Flash 375

GPT-5.6 Luna 120

A Business seat's 1,900 credits buy ~380,000 output tokens on Astra, or ~15.8 million on Luna. Credits are pooled at the billing entity level, so one team's default spends everyone's allowance.
Bars are our arithmetic on GitHub's published rates — dollars per million output tokens converted at 1 AI credit = $0.01. Rates from GitHub Docs, Models and pricing, retrieved 2026-09-09. Output rates only; input tokens are cheaper and priced separately, and real consumption mixes both.

Astra's output tokens cost 5,000 credits per million. Gemini 3.8 Flash costs 375. That's 13.3x on identical volume, from a setting neither model's release notes mention. Widen it to the whole roster and GPT-5.6 Luna sits at 120 credits per million — roughly 42x cheaper than Astra.

None of that argues for defaulting everyone to the cheapest model. It argues that the default deserves a decision, because the difference between a considered default and an inherited one is a multiple, not a percentage. Our earlier piece on which Copilot model to default to covers the task-to-model mapping; this release is the mechanism that finally lets you enforce one.

The October 2 deprecation nobody will read as a price change

On September 3, GitHub announced four models retiring on October 2, 2026 across all Copilot experiences (GitHub Changelog, September 2026). Business and Enterprise admins have to enable access to the replacements; after the sunset date the old models simply stop working.

Price the swaps and three of the four are non-events. One isn't.

Retiring October 2 In / out per 1M Replacement In / out per 1M Rate change
Gemini 3.5 Flash $1.50 / $9.00 Gemini 3.8 Flash $0.75 / $3.75 cheaper — half the input, 2.4x less output
Gemini 3.6 Flash $0.75 / $3.75 Gemini 3.8 Flash $0.75 / $3.75 identical
Claude Opus 4.7 $5.00 / $25.00 Claude Opus 5 $5.00 / $25.00 identical
Kimi K2.7 Code $0.95 / $4.00 Kimi K3 $3.00 / $15.00 3.2x input, 3.75x output

Our finding: the Kimi K2.7 Code retirement is a rate increase wearing a deprecation's clothing, and nothing in the announcement frames it that way. Anyone who chose K2.7 Code specifically because it was the cheap capable option for code work gets moved to a model that costs 3.75x more per output token, on a date they didn't pick, with no action required on their part for it to happen. The other three swaps are cost-neutral or better, which is exactly what makes this one easy to miss — a quick skim of the table reads as routine housekeeping. If K2.7 Code is anywhere in your team defaults or your automation, October 2 is a budget event, not a maintenance task.

The fix is cheap if you catch it. Gemini 3.8 Flash sits at $0.75 / $3.75 — below even the old K2.7 Code rate. The forced migration only costs you money if you accept the default replacement without pricing it.

Pooled credits turn a per-team default into an allocation decision

Here's the part that changes how you should think about team-mappings.json. Copilot Business and Enterprise credit allowances are pooled at the billing entity level. They are not per-seat wallets that a developer can exhaust in isolation.

So when you grant one team an expensive default, you are not giving that team a bigger budget. You are letting it draw faster from the same pool everybody else draws from. A twelve-person team on Astra can consume the credit allowance of a much larger group without a single line item saying so.

Which is why this release pairs naturally with GitHub's per-user budgets. A default model decides the rate of consumption; a user budget is the only thing that puts a wall in front of it — and user-level budgets are the one scope GitHub always hard-stops. We wrote up the expiry mechanics in GitHub budgets can now expire, and the pooling model itself in cost centers and AI credit pools.

One trap in the pricing table

GitHub's price list labels several models with "(default)" next to a rate — GPT-6 Astra (default), GPT-5.4 (default), Grok 4.6 (default). That does not mean the model is anyone's default model. It distinguishes the standard context tier from the same model's "(long context)" tier, which is priced substantially higher: Astra's long-context output runs $75 per million against $50 for standard.

Worth flagging because the two meanings of "default" collide in exactly the conversation this release starts. A long-context request on Astra costs 7,500 credits per million output tokens, which is about 253,000 output tokens for a whole Business seat's monthly allowance.

What to do this month

  1. Before October 2: grep your configuration for Kimi K2.7 Code. Team mappings, CLI config, any automation that names a model explicitly. If it's there, choose the replacement deliberately rather than letting the sunset choose for you.
  2. Set an enterprise default rather than leaving one. Whatever it currently is, it was picked by GitHub and not by you. That was unavoidable before September 2 and isn't now.
  3. Use overridable plus team-mappings.json for the exceptions, not for everyone. The agent-heavy team that genuinely needs frontier reasoning should have it. The default for everyone else shouldn't be sized for that team's workload.
  4. Enable access to the replacement models now. Business and Enterprise admins have to do this explicitly, and doing it on October 2 means doing it during an outage of your own making.
  5. Pair the default with a per-user budget. The default sets the burn rate; the budget is the only hard stop. One without the other is half a control.
  6. Remember what's free. Code completions and next edit suggestions aren't billed in AI credits and stay unlimited on paid plans. Model choice moves chat, agents and review — not the autocomplete most developers spend the most time inside.

Where FinOpsAid fits

FinOpsAid reads your org read-only and shows credit consumption per user, per team and per cost center against your allowance, next to the rest of the GitHub bill. One limitation is worth stating plainly rather than discovering later: the per-user AI credit figure GitHub exposes is a single daily number with no model or feature breakdown, so attributing credits to a specific model is an inference from your own configuration, not a reported fact. That's a real constraint on verifying a default-model change after you make it, and it's why the configuration itself is the record. Related: what actually consumes GitHub AI credits, reconciling AI credits to your bill, and how to read the Copilot page. Also worth knowing that GitHub's Copilot metrics lag roughly two to three days, so nothing here is real-time.

Frequently asked questions

Which Copilot model consumes the fewest AI credits?

On GitHub's published rates as of September 2026, GPT-5.6 Luna and MAI-Code-1.1-Flash are the cheapest at $0.20 input and $1.20 output per million tokens — 120 credits per million output tokens at 1 credit = $0.01. GPT-6 Astra is the most expensive standard-context option at 5,000 credits per million output tokens, roughly 42x more.

Does an enterprise default model stop developers choosing something else?

The changelog describes setting the default for new conversations, with team-level overrides through team-mappings.json when the model key is marked overridable. It does not describe removing the model picker. Treat the setting as the starting point rather than a restriction, and verify the behaviour in your own tenant before relying on it as a control.

What happens to my workflows on October 2, 2026?

Gemini 3.5 Flash, Gemini 3.6 Flash, Kimi K2.7 Code and Claude Opus 4.7 stop working across all Copilot experiences. GitHub says no action is required to remove them. Business and Enterprise admins must enable access to the replacements — Gemini 3.8 Flash, Kimi K3 and Claude Opus 5 — before the date.

Sources

If you want to see credit consumption per team against your allowance before you pick a default, connect your GitHub org — read-only and free during beta — or explore the demo dashboard first.

copilotai-creditsmodel-mixcost-optimizationgovernancefinops

See it in your own org

FinOpsAid meters the GitHub spend no invoice itemizes — read-only, and free during beta.