GitHub Copilot Fusion vs Claude Code: Model Routing, Benchmark Costs and Windows Local Models

What GitHub actually shipped​

GitHub Copilot Fusion is generally available. Instead of picking a model for each task, you choose Fusion and let Copilot route and orchestrate the models for you. The date was October 28, 2026. Its predecessor, Project HydraFusion, started as a research preview in Copilot CLI on 4 September 2026 and reached VS Code and the Copilot app on 30 September, according to a DEV Community write-up.

You pick an effort level instead of a model. GitHub's changelog lists three:

• Standard: versatile models for everyday coding.
• High: more capable models for challenging tasks and deeper reasoning.
• Max: the most capable models for the most demanding work.

GitHub's documentation also describes a Fusion Fast mode. Users can't select it, and it is only used in VS Code inline chat.

Fusion is available on all Copilot plans in Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI and JetBrains IDEs, with more clients promised. Which effort levels you see can still depend on your plan. One outlet reported that Standard is available on all plans, while High and Max are limited to supported plans. Treat that as a lead and check your own model picker.

The three execution patterns​

GitHub's documentation says Fusion picks one of three patterns for each prompt, so one session can mix them.

Fusion adds model calls only when a task seems to warrant them, so a simple request shouldn't pay for a review it doesn't need. Cascade and Critique do take longer, because they include review calls.

Fusion has no context window of its own. Each step is limited by the model running that step. The window shown for Fusion is a conservative figure based on the smallest limits among the models in its pool.

What Claude Code is, and why it isn't the same thing​

Claude Code is a tool-using coding agent. Anthropic's CLI documentation shows you can run it interactively or in print mode. You can also choose a model, set a permission mode, restrict which tools it may use, and cap spending in non-interactive runs. Anthropic's prompting guidance describes subagent delegation for parallel or independent workstreams, and it cautions against overusing it.

That is a different idea from Fusion's. A subagent splits or delegates work. Fusion routes among models and adds draft review. GitHub's documentation says Fusion works separately from subagents and doesn't start them. The two ideas could complement each other, but they are not interchangeable.

For Windows developers, Anthropic's setup page says you can run Claude Code natively on Windows or inside WSL. Git for Windows is recommended on native Windows so the Bash tool works. Without it, Claude Code falls back to PowerShell. On the Copilot side, the Windows-relevant feature is local models, covered below.

The benchmark: read it as vendor-reported​

GitHub says that on the Artificial Analysis Coding Agent Index, Fusion Max scored 60, within two points of Claude Code with Opus 5.5 Max. GitHub also claims about half the average API cost per task, about half the tokens and roughly 40% less time.

Some secondary coverage adds detail. XenoSpectrum reported that Fusion at Max in Copilot CLI scored 60 at an average task cost of $5.59, against $11.42 for Claude Code with Opus 5.5 Max. That fits the "about half" claim. The same outlet describes Artificial Analysis as an independent evaluator. The cost figures, though, were published alongside GitHub's own launch messaging.

A separate write-up noted what is still missing. Independent runs of Fusion High and Fusion Standard, which Artificial Analysis has not scored. The 60 applies to Max only. If your team plans to run Standard to save money, the headline number doesn't describe that configuration.

Several limits apply to any single index score:

• A two-point gap says nothing about security, test coverage, maintainability or how much review the output needs.
• The index measures a set of tasks, not your repository.
• A cheaper run that needs more human cleanup may not be cheaper overall.

Cost: don't compare the wrong numbers​

Anthropic lists Opus 5.5 API pricing at $4 per million input tokens and $20 per million output tokens. Cache reads cost $0.20 per million tokens. Fast mode costs $8 and $40 per million. Those are API rates, not a Claude Code subscription price.

Fusion has no separate fee. GitHub's documentation says you are billed for each model it uses, at that model's standard rate. High and Max can use more than one model per task, so they can consume more AI credits than Standard. GitHub is offering paid-plan users a 30% discount on the cost of models used in Fusion through November 30, 2026. Any savings you see before that date partly reflect the discount, and the post-discount price is not yet established.

GitHub says Fusion tries to keep the main conversation on one model so cached tokens keep paying off. Helper models, such as a reviewer, receive only the context they need.

Admin controls and policy limits​

This section matters most for enterprise IT. Per GitHub, Fusion only uses models enabled in your enterprise and organization policies. Enterprise administrators can see which models Fusion picks from and disable models for Fusion without disabling them for everyone. They can also set Fusion, at any effort level, as the default through Enterprise managed settings.

The documentation lists several exclusions:

• Models not included in your plan.
• Models blocked by administrator policy.
• Models excluded by data-residency or FedRAMP-compliant-model policies.
• Models excluded by policies restricting evaluation models.

If none of Fusion's candidate models is available to a user, Fusion doesn't appear in the model picker. "Fusion picks the best model" therefore really means it picks the best model your organization allows.

Local models on Windows (public preview)​

This is the Windows-specific part, and it isn't GA. GitHub's documentation says that on a Windows computer with the required specifications, you can install the MAI Code 1.1 Flash model from Copilot CLI, the Copilot app or VS Code. Fusion can then use it, but only from the Standard effort level. In Copilot CLI, a locally installed Qwen3.8 Flash Next, for example through Ollama, can also be used. That one works across Windows, macOS and Linux.

You must enable experimental features:

1. In the Copilot app, turn on Local model auto routing in the Experimental settings.
2. In Copilot CLI, start it with the --experimental option, or run /experimental on in an interactive session.

GitHub warns the preview is subject to change.

Practical guidance​

1. Start at Standard for routine work and move up when a task warrants it. GitHub describes High as suited to well-scoped but substantial work, such as a complex bug or a multi-file change.
2. Reserve Max for tasks that need the deepest reasoning, and expect higher credit use.
3. Review diffs before committing. GitHub warns that if Fusion discards a draft, file edits that draft already made in your workspace are not undone automatically.
4. Check your policies. Know which models your organization permits, since that sets the ceiling for what Fusion can do.
5. Benchmark on your own work. Run a few representative tasks through both tools. Record cost, wall-clock time, test results and human review time.
6. Hover over the effort label under a response to see which models were used. That is a simple way to audit routing.

Which should you choose?​

The evidence supports a bounded conclusion. Fusion's strength is that it removes the model-picking chore, runs inside Copilot surfaces many teams already use, and gives administrators policy controls. Claude Code's strength is an agent interface with configurable tools, permissions, model choice and optional subagents. The evidence doesn't show that either tool is universally more autonomous, produces better code or costs less across real projects.

The comparison also isn't strictly either/or. Anthropic's own Opus 5.5 announcement quotes GitHub saying that in its testing across Copilot CLI and VS Code, the model used among the fewest tokens and steps it measured. Claude models and Copilot are plainly entangled. The bigger shift is that the question is moving from "which model is smartest?" to "which system assigns, checks and bills the work most sensibly?"

Fusion is days old, its model pool will change, and independent numbers for its lower tiers don't exist yet. Treat the launch figures as a reason to test it. They are not a verdict.