If you pay for GitHub Copilot and keep hopping between Claude, GPT and Gemini models in the picker, this comparison is for you. GitHub, owned by Microsoft ($MSFT), made Copilot Fusion generally available on October 28, 2026, and it now chooses and combines models for you at three effort levels. Working only from GitHub’s published per-token rates, one mid-size agent task in our cost model ranges from 2.1 AI credits on the cheapest lightweight model to 212 on GPT-6 Astra, roughly a 100x spread. The short version: Fusion Standard is the sensible default for most people, while picking a model yourself still wins when you know exactly which one a job needs and want a predictable bill.

Copilot Fusion vs Manual Model Picking: Side-by-Side
Here is how the two approaches differ on the points that affect your bill and workflow, based on GitHub’s documentation and changelog.
| What matters | Copilot Fusion | Picking a model yourself |
|---|---|---|
| Who chooses the model | Fusion routes each prompt and may chain several models | You do, and it stays fixed until you switch |
| Effort settings | Standard, High, Max (Fast is internal to VS Code inline chat) | Per-model reasoning level where the model supports it |
| How it’s billed | Each model it calls, at that model’s standard rate; no Fusion surcharge | The one model you picked, at its standard rate |
| Current promo | 30% off model costs on paid plans through Nov 30, 2026 | None |
| Cache behavior | Tries to keep the main thread on one model so cached tokens keep working | Cache resets whenever you switch models mid-session |
| Local models | Standard tier can route to MAI-Code-1.1-Flash or Qwen3.8 Flash Next (experimental) | You can select a local model directly |
| Cost predictability | Lower on High/Max, since extra review calls are added when Fusion thinks they help | High: one rate card, one model |
| Where it works | VS Code, Copilot CLI, GitHub Copilot app, JetBrains IDEs | Every Copilot surface with a model picker |
Methodology: How We Compared Them
We did not run hands-on benchmarks for this piece, so you won’t find any speed or accuracy scores we measured ourselves. This is a spec, pricing and documentation comparison. We read the About GitHub Copilot Fusion page, the Models and pricing for GitHub Copilot rate tables, the individual billing and organization billing pages, and the launch changelog, all checked on November 3, 2026.
To turn per-million-token prices into something you can picture, we defined one illustrative agent task: a bug fix spread over about ten turns in a mid-size repository. We assumed 80K fresh input tokens, 320K cached input tokens (context the model reuses from earlier turns) and 20K output tokens. Each model’s cost is simple arithmetic on GitHub’s list rates, converted at 1 AI credit = $0.01. We left out cache-write fees, which some OpenAI and Anthropic models charge on top, so real numbers on those models will run slightly higher.
One limit matters a lot: GitHub does not publish which models Fusion will pick for a given prompt. The Fusion figures further down are therefore hypothetical routes we built from the documented patterns, not readings from a real session. Your own usage dashboard is the only place to see true numbers.
What One Agent Task Costs on Each Model
Applying the same token profile to eleven models in the Copilot pool gives the spread below. Prices are GitHub’s default tier (shorter contexts); several models charge more past 200K or 272K input tokens per request.
| Model | Input / 1M | Cached input / 1M | Output / 1M | Credits for our task |
|---|---|---|---|---|
| GPT-6 Luna | $0.10 | $0.01 | $0.50 | 2.1 |
| Claude Haiku 5.5 | $0.10 | $0.01 | $0.50 | 2.1 |
| MAI-Code-1.1-Flash | $0.20 | $0.02 | $1.20 | 4.6 |
| Gemini 3.8 Flash | $0.75 | $0.075 | $3.75 | 15.9 |
| GPT-6.1 Terra | $1.00 | $0.05 | $5.00 | 19.6 |
| Claude Sonnet 5.5 | $2.00 | $0.10 | $10.00 | 39.2 |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 | 39.2 |
| Gemini 4 Argon | $2.00 | $0.10 | $10.00 | 39.2 |
| Claude Opus 5.5 | $4.00 | $0.20 | $20.00 | 78.4 |
| Claude Fable 5.1 | $10.00 | $0.25 | $50.00 | 188.0 |
| GPT-6 Astra | $10.00 | $1.00 | $50.00 | 212.0 |

The lightweight group (GPT-6 Luna, Claude Haiku 5.5, MAI-Code-1.1-Flash) stays under 5 credits, so even a heavy month barely dents an allowance. The versatile and powerful middle, where Claude Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon from Google ($GOOGL) all share a $2 input and $10 output rate, lands at 39.2 credits. GPT-6.1 Terra sits at half that, 19.6. At the top, Claude Opus 5.5 doubles the middle tier, and Fable 5.1 or GPT-6 Astra run about five times the middle tier.
Output tokens drive more of the bill than most people expect. On Sonnet 5.5, our 20K output tokens cost 20 credits, more than the 80K fresh input tokens (16 credits). Agents that write long explanations or rewrite whole files burn credits fast. Anthropic’s pricing choices here tie into the wider economics of frontier labs we looked at in our breakdown of the Anthropic S-1 filing.
The hidden cost of switching models mid-session
GitHub’s cost optimization guide warns that a different model can’t reuse another model’s cache, and it notes cached tokens are typically billed at about 10% of the normal input price. Say your context has grown to 40K tokens and you jump to Sonnet 5.5 halfway through. That next turn re-sends the full 40K as fresh input: 8 credits instead of the 0.4 credits it would cost as a cache hit. Repeat that often and switching can cost more than the model choice itself. Fusion is designed to route along cache boundaries, which is one of the quieter reasons it can come out cheaper.
How Fusion’s Three Patterns Change the Bill
Fusion doesn’t just pick one model. Per prompt, it uses one of three execution patterns, and only the first behaves like a normal single-model request.
- Single: one model handles the prompt. Fusion Standard picks one model per task, so this is what you’ll see most at that level.
- Cascade: an efficient model writes a draft, a judge reviews it, and the work is either accepted or escalated to a stronger model.
- Critique: one model drafts while several others critique it in parallel; their notes are merged and the original model revises.

Because cascade and critique add calls, the docs say a task on Fusion High or Max may use more AI credits than it would on Standard. To show what that can look like, we priced four hypothetical routes using the same task profile, with the 30% launch discount applied. The judge reads 20K tokens and writes 1K on Sonnet 5.5; each critic reads 30K and writes 2K on GPT-6.1 Terra; the revision turn is small.
| Hypothetical route | Credits (after 30% off) | vs manual Sonnet 5.5 (39.2) |
|---|---|---|
| Single on GPT-6.1 Terra | 13.7 | -65% |
| Cascade, draft accepted | 17.2 | -56% |
| Critique with two critics | 36.8 | -6% |
| Cascade, escalated to Sonnet 5.5 | 44.7 | +14% |

When Fusion settles a prompt with a mid-priced model, it beats a fixed Sonnet 5.5 pick by a wide margin. When it escalates, you pay for the discarded draft plus the stronger model, which edges past a straight Sonnet run even with the discount. After November 30 the discount ends, and an escalated cascade in our model would cost 63.8 credits. GitHub’s own claim is more upbeat: it says Fusion Max scored 60 on the Artificial Analysis Coding Agent Index, within two points of Claude Code with Opus 5.5 Max, at about half the average API cost per task (changelog). That’s GitHub’s figure, not ours, but it matches our math: the savings come from keeping routine work off frontier models.
How to Turn On Copilot Fusion
Update your client first, since older builds won’t list Fusion.
- VS Code or JetBrains: open the Copilot Chat model picker, choose Copilot Fusion, then pick Standard, High or Max.
- GitHub Copilot app: click the model name under the prompt box, switch the Copilot Fusion toggle on and choose an effort level (app docs).
- Copilot CLI: type
/modelin a session and select Copilot Fusion, or pass it as a flag for one-off prompts (CLI docs). Use/config modelto make it your default.
For scripted runs, the documented flags look like this (the prompt text is our own example):
copilot --model fusion --fusion-tier standard -p "Add input validation to src/signup.ts and update its tests"
To sanity-check a bill before committing to a model, this short snippet of ours does the math; plug in GitHub’s rates and token counts from your usage dashboard.
def copilot_credits(fresh, cached, output, rate_in, rate_cached, rate_out, discount=0.0):
"""Estimate GitHub AI credits (1 credit = $0.01). Rates are USD per 1M tokens."""
usd = (fresh * rate_in + cached * rate_cached + output * rate_out) / 1_000_000
return round(usd * 100 * (1 - discount), 1)
# Claude Sonnet 5.5 at list rates: 39.2 credits for our sample task
print(copilot_credits(80_000, 320_000, 20_000, 2.00, 0.10, 10.00))
Local routing is a separate, experimental option. According to the local models changelog, on supported Windows machines you can install MAI-Code-1.1-Flash, and Fusion Standard may then send suitable work to it without using AI credits.
How Far Each Plan’s AI Credits Go
Since June 1, 2026, Copilot bills by usage. Each plan includes a monthly AI credit allowance that resets at 00:00 UTC on the first of the month, and unused credits don’t roll over. Code completions and next edit suggestions are not billed in credits and stay unlimited on paid plans.
| Plan | Price | Monthly AI credits | Tasks on Terra | Tasks on Sonnet 5.5 | Tasks on Opus 5.5 |
|---|---|---|---|---|---|
| Copilot Pro | $10/mo | 1,500 | 76 | 38 | 19 |
| Copilot Business | per user | 1,900 | 96 | 48 | 24 |
| Copilot Enterprise | per user | 3,900 | 198 | 99 | 49 |
| Copilot Pro+ | $39/mo | 7,000 | 357 | 178 | 89 |
| Copilot Max | $100/mo | 20,000 | 1020 | 510 | 255 |

Pro users feel model choice the most. Running every agent task on Opus 5.5 empties a Pro allowance in about 19 tasks, while routine work on Terra stretches it to 76. Copilot Free and Student plans only reach models through automatic selection, so the manual-versus-Fusion question mostly applies to paid tiers. If you hit the ceiling often, GitHub suggests that a bigger plan can work out cheaper than buying extra usage, and a $0 budget with a hard stop prevents surprise charges. Budget-conscious users can also look at the best free AI coding agents in 2026 if you want a free option.
Who Should Pick Which?
- Copilot Pro on a tight budget: use Fusion Standard as your default. It keeps the main thread on one model and can route to cheaper ones without you thinking about it.
- You already know the right model: pick it manually and stay on it for the whole session. A fixed Sonnet 5.5 or Terra run gives you a predictable, easy-to-audit bill.
- Hard bugs or multi-file refactors: try Fusion High for those sessions only. The review calls cost extra, but they’re cheaper than defaulting to a frontier model all day.
- Architecture or deep debugging: Fusion Max or a manual Opus 5.5 pick. Plan with the strong model, then start a fresh session on a cheaper one to implement.
- Team admins: set Fusion as the managed default and limit its model pool through policy. Fusion only uses models your org has enabled.
- Windows developers with plenty of RAM: experiment with local routing on Fusion Standard. Check the hardware requirements first.
Spending on AI tools rides on a much bigger buildout of chips and data centers, which we’ve tracked in our pieces on AI infrastructure debt and AI debt concerns in semiconductors. Falling list prices, such as Opus 5.5 pricing below Opus 5, help make routers like Fusion worthwhile.
FAQ
Does Copilot Fusion cost extra?
No. GitHub says there is no separate charge for Fusion. You pay for each model it calls at that model’s standard rate, and through November 30, 2026, paid plans get 30% off those model costs.
Is Fusion always cheaper than picking a model?
Not always. Fusion Standard usually is for routine work, but Fusion High and Max can add judge or critic calls, so an escalated task can cost more than one run on a single mid-tier model.
Can I see which models Fusion used?
Yes. After a response, hover over the effort level name under it to see the list of models used. You can also follow each step’s model while it works.
Do code completions use AI credits?
No. Code completions and next edit suggestions are not billed in AI credits and remain unlimited on paid Copilot plans.
Which effort level should I start with?
Start with Fusion Standard for everyday prompts. Move to High for well-scoped but difficult tasks, and save Max for the hardest reasoning work.
Official Sources
- GitHub Changelog: Route and orchestrate models with GitHub Copilot Fusion (Oct 28, 2026)
- GitHub Docs: About GitHub Copilot Fusion
- GitHub Docs: Models and pricing for GitHub Copilot
- GitHub Docs: Usage-based billing for individuals
- GitHub Docs: Usage-based billing for organizations and enterprises
- GitHub Docs: Optimizing your AI usage to maximize efficiency and reduce cost
- GitHub Docs: Choosing a model in GitHub Copilot CLI
- GitHub Docs: Choosing a model in the Copilot app
- GitHub Changelog: Copilot Fusion now supports selection of local models (Oct 28, 2026)
Related Posts
- Anthropic S-1: $16.3B Revenue and an $80.7B Loss — What the Filing Actually Says
- The AI Buildout Hits Its Funding Wall
- AI Debt Concerns Just Stress-Tested the Compute Trade
About the author: JSCC writes about AI tools, developer software and the costs behind them, with a focus on turning pricing pages and docs into numbers readers can act on.
This article was drafted with AI assistance and fact-checked against official documentation by the author. Prices and features were checked on November 3, 2026 and may change.
© 2026 JSCC AI Notes
