Picking the right AI model for every coding task has quietly become a job in itself. Open your editor, stare at a long list of model names, and guess: is this a quick fix that a fast, cheap model can handle, or a tangled bug that deserves the most powerful model you can afford? Guess wrong in one direction and you waste money. Guess wrong in the other and you waste an afternoon on a weak answer. GitHub Copilot Fusion is GitHub’s answer to that daily guessing game. Announced at GitHub Universe on October 28, 2026, and generally available the same day, Fusion stops asking you to choose a model and instead asks you to choose an effort level. You say how hard the task is. GitHub decides which models do the work, and how they work together. In this guide, we explain what Fusion is, how its Standard, High, and Max levels work, what the benchmark numbers really show, what it costs on every Copilot plan, and who should switch to it first.
Table of Contents
- What Is GitHub Copilot Fusion?
- GitHub Copilot Fusion at a Glance
- How GitHub Copilot Fusion Works
- The Three Effort Levels: Standard, High, and Max
- Single, Cascade, and Critique: The Three Ways GitHub Copilot Fusion Runs a Task
- GitHub Copilot Fusion Benchmarks: 60 vs 62 at About Half the Cost
- What the Benchmark Numbers Mean — and What They Do Not Prove
- GitHub Copilot Fusion Pricing and Copilot Plans
- The 30% Fusion Discount (Through November 30, 2026)
- How to Turn On GitHub Copilot Fusion
- GitHub Copilot Fusion for Teams and Enterprises
- Why GitHub Copilot Fusion Arrived Now: The Octoverse Story
- GitHub Copilot Fusion vs Claude Code and vs Picking a Model Yourself
- Who Should Use GitHub Copilot Fusion — and Who Should Wait
- A Practical Playbook for GitHub Copilot Fusion
- Limitations of GitHub Copilot Fusion You Should Know
- The Verdict on GitHub Copilot Fusion
- Frequently Asked Questions About GitHub Copilot Fusion
What Is GitHub Copilot Fusion?
GitHub Copilot Fusion is a routing and orchestration system inside GitHub Copilot. Instead of appearing as one more model in a list, Fusion sits above the models. When you select it in the model picker, you are choosing a system, not a single model. For each prompt, Fusion looks at what the task seems to need — reasoning, code generation, debugging, or tool use — and then decides which model or combination of models should handle it. The idea, in GitHub’s own framing from Universe, is simple: developers should not have to manage every model choice to get the right result at the right price.

That shift matters because the model menu inside Copilot has grown fast. Developers using GitHub Copilot now have access to models from OpenAI, Anthropic, and Google, and each of those families offers several strengths, speeds, and prices. Having choice is good. Having to re-make that choice for every prompt, under deadline pressure, is not. Most developers fall into one of two habits: they leave the most powerful model selected all day, which burns budget on trivial edits, or they leave a cheap model selected and then wonder why a hard problem keeps coming back half-solved. GitHub Copilot Fusion is designed to break both habits at once.
GitHub Copilot Fusion combines two things GitHub had already been building. The first is Copilot’s automatic model selection, which picks a suitable model for a prompt. The second is Project HydraFusion, a research preview from September 2026 that explored how several models could coordinate on one task. Fusion brings those two ideas together into a single, generally available setting. If you were using the preview options called auto, HydraFusion, or HydraFusion Max, GitHub moves your choice automatically to the matching Fusion effort level, so you do not have to start from scratch.
It is worth being precise about what GitHub Copilot Fusion is not. It is not a new foundation model. It does not replace Claude, GPT, or any other model with a GitHub-built brain. It is the traffic controller standing in front of those models. It is also not a magic cost-cutter that makes every task cheaper in every situation. As we will see in the pricing section, the higher effort levels can call on more than one model, and a task that uses two models can cost more in credits than the same task on the lowest level. The promise of Fusion is better judgement about when that extra spend is worth it — not a promise that you will never spend it.
GitHub Copilot Fusion at a Glance
Here is the short version for readers in a hurry. GitHub Copilot Fusion became generally available on October 28, 2026, at GitHub Universe in San Francisco. It is available on all Copilot plans in Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI, and JetBrains IDEs, with support for more clients promised later. You pick Fusion in the model picker and then choose one of three effort levels: Standard, High, or Max. Billing follows the models actually used, each at its standard rate, and paid Copilot plans get a limited-time 30% discount on model costs when using Fusion, through November 30, 2026.
| Detail | GitHub Copilot Fusion |
|---|---|
| Launched | October 28, 2026, at GitHub Universe (generally available) |
| What it does | Routes each coding task to one or more models and coordinates how they work together |
| What you choose | An effort level: Standard, High, or Max |
| Where it works | VS Code, the GitHub Copilot app, Copilot CLI, and JetBrains IDEs |
| Headline benchmark | Fusion Max scored 60 on the Artificial Analysis Coding Agent Index, vs 62 for Claude Code with Opus 5.5 Max, at $5.59 vs $11.42 per task |
| Separate fee | None — you pay for the models Fusion uses, at each model’s standard rate |
| Limited-time discount | 30% off model costs on paid plans when using Fusion, through November 30, 2026 |
If you only remember one sentence from this guide, make it this one: GitHub Copilot Fusion turns model selection from a per-prompt decision into a per-task budget decision. You control the effort. GitHub controls the routing. Your job shifts from choosing models to describing tasks clearly and checking results carefully.
How GitHub Copilot Fusion Works
When you send a prompt with GitHub Copilot Fusion selected, the system first assesses the task. Is this mostly a simple edit, where a fast model will do? Does it need deep reasoning across several files? Does it involve debugging, where a second pair of eyes might catch what the first model missed? Does it need tools — searching a codebase, running tests, reading documentation — before any code is written? Fusion weighs those demands against your chosen effort level and then builds a plan: which model or models to use, and in what arrangement.
That assessment step is the part most single-model setups cannot do. A single model, however good, has one speed, one price, and one style. It cannot decide to be cheap for the easy half of a task and expensive for the hard half. GitHub Copilot Fusion can, because it is allowed to split the work. A cheap model might draft the first version. A stronger model might judge whether that draft is good enough. Or one model might write while another reviews, with the first model revising before anything reaches you. The exact arrangement depends on the task and on the effort level you set, which is why the same prompt can cost different amounts under Standard, High, and Max.
There is an important practical consequence here. With GitHub Copilot Fusion, your prompt quality matters even more than it did before. The router can only judge the task you actually describe. A vague instruction such as “fix the login bug” gives the system very little to work with, and even a brilliant router will struggle to pick the right approach for a problem it cannot see clearly. A specific instruction — what is broken, what you have already tried, what a correct fix must do, and how you will test it — gives Fusion the information it needs to route well. In other words, Fusion does not remove skill from coding. It moves the skill from model trivia to task specification, which is a much better place for it to live.
The Three Effort Levels: Standard, High, and Max
GitHub Copilot Fusion gives you exactly three choices, and learning when to use each one is the whole skill of using the feature well. Think of them as budgets for brainpower, not as quality settings you should always push to the top. Using Max for everything is like hiring a senior architect to rename a variable: the work gets done, but the bill does not make sense.
Fusion Standard prioritises efficiency and cost for everyday coding. This is the level for routine work: small edits, boilerplate, simple refactors, documentation tweaks, test updates, and familiar patterns you could almost write yourself. GitHub Copilot Fusion at Standard leans toward versatile, lower-cost models and keeps the workflow simple, so your credit balance lasts longer across a normal working day. For many developers, Standard should be the default, with the higher levels reserved for the minority of tasks that genuinely need them.
Fusion High targets challenging tasks and deeper reasoning. Reach for High when the task crosses files, involves a design decision, or needs careful thinking about edge cases — a new feature with several interacting parts, a migration between libraries, a performance problem with more than one plausible cause. GitHub Copilot Fusion at High is allowed to use more capable models and more reasoning, and it may bring in a second model to judge or review the first model’s work. That extra effort costs more, but for a task that would otherwise eat an hour of your time, it is usually money well spent.
Fusion Max reserves the most capable models for the most demanding tasks and the deepest reasoning. This is the level for the problems you would otherwise escalate to the strongest model you have: a concurrency bug that only appears under load, a security-sensitive change, a large refactor where a mistake would be expensive, or an unfamiliar codebase where the first draft is almost certain to miss something. GitHub Copilot Fusion at Max is also the level behind the headline benchmark numbers in this guide, so if you want Fusion’s best measured performance, Max is where it lives. Just remember that Max is also where multi-model work is most likely, so it is the level where costs can climb fastest if you use it for everything.
| Effort level | Best for | What to expect |
|---|---|---|
| Fusion Standard | Everyday coding: small edits, boilerplate, simple refactors, docs | Versatile models, lowest cost, fastest routine answers |
| Fusion High | Challenging tasks: multi-file features, migrations, tricky debugging | More capable models, deeper reasoning, possible review step |
| Fusion Max | Demanding tasks: concurrency bugs, security changes, large refactors | Most capable models, deepest reasoning, highest cost per task |
A good rule of thumb is to start on Standard and escalate only when the result tells you to. If Standard’s answer is wrong in an interesting way, or if it stalls on a problem you know is hard, switch to High or Max for the next attempt rather than re-running Standard three times. Repeated cheap attempts that all fail cost more than one well-aimed expensive attempt, and they cost you time as well. GitHub Copilot Fusion rewards that discipline: the effort level is a dial you turn deliberately, not a setting you forget.
Single, Cascade, and Critique: The Three Ways GitHub Copilot Fusion Runs a Task
Behind the three effort levels, GitHub Copilot Fusion uses three execution patterns. You do not pick a pattern directly — Fusion picks it for each task — but understanding them helps you predict costs and judge results.

Single: One Model, Start to Finish
In the Single pattern, one model completes the task directly. This is the cheapest and fastest arrangement, and it is what most everyday tasks need. When GitHub Copilot Fusion judges a task to be straightforward and well within one model’s abilities, it does not waste money on a second opinion. If you mostly work at Standard, most of your tasks will run this way, and that is a good thing.
Cascade: A Cheap Model Tries First, a Stronger Model Takes Over Only If Needed
In the Cascade pattern, an efficient model attempts the task first, and another model evaluates the result. If the draft passes the quality check, the task ends there and you have saved money. If it does not, a stronger model takes over. Cascade is the pattern that makes GitHub Copilot Fusion genuinely different from simply picking an expensive model “just in case.” The expensive model only gets involved when the cheap attempt has already shown it is needed. For teams watching a credit balance, Cascade is the pattern doing most of the quiet saving.
Critique: One Model Drafts, Another Reviews, the First Revises
In the Critique pattern, one model drafts a solution, a second model reviews it, and the original model revises its work based on that review. This is the most expensive pattern, and it is reserved for tasks where a second perspective is likely to catch real mistakes — the kind of review a careful colleague would give before a pull request. Critique is also the pattern to watch most closely as independent evaluations appear, because its value depends entirely on whether the reviewing model actually rejects bad code or simply rubber-stamps it. A review step that never says no is pure overhead. A review step that catches a real bug before merge is worth every credit it costs.
Notice what these patterns have in common: in every case, GitHub Copilot Fusion is spending your budget on judgement, not just on generation. That is the conceptual change worth understanding. Older AI coding tools asked, “Which model writes this code?” Fusion asks, “How much judgement does this task deserve, and where should that judgement come from?” For routine work, the answer is “not much, from one model.” For hard work, the answer is “a lot, from more than one.” Getting that answer right, task by task, is where the savings and the quality gains are supposed to come from.
GitHub Copilot Fusion Benchmarks: 60 vs 62 at About Half the Cost
The headline numbers for GitHub Copilot Fusion come from Artificial Analysis, an independent benchmark evaluator, and its Coding Agent Index version 2.0. GitHub cites the results, and Artificial Analysis published its own write-up on October 28, 2026, after benchmarking the Max setting inside GitHub Copilot CLI. Here are the numbers as published, with the important context attached to each one.
| System (Max setting) | Coding Agent Index score | Average cost per task | Tokens per task |
|---|---|---|---|
| GitHub Copilot Fusion (Max, in Copilot CLI) | 60 | $5.59 | 7.2 million |
| Claude Code with Claude Opus 5.5 (Max) | 62 | $11.42 | About double Fusion’s token use |
| Devin Fusion with Opus 5.5 (Max) + GPT-6 Luna (High) | 62 | $8.00 | About 30% more than Fusion |
In plain language: GitHub Copilot Fusion at Max scored two points behind Claude Code with Opus 5.5 Max on the overall index, while costing roughly half as much per task — $5.59 against $11.42, a saving of about 51%. GitHub also says Fusion Max completed benchmark tasks in about 40% less time per task than the Claude Code configuration. On the index’s three component benchmarks, the picture is more mixed, and that mix is informative. Fusion led Terminal-Bench 4.0 with a score of 71, ranked third on FrontierCode at 51 (behind Claude Code with Opus 5.5 Max at 56 and Devin Fusion at 54), and lagged on SWE-Atlas-QnA-AA at 57, between GPT-6 Astra in Codex and Gemini 4 Argon in Antigravity CLI.
The models behind Fusion in that benchmark, according to Artificial Analysis, came from Anthropic and OpenAI, including Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra, and GPT-6 Sol. That detail matters for anyone trying to reproduce the result or compare it with their own stack: the benchmark measures Fusion as a system running those models, not Fusion as an abstract idea. Change the model pool, and the numbers could change too — which is why GitHub’s documentation warns that execution patterns and the model pool may change over time.
What the Benchmark Numbers Mean — and What They Do Not Prove
Benchmarks are useful, but only if you read them the way they were meant to be read. Here is an honest reading of the GitHub Copilot Fusion numbers, including the caveats that GitHub’s own announcement and the independent write-up both invite.
First, the good news is real. A two-point gap on an overall index, at half the cost per task and about half the token use, is a meaningful result — especially because the cost saving comes from using fewer tokens, not from using a cheaper model to produce the same volume of output. Fusion used 7.2 million tokens per task, roughly half of what Claude Code with Opus 5.5 used. That suggests the routing is doing actual work: cheap models handling the parts they can handle, expensive models reserved for the parts that need them, and less wasted output overall. The Terminal-Bench lead (71) also suggests Fusion is strong at the terminal-based, multi-step tasks that resemble real developer workflows.

Second, the gaps are real too. Two points on an overall index is close, not equal, and the component scores show where GitHub Copilot Fusion is weaker: FrontierCode and SWE-Atlas-QnA-AA, where it trails the leaders. If your work looks more like those benchmarks — certain kinds of coding questions and frontier-style tasks — the headline “near-frontier at half the cost” may overstate what you will get. Benchmarks also measure a specific setup (Copilot CLI, Max setting, a specific model pool, a specific date). Your editor, your codebase, your task mix, and the model pool next month may all differ.
Third, watch the difference between the two cost claims circulating about Fusion. The Artificial Analysis figure — about half the cost per task — is a measured average from that benchmark. Microsoft chief executive Satya Nadella’s larger claim, that Fusion delivers frontier-level quality at up to 77% lower cost, refers to a separate, company-reported evaluation, not to the Artificial Analysis average. Both claims can be true about different measurements, but they are not the same claim, and you should not budget from the 77% figure as if it were the benchmark average. VentureBeat made exactly this distinction in its Universe coverage, and it is the right one to keep.
Finally, remember that GitHub is citing Artificial Analysis, and the question of whether GitHub commissioned or funded that evaluation is not settled in the changelog, product docs, or announcement materials that independent trackers reviewed. That does not make the numbers wrong — Artificial Analysis is a known evaluator with a published methodology — but it does mean the prudent move is to treat the benchmark as encouraging evidence, not as proof, and to run your own comparison on your own representative tasks before making Fusion the default for a whole team. The section on a practical playbook below shows how.
GitHub Copilot Fusion Pricing and Copilot Plans
There is no separate GitHub Copilot Fusion subscription fee. Fusion is a setting inside Copilot, available on all Copilot plans, and you pay for the models Fusion actually uses, each at that model’s standard rate. That sentence is simple, but its consequences are not, because Copilot’s billing itself changed in 2026. Since June 1, 2026, Copilot plans have been billed with GitHub AI Credits instead of the old premium-request system. One AI credit is worth $0.01, and each plan includes a monthly allowance of credits that agent work and chat draw down at the model’s per-token price. Code completions and next-edit suggestions, by contrast, do not use credits and remain unlimited on every paid plan.
Here are the individual and team plan prices as reported in October 2026, with their included credit values. Treat the credit figures as the current published allowances, and check GitHub’s pricing page before you buy, because GitHub has said flex allotments — the bonus portion of the allowance — can change over time.
| Copilot plan | Monthly price | Included AI credits (value) |
|---|---|---|
| Free | $0 | Limited allowance, auto model only |
| Pro | $10 per user | 1,500 credits ($15) |
| Pro+ | $39 per user | 7,000 credits ($70) |
| Max | $100 per user | 20,000 credits ($200) |
| Business | $19 per user | 1,900 credits per user, pooled across the organisation |
| Enterprise | $39 per user | 3,900 credits per user, pooled across the organisation |
Now connect those plan numbers to Fusion. On Fusion Standard, your tasks will mostly run as Single-model work on versatile models, so your credit burn should track roughly with ordinary Copilot agent use. On Fusion High and Fusion Max, a task may call on more than one model, so the same task may consume more AI credits than it would on Standard. That is not a flaw in the design — it is the design. You are buying extra judgement. But it does mean that switching everyone to Max “because it is the best” is the fastest way to burn through a pooled credit allowance and start paying overage. The right default for most teams is Standard, with High and Max used deliberately for the tasks that justify them.
There is a second Universe pricing change worth knowing about, because it changes the maths for larger organisations. GitHub said Enterprise customers can now get Copilot included for every licensed user, without a separate per-seat Copilot purchase, and pay only for the AI credits actually used. For a company that was previously buying Copilot seats one by one, that is a structural change: the question shifts from “who gets a seat?” to “how do we budget credits across the whole organisation?” In that world, a routing system like GitHub Copilot Fusion — which tries to keep routine work cheap and reserve expensive models for hard work — becomes a budgeting tool, not just a convenience.
The 30% Fusion Discount (Through November 30, 2026)
For a limited time, users on paid Copilot plans get a 30% discount on model costs when using Fusion, through November 30, 2026, according to GitHub’s Fusion documentation as summarised by independent pricing trackers. That date matters. If you are evaluating Fusion, the cheapest time to run your comparison is right now, while the discount applies, and the honest time to judge its long-run value is after you have modelled what the same usage costs at full price.
Here is a simple way to use the discount window well. First, pick ten to twenty tasks that represent your real work: a mix of routine edits, a feature, a bug, and a refactor. Second, run half on your current setup and half on GitHub Copilot Fusion, keeping the effort level matched to the task (Standard for routine, High or Max for hard). Third, record three numbers per task: whether the result was accepted without major rework, how long it took, and how many credits it used. Fourth, repeat the cost maths at full price, without the 30% discount. If Fusion still wins on cost per accepted result at full price, you have a durable case. If it only wins during the discount, you have a deadline: either adopt while it is cheap, or wait and re-test later. Either answer is better than guessing.
One more billing detail deserves a plain sentence, because it surprises people. Fusion bills you for each model it uses at that model’s standard rate. There is no blended “Fusion rate” and no discount built into the routing itself, apart from the limited-time 30% offer. If Fusion routes your task to an expensive model, you pay that model’s price for the tokens it uses. The saving, when it happens, comes from using fewer tokens overall and from letting cheap models do the cheap parts — not from a special Fusion price list.
How to Turn On GitHub Copilot Fusion
Getting started with GitHub Copilot Fusion takes less than a minute, because there is nothing to install. Fusion is a model-picker choice inside the Copilot surfaces you already use. The steps below follow GitHub’s documented flow; the exact menu labels may vary slightly between VS Code, JetBrains, the Copilot app, and the CLI, but the pattern is the same everywhere.
- Update your Copilot client to the latest version, so the generally available GitHub Copilot Fusion option appears in the model picker.
- Open the model picker in VS Code, the GitHub Copilot app, Copilot CLI, or your JetBrains IDE, and select Copilot Fusion.
- Choose your effort level: Standard for everyday work, High for challenging tasks, or Max for the most demanding tasks.
- Write your prompt as a task specification, not a model instruction: what you want, the constraints it must respect, and how you will know it is done.
- Review the result before you commit, especially on High and Max, where a second model may have reviewed — or revised — the first model’s work.
- Check your credit usage after a day or two on each level, and adjust your default level to match what your real tasks actually cost.
If you were part of the research preview, you may not need to do anything at all. GitHub says users who had auto, HydraFusion, or HydraFusion Max enabled move automatically to the matching Fusion effort level. If you do not see Fusion in the picker, check two things before assuming it is unavailable: first, that your client is updated, and second, that your organisation has not restricted the models Fusion draws on. GitHub’s documentation notes that if none of Fusion’s models are available to you — because of plan, admin policy, data-residency, or other restrictions — Fusion simply does not appear in the picker.

There is also a separate preview worth keeping distinct from the generally available release. With experimental features enabled, Fusion Standard can choose certain models installed on your own machine, including MAI Code 1.1 Flash on a qualifying Windows computer and, in Copilot CLI, a locally identified Qwen3.8 Flash Next model. That local-model routing is a public preview sitting beside the release, not part of the general-availability claim, so do not judge Fusion’s GA performance by what a local preview model does on your laptop. The GA story is about routing across hosted Anthropic and OpenAI models; the local story is an experiment in keeping some work on your own machine.
GitHub Copilot Fusion for Teams and Enterprises
For individual developers, GitHub Copilot Fusion is a convenience. For teams, it is a policy question. The good news is that GitHub built the admin controls first, rather than bolting them on later. Enterprise and organisation administrators control which models Fusion may draw on, through enterprise and organisation model policies. An admin can disable a model for Fusion without disabling it for everyone, and can set each model’s policy state separately. That granularity matters when a team has approved one provider for general use but not for a particular kind of work, or when data-residency rules limit which models may handle certain code.
Administrators can also set Fusion, at any effort level, as the default for Copilot users under enterprise managed settings. That is a powerful lever, and it should be pulled deliberately. Making Fusion Standard the default is a low-risk way to give every developer better routing without changing their budget profile much. Making Fusion Max the default for everyone, by contrast, is a decision to spend more on every task in exchange for higher quality — which may be exactly right for a security-critical team and exactly wrong for a team whose credit pool is already tight. The sensible rollout is staged: Standard as the default, High and Max available on request, and a review of credit usage after a month before any wider default change.
One early enterprise data point comes from AT&T, quoted in GitHub’s changelog. Hari Pokhrel, a principal software engineer at AT&T, said Fusion Standard improved token efficiency across AT&T by automatically selecting the right model for each task, reducing unnecessary spend and preserving capacity for higher-value work, and that its decision-making had improved over time. That is a vendor-quoted customer story, not an independent study, so read it as a plausible outcome rather than a guaranteed one. But it points to the right enterprise metric: not “how many tasks did we run?” but “how much of our credit pool went to work that actually mattered?” GitHub Copilot Fusion earns its place in a team when that second number improves.
Why GitHub Copilot Fusion Arrived Now: The Octoverse Story
Fusion did not arrive in a vacuum. It arrived alongside GitHub’s 2026 Octoverse report, which describes a platform transformed by agents in a single year. Developers pushed code to GitHub 17.9 billion times in the twelve months to September 30, 2026 — more than in 2024 and 2025 combined — and commits across public and private repositories reached 34.3 billion. By September 2026, more than 40% of pull requests started with an agent’s first draft, up from just 17% in March. Among repositories created during the year, the average repo with an agent configuration file logged eight times as many commits as the average new repo without one. GitHub now serves more than 225 million developers, with 38.3 million in the United States and 32 million in India.
Those numbers explain both the opportunity and the pressure behind GitHub Copilot Fusion. When agents write the first draft of two in every five pull requests, the cost of those drafts stops being a rounding error and starts being a budget line. When 61% of Copilot users in September used more than one model, model choice stops being a niche concern and becomes something every developer does, badly, every day. Fusion is GitHub’s bet that the platform, not the individual developer, should manage that complexity — and that doing so will keep agent-driven development affordable enough to keep growing.
The same Universe event that launched Fusion also showed how much infrastructure that growth demands. GitHub announced it is adding four million CPU cores and 160 petabytes of high-speed storage, with 50 terabits per second of network capacity, and redesigning its architecture to separate compute and storage, aiming for far greater throughput. Microsoft’s Jay Parikh, whose CoreAI teams include GitHub, framed the shift plainly: developers are moving from writing code line by line to orchestrating assistants and fleets of agents, and GitHub’s goal is to become the most comprehensive software delivery system in the world, with completed work — not more code — as the main output. Fusion fits that framing exactly: it is a piece of delivery infrastructure, not just a coding helper.
GitHub Copilot Fusion vs Claude Code and vs Picking a Model Yourself
The most useful comparison for GitHub Copilot Fusion is not against a single rival product. It is against the three ways developers actually get code written today: picking one model yourself, using Claude Code with a top model, or letting Fusion route the work. Each has a clear trade-off, and the right choice depends on what you value most: control, quality, or cost per finished task.
| Approach | Strength | Weakness | Best for |
|---|---|---|---|
| Pick a model yourself | Full control; predictable cost per prompt | Daily guessing; easy to overpay or underpower a task | Developers who know exactly which model fits each task type |
| Claude Code with Opus 5.5 Max | Highest measured index score (62) in this benchmark | Highest cost per task ($11.42); most tokens per task | Teams where maximum quality matters more than cost |
| GitHub Copilot Fusion (Max) | Near-top score (60) at about half the cost ($5.59) and half the tokens | Less control over which model runs; weaker on some component benchmarks | Teams that want strong results without paying top-model prices on every task |
Against Claude Code specifically, Fusion makes its case on efficiency, not on outright victory. It does not beat Claude Code with Opus 5.5 Max on the overall index — it trails by two points. What it offers is a result close enough that many teams will accept the gap in exchange for halving the per-task cost and finishing tasks faster. That is a legitimate trade, but it is a trade, and it should be presented as one. If your work sits in the benchmark areas where Fusion trails most, or if a two-point quality gap means a security bug slipping through, the cheaper option is not the better option. The benchmark tells you Fusion is close. Your own tasks tell you whether close is close enough.
Against picking a model yourself, GitHub Copilot Fusion makes a different case: it removes a decision you were probably making badly. GitHub’s Octoverse data shows most Copilot users already switch between models, which means most developers are already paying the mental cost of model selection without necessarily getting the benefit. Fusion centralises that decision in a system that sees the task, the effort level, and the model pool together. You lose the ability to say “use this exact model for this exact prompt” — although you can still pick a specific model directly in Copilot when you want to — and you gain a system that applies the same routing judgement consistently, even on your tired Friday afternoon prompts.
Readers who want the wider landscape should also look at our comparison of the best AI coding assistants, which puts Copilot alongside Cursor, Claude Code, and other tools on price, free tiers, and agent modes, and at our guide to Skillsync, which solves a neighbouring problem: moving a live coding session between agents such as Claude Code, Cursor, and Codex without losing your place. Fusion decides which models do a task; Skillsync decides how your session survives when you switch agents mid-task. Used together, they point to the same future: less time managing tools, more time shipping software. For readers tracking the frontier models behind these tools, our guide to Claude Sonnet 5.5 explains the model family that sits inside Fusion’s pool.
Who Should Use GitHub Copilot Fusion — and Who Should Wait
GitHub Copilot Fusion is a strong fit for solo developers and small teams who already use Copilot daily and want to stop thinking about models. If you are on Pro or Pro+, Standard as your default with High for hard tasks is a sensible starting point, and the 30% discount window makes October and November 2026 a cheap time to test it. It is also a strong fit for engineering managers who need to control a pooled credit budget without policing every developer’s model choice: set Standard as the default, let developers escalate deliberately, and review the credit data monthly.
Fusion is a strong fit for teams working across a varied task mix. If your week includes routine edits, a feature build, a migration, and a nasty bug, a single model is always the wrong answer for at least one of those tasks. Fusion’s whole point is to match the model to the task instead of forcing one model to cover everything. Teams with strict model policies will also appreciate the admin controls, provided they take the time to configure them before rolling Fusion out widely.
Who should wait? Developers who need a specific model for a specific reason — a compliance requirement, a benchmark they must reproduce, a workflow tuned to one model’s quirks — should keep picking that model directly. Fusion is not designed to replace deliberate single-model use; it is designed to replace accidental single-model use. Developers on a very tight credit budget should also be careful with High and Max until they have measured their own cost per accepted task, because multi-model work can consume more credits than Standard. And anyone whose organisation has not yet decided which models Fusion may use should wait for that policy decision rather than letting the default pool decide for them.
A Practical Playbook for GitHub Copilot Fusion
Here is a week-long routine that turns GitHub Copilot Fusion from a novelty into a measured part of your workflow. It needs no extra tools — just a notebook, your credit dashboard, and a willingness to judge results honestly.
- Day 1: Set Standard as your default. Use GitHub Copilot Fusion on Standard for everything, exactly as you would use Copilot normally. Note which tasks feel slower or weaker than your usual setup.
- Day 2: Escalate deliberately. For each task that Standard handled poorly, retry it on High, and for the hardest one or two, on Max. Record whether the escalation actually fixed the problem or just produced a longer answer.
- Day 3: Write better task specifications. Before each prompt, add three lines: what done looks like, what must not break, and how you will test the result. Notice whether GitHub Copilot Fusion routes better when the task is described better. In our experience with routing systems generally, this step alone improves results more than any setting change.
- Day 4: Check the credit maths. Compare your credit use on Fusion days with a normal Copilot week. Divide total credits by accepted results, not by prompts sent. Cost per accepted result is the only cost number that matters.
- Day 5: Test the critique step. On a High or Max task, read the result as a reviewer, not as a user. Did the second model catch anything? Would you have caught it yourself? If the review step never changes anything, you are paying for reassurance, not quality.
- Day 6: Set your personal defaults. Write down your own rule — for example, Standard for edits and docs, High for features, Max for concurrency and security — and put it in your team’s shared notes so new joiners inherit it.
- Day 7: Decide at full price. Re-run your cost maths without the 30% discount. If GitHub Copilot Fusion still wins, make it your default with confidence. If it only wins during the discount, decide whether to adopt now or re-test after November 30, 2026.
Two habits make the whole playbook work. First, always review before you commit, especially after a discarded draft: Fusion works separately from subagents, and if it discards a draft, file edits that draft already made are not undone automatically. Check the workspace before you commit, every time, on every effort level. Second, measure on your own code. Benchmarks rank systems on shared tasks. Your codebase — its size, its style, its test coverage — is the only benchmark that decides whether Fusion saves you money.
Limitations of GitHub Copilot Fusion You Should Know
No honest guide to GitHub Copilot Fusion should end without its limits, and GitHub’s own documentation is refreshingly clear about several of them. First, Fusion works separately from subagents and does not start them. If your workflow depends on subagents, Fusion will not orchestrate them for you; it routes models within a task, not agents across a project. Second, as noted above, a discarded draft does not automatically roll back its file edits, so review discipline is not optional. Third, execution patterns and the model pool may change over time, which means today’s routing behaviour and today’s benchmark numbers are not a permanent contract. A model that Fusion uses today may leave the pool, and a pattern that works today may be tuned tomorrow.

Fourth, availability depends on your plan and your organisation’s policies. If none of Fusion’s models are available to you, Fusion does not appear in the picker at all — which can look like a bug when it is actually a policy outcome. Check with your admin before troubleshooting the client. Fifth, Fusion is currently available in VS Code, the Copilot app, Copilot CLI, and JetBrains IDEs, with other clients promised later; if your daily editor is outside that list, you will be waiting. Sixth, the local-model preview on Standard is exactly that — a preview, with a different model set and different performance — and should not be confused with the generally available hosted routing.
Finally, there is a limit no documentation page will state, but every developer should keep in mind: Fusion optimises for the task you describe, not the task you meant. A brilliantly routed answer to a badly specified problem is still a badly specified answer. Fusion lowers the cost of model choice. It does not lower the cost of unclear thinking, missing tests, or unreviewed merges. The teams that benefit most from Fusion will be the teams that were already good at specifying and reviewing work — because Fusion amplifies good process and, just as efficiently, amplifies sloppy process too.
The Verdict on GitHub Copilot Fusion
GitHub Copilot Fusion is the least flashy announcement from GitHub Universe 2026, and it may turn out to be the most consequential. It does not introduce a new model, a new app, or a new programming language. It introduces a new default: let the platform choose the model, and let the developer choose the effort. That default matches where software development is actually going — agents drafting a growing share of pull requests, models multiplying faster than any developer can track, and credit budgets replacing seat counts as the thing managers watch. In that world, routing is infrastructure, and infrastructure that halves the cost of near-frontier work is worth taking seriously.
Our recommendation is straightforward. If you already use GitHub Copilot, turn on Fusion this week, set Standard as your default, and run the seven-day playbook above while the 30% discount is live. Judge it on cost per accepted result on your own code, at full price as well as discounted price, and keep picking a specific model directly whenever you have a specific reason to do so. If you do not use Copilot yet, Fusion alone is not a reason to switch — but if you are already comparing Copilot with Claude Code and other assistants, Fusion’s benchmark result (60 vs 62, at $5.59 vs $11.42 per task) is now a genuine part of that comparison, and it makes Copilot’s case considerably stronger than it was a week ago.
The bigger story is the one GitHub told at Universe: software is increasingly written by agents, reviewed by developers, and delivered as completed work rather than as lines of code. GitHub Copilot Fusion is a small, practical piece of that story — a traffic controller for an age when the question is no longer “which AI should I use?” but “how much intelligence does this task deserve, and who pays for it?” For most developers, most of the time, the answer to the first question is now “let Fusion decide.” The answer to the second is still yours.
Frequently Asked Questions About GitHub Copilot Fusion
What is GitHub Copilot Fusion in simple terms?
Fusion is a setting inside GitHub Copilot that picks which AI models handle your coding task, instead of you picking one model from a list. You choose an effort level — Standard, High, or Max — and Fusion routes the task to one or more models, using Single, Cascade, or Critique patterns depending on what the task needs.
How much does GitHub Copilot Fusion cost?
GitHub Copilot Fusion has no separate fee. You pay for the models it uses, each at its standard rate, drawn from your Copilot plan’s AI credit allowance (1 credit = $0.01). Paid plans get a 30% discount on model costs when using Fusion through November 30, 2026. Note that High and Max can use more than one model, so a task may consume more credits than on Standard.
Is GitHub Copilot Fusion better than Claude Code?
On the Artificial Analysis Coding Agent Index, Fusion at Max scored 60, two points behind Claude Code with Opus 5.5 Max at 62, but at about half the cost per task ($5.59 vs $11.42) and about half the tokens. So Fusion is close on quality and cheaper on cost in that benchmark — but it does not beat Claude Code outright, and your own tasks may rank them differently.
Where can I use GitHub Copilot Fusion?
GitHub Copilot Fusion is generally available on all Copilot plans in Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI, and JetBrains IDEs, with support for additional clients coming later. Select it in the model picker and choose an effort level.
Which models does GitHub Copilot Fusion use?
In the Artificial Analysis benchmark, Fusion drew on Anthropic and OpenAI models, including Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra, and GPT-6 Sol. GitHub notes that the model pool and execution patterns may change over time, and administrators can restrict which models Fusion may use.
Can my company control GitHub Copilot Fusion?
Yes. Enterprise and organisation administrators control which models GitHub Copilot Fusion can draw on, can disable a model for Fusion without disabling it for everyone, and can set Fusion at any effort level as the default under enterprise managed settings. If Fusion does not appear in your picker, an admin policy or model availability restriction may be the reason.
Sources and further reading: Artificial Analysis on Copilot Fusion’s benchmark results, VentureBeat’s Universe coverage of the cost and time claims, and GitHub’s Octoverse 2026 report on agent-driven pull requests. Benchmark figures in this article are GitHub’s citation of Artificial Analysis unless stated otherwise; the up-to-77% saving figure is a separate company-reported evaluation, not the benchmark average.
