How to Use GitHub Copilot Fusion: The Beginner's Guide to the Router, Effort Levels, and Workflows
CodexFuse Team · 2026-11-02T15:05:07.495Z · 17 min read min read
GitHub Copilot Fusion is the model router GitHub launched at Universe 2026: pick an effort level and it routes your prompts across models. This beginner's guide covers the effort levels, the Single/Cascade/Critique workflows, pricing, and setup.
GitHub Copilot Fusion is the model router GitHub made generally available on October 28, 2026, at GitHub Universe — and if you want to know how to use GitHub Copilot Fusion, the short version is this: stop picking models. You open the model picker, choose Copilot Fusion, and choose an effort level — Standard, High, or Max. From there, Copilot evaluates every task across reasoning, code generation, debugging, and tool use, then routes and orchestrates one or more models to do the work, and you touch nothing else. It is not a new model; it is the system in the picker that decides which models serve each prompt. This beginner's guide covers the mental model that makes Fusion click, the effort levels, the three workflows (Single, Cascade, Critique), the pricing, and the turn-on steps for every client. If Copilot itself is new to you, start with our GitHub Copilot beginner guide — Fusion is the model-routing layer that sits on top of it.
What Is GitHub Copilot Fusion, Exactly?
GitHub Copilot Fusion is an intelligent runtime model router and orchestrator inside Copilot: you choose an effort level in the model picker, and Fusion evaluates each task and picks the models and execution patterns that serve it, returning a single response. If your search was literally "what is Copilot Fusion," that sentence is the whole answer — everything below is the beginner's tour of what it implies.
That one sentence carries the whole design. Fusion merges two earlier GitHub systems — Project HydraFusion's multi-model orchestration and Copilot's automatic model selection — into one layer that balances performance and cost efficiency. For each prompt, it weighs how much reasoning, code generation, debugging, and tool use the task needs, checks which models are healthy and available to you, and picks the most efficient pattern that meets the quality bar for your effort level. There is no need to switch models during a task or decide which model suits each step — Fusion decides, and you stay in the conversation.
One clarification up front, because the name misleads everyone at first: Fusion is not a model. It is the router in the model picker. As GitHub's chief product officer Mario Rodriguez put it, quoted by VentureBeat: "It's not a model. It's an orchestration engine at runtime." If you pick Fusion and expect a new flagship model called Fusion, you will misunderstand every number and setting below.
Why does this exist at all? Because the model menu had become a second job. GitHub's own Octoverse data, surfaced in independent coverage, says paid Copilot users touched 47 different models in September, no single model handled more than a quarter of requests, and 63 percent tried automatic model selection at least once. Developers were spending real time hand-picking models per prompt — and Fusion is GitHub's answer: turn the model picker into an effort dial and let the runtime do the choosing.
How Do You Use GitHub Copilot Fusion, Step by Step?
Seven steps take you from hand-picking models to effort-level coding: update your client, open the model picker, choose Copilot Fusion, choose an effort level, send your first prompt, watch what the router picked, and tune the effort level as the task changes.
- Update your client. Fusion shipped October 28, 2026, in Visual Studio Code (plus the Copilot extension), the GitHub Copilot app, the GitHub Copilot CLI, and JetBrains IDEs. Install the latest versions — if your client predates the launch, the Fusion entry will not exist. Support for additional clients is coming, per GitHub.
- Open the model picker. In VS Code, open Copilot Chat and find the model picker; in the CLI, use the
/modelcommand; in JetBrains, the picker's in the Copilot panel. If you live in the terminal, our Git beginner guide covers the command-line comfort the CLI route assumes. - Select Copilot Fusion. You are not selecting a model here — you are selecting the routing system. If Fusion does not appear in your picker, none of the models it would use are available to you (a plan or policy restriction, covered below).
- Choose an effort level. Standard, High, or Max. Start on Standard for ordinary work; escalate when the task gets harder. This is the only dial you get — learn it and you have learned Fusion's entire UI.
- Send a normal prompt. Nothing about how you write prompts changes. Ask for the bug fix, the refactor, the new feature — exactly as before.
- Watch what the router did. GitHub's changelog says it plainly: watch as Fusion analyzes each task and selects a model to complete it. Seeing which model it chose, and which workflow it ran, teaches you faster than any doc which effort level each of your tasks deserves.
- Tune the effort level per task. Stay on Standard for everyday coding, reach for High on gnarly problems, and reserve Max for the most demanding work. If you came from the research preview, your old
auto,HydraFusion, orHydraFusion Maxselections transitioned to the corresponding Fusion effort levels automatically.
What Do the Three Effort Levels Actually Do?
The effort level is the only dial Fusion gives you: Standard picks one versatile model for everyday coding, High orchestrates capable models for harder work, and Max marshals the most capable models for the most demanding tasks. The Copilot Fusion Standard, High, and Max levels are the three choices you will actually click; everything else on this page explains what each choice buys you.
| Effort level | What Fusion does | Reach for it when | Relative cost |
|---|---|---|---|
| Standard | Balances cost, quality, and latency; selects one model per task | Everyday coding — boilerplate, simple refactors, quick questions | Lowest; the baseline |
| High | Balanced orchestration with moderate token savings; may call more than one model | Substantial, well-scoped work — a complex bug fix, a change across several files — where extra model calls may be worth the extra time and credits | More than Standard |
| Max | Frontier capability while still considering token efficiency; the deepest reasoning and most thorough analysis | The most demanding tasks — architecture-level refactors, security-critical reviews, hard algorithmic work | Highest |
| Fast | Prioritizes fast models | You don't choose it — it runs only in VS Code inline chat scenarios that need fast models | n/a |
Two honest consequences follow from this table. First, because High and Max can call more than one model for a single task, a task on High or Max may consume more AI credits than the same task on Standard — GitHub's docs say this outright. Second, there is a fourth effort level, Fusion Fast, but it is not selectable by users; it exists only for scenarios that need fast models, and only in VS Code inline chat. If you go looking for Fast in the picker and cannot find it, that is the reason.
One more comparison that makes the dial concrete: this is the same idea as tools that stopped asking you to hand-pick a model per prompt and started asking how hard the task is. If you have used another coding agent where you micromanage the model dropdown, our OpenCode walkthrough shows the manual-model-selection world Fusion is replacing.
How Do the Single, Cascade, and Critique Workflows Work?
For each prompt, Fusion runs one of three execution patterns — the Copilot Fusion Single, Cascade, and Critique workflows: Single sends one model at the task; Cascade has an efficient model draft while a judge decides whether to accept the draft or escalate to a stronger model; Critique has one model draft while other models critique in parallel, then the original revises on the aggregated feedback.
| Workflow | What happens, exactly | When Fusion uses it |
|---|---|---|
| Single | One model completes the task directly | Straightforward tasks where one model is enough — the Standard-level default |
| Cascade | An efficient model drafts a response; a quality check (a judge) inspects the draft and decides whether to accept it or escalate to a stronger model for a fresh start | Tasks where a cheap attempt might suffice, with a stronger model as the safety net |
| Critique | One model drafts an initial response; multiple models independently critique it in parallel; their feedback is aggregated and the original model revises its response on the combined feedback | Demanding tasks where independent review genuinely improves the answer |
You do not choose the workflow — Fusion does, per prompt, within the quality bar of your effort level. Standard selects one model for each task; High and Max unlock the multi-model patterns. And note the definitions carefully, because the launch press garbled them: Cascade is not "one model plans, another executes" — it is draft, then judge, then accept-or-escalate. Critique is not two models debating — it is one draft, parallel independent critiques, one revision. The changelog and the docs agree on these definitions verbatim.
Three honest limits sit underneath the orchestration. First, Fusion has no context window of its own — each step runs within the context limits of the model running it. Second, Fusion works separately from subagents and does not start them; if you expected the router to fan out agent swarms, that is a different feature. Third, and the one that bites: if Fusion discards an intermediate draft, the changes that draft already made in your workspace — file edits included — are not undone automatically. Review changes before you commit them.
How Much Does Copilot Fusion Cost?
Fusion itself costs nothing — there is no separate fee for it. You are billed in AI credits for each model Fusion calls, at that model's standard rate, and users on paid Copilot plans get 30% off those model costs through November 30, 2026.
| Billing fact | What it means in practice |
|---|---|
| No Fusion fee | Selecting Fusion adds zero surcharge; the bill is the models it used, nothing else |
| Billed per model, at standard rates | Every model Fusion calls is charged at that model's normal rate in AI credits (1 credit = $0.01) |
| High and Max can cost more than Standard | Because they may call more than one model per task, a High or Max task may consume more credits than the same task on Standard |
| 30% discount, paid plans, through Nov 30, 2026 | For a limited window, users on paid Copilot plans pay 30% less on model costs when using Fusion |
| Plan availability | The changelog says Fusion is available on all Copilot plans; the independent Apex Logic guide reads GitHub's availability table as Standard on every plan with High and Max requiring Pro+, Max, Business, or Enterprise — verify your plan's levels in the picker |
The availability nuance matters because the two sources differ in granularity: GitHub's changelog says Fusion is "available on all Copilot plans," while the Apex Logic guide's reading of the availability table splits it — Standard everywhere, High and Max on the higher tiers. Treat the split as a third-party reading, not a changelog quote. And one practical edge: if none of the models Fusion would use are available to you — plan exclusion or an admin policy — Fusion simply does not appear in your model picker.
How Does Copilot Fusion Compare to Claude Code With Opus 5.5?
On GitHub's own numbers, Fusion Max lands within two points of Claude Code with Opus 5.5 Max on the Artificial Analysis Coding Agent Index — a score of 60, within two points — at about half the average API cost per task, using about half as many tokens and taking about 40% less time per task.
Say it once and hold it: those figures are GitHub's own claims, not independently tested results. Independent coverage is careful here for a reason — whether GitHub commissioned or funded the evaluation is not stated in the changelog, the docs, or the announcement, and the comparison has not been independently reproduced. The changelog's exact wording is "within two points," so treat any precise Opus score you see elsewhere as inference, not a quote.
The press filled in two more numbers worth knowing, both second-hand: VentureBeat reported $5.59 per task for Fusion Max against $11.42 for Claude Code with Opus 5.5 Max, and a FrontierCode score of 51 against 56 (Fusion lower). The sharpest caveat comes from independent commentary: the index measures per-task API cost on a benchmark — it is not a promise about your invoice. Composite index scores are not completion percentages, and benchmark API estimates are not your subscription bill or your total engineering cost. If you benchmark agents yourself, our Claude Code beginner guide covers the other side of this comparison.
How Do You Turn On Copilot Fusion in Each Client?
Update your client, open the model picker, select Copilot Fusion, and choose an effort level — the turn-on is the same shape in every client; only the picker's location differs.
- VS Code: update VS Code and the Copilot extension, open Copilot Chat, pick Copilot Fusion in the model picker, then choose Standard, High, or Max.
- GitHub Copilot app: update the app, open the model picker, select Copilot Fusion, choose your effort level.
- GitHub Copilot CLI: update the CLI, run
/model, select Copilot Fusion, choose your effort level. - JetBrains IDEs: install the latest GitHub Copilot plugin, then pick Copilot Fusion in the model picker and choose an effort level.
Two transition notes. First, more clients are coming — GitHub says so explicitly, so if your editor is not on the list, check back rather than assuming it never will be. Second, if you were in the research preview, your old auto, HydraFusion, or HydraFusion Max selections transition to the corresponding Fusion effort levels automatically — GitHub does not publish which preview maps to which level, so confirm your setting landed where you expect.
What Should Administrators Configure Before Rolling This Out?
Three admin levers control Fusion in an organization: model policies gate which models the router may touch, admins can disable a model for Fusion only, and Enterprise managed settings can make Fusion the org-wide default at any effort level.
The policy gate is absolute — Fusion only uses models enabled in your enterprise and organization model policies, and a model your org blocks cannot be routed to, period. Enterprise administrators can see which models Fusion picks from, set each model's effective policy state independently, and turn a model off for Fusion without disabling it for developers who select it directly — which is how you cap what the router may escalate to without taking models away from anyone. And with Enterprise managed settings, admins can set Fusion at any effort level as the default model for every Copilot user in the org. If you manage the GitHub side of your org, our GitHub beginner guide covers the platform basics the admin console assumes.
One piece of honest advice from independent coverage: read the Fusion docs before making it the org default. High and Max can spend more than Standard, and a discarded draft will not roll its edits back — defaults have billing and workspace consequences you want to choose deliberately.
What Is Fusion Fast, and What Is the Local-Model Preview?
Fusion Fast is a fourth effort level you cannot choose — it exists only for scenarios that need fast models, and only in VS Code inline chat. Separately, an experimental public preview lets Fusion Standard route to models installed on your own machine.
The local-model routing preview is the more interesting of the two. With experimental features enabled, Fusion can choose between on-device and cloud models per request. The models in scope are MAI Code 1.1 Flash on a qualifying Windows computer and Qwen3.8 Flash Next, which you can configure through a local OpenAI-compatible server — Ollama is the named route — on Windows, macOS, or Linux. Enabling it looks like this:
# VS Code: enable local model support in settings, then pick Copilot Fusion # Copilot app: enable "Local model auto routing" under experimental features # Copilot CLI: enable experimental mode, then /model # follow the local-model setup prompts
Two honest footnotes. First, local inference does not make your session offline: Copilot Fusion still makes its routing decisions in the cloud, and local models may carry different safety protections than Copilot-provided cloud models. Second, BYOK models you bring yourself are not automatically eligible for routing — only the models in the preview's scope qualify. This is a preview, not a promise; treat every detail here as current-as-of-writing.
What Are the 7 Mistakes Beginners Make With Copilot Fusion?
Every mistake below comes from the launch coverage — each is a misunderstanding a beginner can hold on day one and drop by day two.
| Mistake | Why it hurts | The fix |
|---|---|---|
| Treating Fusion as a model | You compare "Fusion" against Claude or GPT as if it were one model — every benchmark and setting then misreads | Hold the router mental model: Fusion picks models; it is never itself a model |
| Leaving Max on for everything | Max can call multiple models per task, so routine work burns credits a Standard-level model would have handled | Default to Standard; escalate to High, then Max, only as the task gets harder |
| Ignoring the discarded-draft warning | A draft Fusion threw away may have already edited your files — those edits stay | Review the diff before every commit, especially after Cascade and Critique runs |
| Expecting Fusion to launch subagents | You wait for an agent swarm that never comes | Know the boundary: Fusion routes models for your prompt; it does not start subagents |
| Hunting for Fast in the picker | You waste time looking for an effort level that is not user-selectable | Forget Fast exists — it runs only in VS Code inline chat, automatically |
| Assuming your teammate's Fusion behaves like yours | Model policies differ by org, so the same effort level can route to different models for different people | Check your plan and your org's model policies before comparing notes |
| Reading the benchmark as your bill | You budget around "half the cost" and are surprised by the actual invoice | Treat the 60-vs-Opus figures as GitHub's benchmark claims; your cost is per-model credits, metered |
Sources
- GitHub Changelog — "Route and orchestrate models with GitHub Copilot Fusion" (October 28, 2026): the GA announcement — effort levels, the three workflows verbatim, billing, availability, admin controls, and the Artificial Analysis index claim. https://github.blog/changelog/2026-10-28-route-and-orchestrate-models-with-github-copilot-fusion/
- GitHub Docs — "Copilot Fusion" (docs.github.com/en/copilot/concepts/models/copilot-fusion): the reference — effort-level definitions, the Cascade judge and Critique parallel-critique definitions, Fusion Fast, the 30% discount end date, local-model routing preview, the discarded-draft and subagent limits. https://docs.github.com/en/copilot/concepts/models/copilot-fusion
- Apex Logic — "GitHub Copilot Fusion: Effort Levels, Pricing and How to Use It" (updated October 29, 2026): the independent how-to — effort-level table, per-plan availability reading, billing worked example, per-model rates, and per-client turn-on steps. https://www.apex-logic.net/news/github-copilot-fusion-guide-2026
- subagentic.ai — "Copilot Fusion is generally available" (October 2026): the editorial explainer — pattern details, discount-date sourcing, the evaluation-funding caveat, and the admin-defaults warning. https://subagentic.ai/posts/copilot-fusion-generally-available/
- dev.to / piekwerk — "Copilot Fusion is GA: 2 points off Opus 5.5 Max at half the cost, and your model picker is now an effort dial" (October 31, 2026): the interface-shift angle — Octoverse model-pick data, the benchmark-as-invoice caveat, admin levers, and the local-inference-is-not-offline footnote. https://dev.to/piekwerk/copilot-fusion-is-ga-2-points-off-opus-55-max-at-half-the-cost-and-your-model-picker-is-now-an-4dh1
Frequently Asked Questions
What is GitHub Copilot Fusion?
Copilot Fusion is an intelligent runtime model router and orchestrator inside GitHub Copilot, generally available since October 28, 2026. You choose an effort level — Standard, High, or Max — in the model picker, and Fusion evaluates each task and picks the models and execution patterns that serve it, returning a single response.
Is Copilot Fusion a new AI model?
No. Fusion is not a model; it is the routing and orchestration system in the model picker. It combines Project HydraFusion's multi-model orchestration with Copilot's automatic model selection to balance performance and cost efficiency across the models you already have access to.
How much does Copilot Fusion cost?
There is no separate fee for Fusion. You are billed in AI credits for each model Fusion calls, at each model's standard rate (1 credit = $0.01), and High or Max tasks can consume more credits than Standard ones because they may call multiple models. Users on paid Copilot plans receive a 30% discount on those model costs through November 30, 2026.
Which Copilot plans get Fusion High and Max?
GitHub's changelog says Fusion is available on all Copilot plans in VS Code, the Copilot app, the Copilot CLI, and JetBrains IDEs. The independent Apex Logic guide reads GitHub's availability table more granularly: Standard on every plan, High and Max on Pro+, Max, Business, or Enterprise. Confirm your plan's levels in your own picker.
Does Copilot Fusion work in JetBrains IDEs?
Yes — install the latest GitHub Copilot plugin and Fusion appears in the model picker with the same Standard / High / Max effort levels as VS Code, the Copilot app, and the CLI. GitHub says support for additional clients is coming soon.
