GitHub Copilot Fusion Explained: How It Works, What It Costs, and What to Test

GitHub has made Copilot Fusion generally available. Instead of requiring developers to manually pick a specific model for every coding prompt, you select Copilot Fusion in your client's model picker alongside an effort level. Copilot then dynamically decides which models to invoke and how they coordinate to complete the task (GitHub changelog).

The short answer to the big question: Copilot Fusion unquestionably removes the repetitive friction of manually switching models. Whether it lowers your coding bill is far less straightforward. While an independent benchmark run found a substantially lower average cost per task for Fusion Max compared to Claude Code, that finding reflects synthetic benchmark tasks evaluated at standard API rates—not a guarantee for your monthly subscription or credit usage. Real-world costs depend on your chosen effort level, your Copilot plan, and the nature of your codebase.

About this article: This is an independent news explainer based on GitHub's official documentation and independently published third-party benchmark data. TechAffiliate has not run personal hands-on tests of Copilot Fusion. Claims attributed to "GitHub says" represent vendor statements.

What launched

GitHub's official documentation defines Copilot Fusion as a runtime model router and orchestrator. For each individual prompt, Fusion evaluates task complexity, context size, and necessary tools, selects the most suitable underlying models, chooses an execution pattern, and returns a single unified response.

Rather than locking your session into a single static model, you are choosing an orchestration system that can route different prompts to different models within the very same coding session.

Copilot Fusion is currently supported across:

• Visual Studio Code
• GitHub Copilot desktop app
• GitHub Copilot CLI
• JetBrains IDEs

GitHub notes that support for additional clients is coming soon.

The three execution patterns

For every prompt submitted, Fusion chooses one of three underlying execution patterns:

GitHub explains that Cascade and Critique introduce additional latency because they involve intermediate review calls. Fusion reserves these multi-model patterns for tasks whose complexity warrants the extra evaluation steps. Developers only see the final response, as intermediate drafts may be modified or discarded during orchestration.

Standard, High, and Max: Effort levels explained

Fusion provides three user-selectable effort levels that determine how aggressively it orchestrates models:

A fourth level, Fusion Fast, is not user-selectable; it operates automatically in Visual Studio Code inline chat for rapid, low-latency completions.

Standard effort is accessible to all Copilot users, including those on Free, Student, and Pro plans. In contrast, the deeper multi-model orchestration tiers (High and Max) are restricted to Pro+, Max, Business, and Enterprise plans. Developers planning their workflows around multi-agent critiques should verify current plan entitlements in GitHub's Copilot Fusion documentation.

Is Copilot Fusion actually cheaper?

To evaluate cost claims, developers must distinguish between synthetic benchmark results and practical monthly invoices.

What GitHub reports: According to GitHub, Fusion Max achieved a composite score of 60 on the Artificial Analysis Coding Agent Index—within two points of Claude Code running Opus 5.5 Max—while consuming approximately half the average API cost per task, using roughly half the tokens, and finishing tasks in about 40% less wall-clock time.

What the benchmark publisher reports: Artificial Analysis published an independent benchmark report after running Fusion Max through the Copilot CLI on its Coding Agent Index v2.0. The independent analysis verified significant efficiency gains: an estimated average cost of $5.59 per task for Fusion Max compared to $11.42 for Claude Code with Opus 5.5 (max), consuming roughly 7.2 million tokens per task (about 50% of Claude Code's consumption).

However, Artificial Analysis reported mixed results across individual benchmark components:

• Terminal-Bench 4.0: Fusion Max led the index with a score of 71.
• FrontierCode: Fusion Max placed third with a score of 51, trailing Claude Code at 56.
• SWE-Atlas-QnA-AA: Fusion Max scored 57.

Crucial caveats developers must keep in mind:

• Benchmark scope was Max-only: The independent benchmark evaluated only Fusion Max. No independent benchmark figures exist for Standard or High.
• Time savings attribution: The claim of "40% less time" is reported exclusively by GitHub; the Artificial Analysis publication did not include wall-clock task completion metrics.
• API rates do not equal subscription bills: Benchmark figures reflect API token pricing calculations. Copilot users are billed in plan-level AI credits or flat-rate quotas, meaning lower API token costs may not directly shrink an individual developer's bill.
• Synthetic benchmarks do not reflect private codebases: A benchmark index tests specific synthetic suites. It does not predict how Fusion handles proprietary frameworks, internal libraries, domain-specific APIs, or idiosyncratic coding styles.

High benchmark scores for Fusion Max demonstrate impressive multi-model efficiency on standardized suites, but they do not guarantee superior code quality, accelerated delivery, or reduced costs for every development team.

How billing works

GitHub's official billing terms clarify how Fusion usage is charged:

• No separate platform fee: There is no standalone subscription surcharge for enabling Copilot Fusion.
• Billed at individual model rates: You pay for each model Fusion invokes at that specific model's standard credit rate.
• Multi-model usage consumes more credits: Because High and Max levels may invoke secondary judge or critique models, a single complex prompt can consume more AI credits than a prompt run under Standard.
• Limited-time 30% model-cost discount: Paid Copilot subscribers receive a 30% discount on model costs when using Copilot Fusion through November 30, 2026 (as documented in GitHub's official documentation). Developers should confirm whether this promotional rate remains active when planning ongoing budgets.
• Conversation affinity: Where possible, Fusion attempts to retain your primary session on the same model to maximize context cache hits and avoid redundant prompt-processing charges.

The underlying model pool is dynamic and not permanently fixed. GitHub states that the catalog shifts over time. In its benchmark tests, Artificial Analysis observed models including Anthropic Claude Opus 5.5, Claude Sonnet 5.5, OpenAI GPT-6 Astra, and OpenAI GPT-6 Sol participating in routing decisions. Developers can compare these underlying options in our Gemini 4 Argon vs GPT-6 Astra vs Claude Opus 5.5 comparison.

Documented limits and cautions

• Discarded drafts can leave uncommitted workspace edits: When Fusion tests a draft that a secondary critique model subsequently rejects, intermediate file edits made by that draft are not guaranteed to revert automatically. Always inspect your Git diff before staging or committing changes. For broader context on automated tool security, see our guide on AI Agent Security Risks in 2026.
• Subagents are not initiated: Fusion is a model orchestrator, not an autonomous subagent manager. It operates within the single prompt-response loop.
• Conservative context window: Fusion displays a conservative context limit derived from the smallest window among the models in its active routing pool.
• Enterprise admin policies apply: Fusion strictly respects organizational and enterprise model policies. If an organization restricts specific third-party models, Fusion adjusts its routing pool accordingly; if all candidate models are restricted, Fusion is hidden from the picker.
• Dynamic routing evolution: Routing heuristics, threshold criteria, and underlying model versions may update without advance notification.

Local-model routing is a separate experimental preview

Alongside Fusion's general availability, GitHub launched local model routing as a separate preview. This capability is not part of Fusion's standard general availability.

In this preview, Fusion Standard can route tasks between supported on-device local models and cloud endpoints:

• A managed setup for Microsoft MAI Code 1.1 Flash is available on Windows.
• The Copilot CLI supports manually configured local models across Windows, macOS, and Linux.

GitHub explicitly clarifies that running local models does not turn Copilot into an offline tool: routing decisions are still evaluated by GitHub's cloud infrastructure. Furthermore, local models may not share identical content filtering or safety guardrails with cloud foundation models.

Practical takeaways: Who should use it?

Copilot Fusion is well-suited for developers who:

• Frequently switch between lightweight and frontier models throughout the day.
• Forget to downgrade to cheaper models for routine tasks like unit test boilerplate or regex generation.
• Manage engineering teams and want a standardized default that optimizes token expenditure automatically.

Copilot Fusion may be less suitable for developers who:

• Rely strictly on deterministic behavior from a specific model architecture they know intimately.
• Require absolute auditability of which model touched each line of sensitive code.
• Are sensitive to unpredictable credit consumption caused by multi-model critique passes on High or Max.

How to test Copilot Fusion on your own code

Because benchmarks cannot predict private repository performance, developers should conduct a structured, low-risk pilot on non-critical code:

For each task, compare Fusion Standard and High/Max against your team's usual default model. Record wall-clock turnaround, credit consumption, test pass rates, manual rework required, and any leftover diff artifacts. Testing before the November 30, 2026 promotional deadline allows teams to gauge efficiency before full credit pricing applies.

Frequently asked questions

Is GitHub Copilot Fusion generally available?

Yes. GitHub announced general availability on October 28, 2026, across Visual Studio Code, the GitHub Copilot desktop app, Copilot CLI, and JetBrains IDEs.

Does Copilot Fusion cost extra?

There is no separate platform fee for Fusion. You pay for the models invoked at their standard rates in Copilot AI credits. Paid plans receive a 30% discount on model costs through November 30, 2026.

Does Fusion always run multiple models?

No. Under the Single pattern, it uses one model. Multi-model Cascade and Critique patterns are reserved for complex tasks under High and Max settings.

Is Fusion Max guaranteed to outperform Claude Code?

No. On the Artificial Analysis Coding Agent Index v2.0, Fusion Max scored within two points of Claude Code overall and won on Terminal-Bench 4.0, but trailed Claude Code on FrontierCode. Performance depends on the specific programming problem.

Can I manually designate which model Fusion selects?

No. You select the effort level (Standard, High, or Max). Fusion's orchestrator selects the models. GitHub's documentation notes that developers can hover over the effort indicator after completion to inspect which models handled the prompt.

Bottom line

Copilot Fusion represents a sensible evolution in developer tooling: delegating model selection to an automated runtime orchestrator. Independent testing confirms that Fusion Max delivers substantial cost and token savings at API rates on standardized benchmarks. However, those gains have not been demonstrated across Standard or High tiers, nor do they guarantee lower bills for every private codebase. Teams should test Fusion on non-critical workflows, monitor credit consumption carefully, and inspect code diffs before committing.

Sources and further reading

• GitHub Changelog: Route and orchestrate models with GitHub Copilot Fusion (Oct 28, 2026) — Official
• GitHub Docs: About GitHub Copilot Fusion — Official documentation and plan matrix
• GitHub Changelog: Copilot Fusion supports selection of local models (Oct 28, 2026) — Official preview details
• Artificial Analysis: GitHub Copilot Fusion orchestrates Anthropic and OpenAI models (Oct 28, 2026) — Independent benchmark report