• 8 min read

GitHub Copilot Fusion: Model Routing, Effort, Cost Per Task

tl;dr

Copilot Fusion Max costs $5.59 per task versus $11.42 for Claude Code with Opus 5.5 Max, 51% less on the Coding Agent Index. The savings come from doing less total model work, not from routing to cheaper tokens.

Featured image for "GitHub Copilot Fusion: Model Routing, Effort, Cost Per Task"

Artificial Analysis measured Fusion Max at $5.59 per task versus $11.42 for Claude Code with Opus 5.5 Max — approximately 51% less — while scoring just two points behind on the Coding Agent Index. That independent benchmark, published the same day GitHub made Copilot Fusion generally available on October 28, 2026, gives engineering leaders a concrete number to work with instead of marketing claims. But the billing model underneath that number deserves scrutiny: Fusion routes each prompt to one or more models at pass-through rates, meaning a single developer action can trigger multiple billable model calls. The headline savings come largely from doing less total model work — about half the tokens — not from routing to cheaper tokens. GitHub owns the model choice; you still own the unpredictable bill.

What Is Copilot Fusion and Why Does It Matter?

GitHub Copilot Fusion is a runtime model router and orchestrator, not a foundation model. When you select it in the model picker, you’re choosing a system that decides which models to call and how to chain them together for each prompt. It merges Project HydraFusion’s multi-model orchestration with Copilot’s existing auto model selection, and it’s now generally available across Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI, and JetBrains IDEs. The rollout is gradual, so some accounts won’t see it immediately — you’ll need to update your client first.

The shift matters because manual model selection has become a chore. GitHub’s own Octoverse data for September 2026 showed that 61% of Copilot users who picked models themselves used more than one, up from 50% four months earlier. Developers on paid plans used 29 distinct models in May and 47 by September, with no single model carrying more than 25% of requests. Fusion moves that decision to runtime, evaluating each task across reasoning, code generation, debugging, and tool use before selecting an execution pattern. Enterprise administrators can control which models Fusion may use and can set any effort level as the organization default through managed settings.

There’s no separate fee for Copilot Fusion — each model it calls is billed at that model’s standard rate in AI credits. Paid Copilot plans receive a 30% discount on model costs when using Fusion through November 30, 2026, per Apex Logic’s guide. That discount applies to Pro, Pro+, Max, Business, and Enterprise plans, but not to Free tiers. The pricing page confirms Copilot plan pricing at Free $0, Pro $10, Pro+ $39, and Max $100 per user per month, with AI credits priced at $0.01 each.

How Do the Three Effort Levels Work?

Fusion offers three effort levels: Standard, High, and Max. Standard prioritizes versatile models for everyday coding and is available on every Copilot plan including Free. High prioritizes capable models for challenging tasks and deeper reasoning. Max prioritizes the most capable models for the most demanding tasks and complex reasoning. Both High and Max require Copilot Pro+, Max, Business, or Enterprise — they’re not available on Pro or Free tiers.

For each prompt, Fusion picks one of three execution patterns. Single sends the task directly to one model — lowest latency and cost. Cascade lets an efficient model draft a solution, then a judge decides whether to accept it or escalate to a stronger model. Critique has one model draft a response while multiple models independently critique it in parallel, then the original model revises based on the combined feedback. Different prompts in the same session can use different patterns, and Fusion only adds model calls when a task warrants them. You can hover over the effort level beneath a response to see which models were actually used.

There’s also a fourth level, Fusion Fast, which is not user-selectable and only available in VS Code inline chat. The model pool currently includes Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra, and GPT-6 Sol, though GitHub says this will change as new models arrive. Administrators can disable specific models for Fusion without disabling them for other uses, giving granular control over the routing pool.

What Does Fusion Actually Cost Per Task?

The independent benchmark from Artificial Analysis puts Fusion Max at $5.59 per task on the Coding Agent Index v2.0, versus $11.42 for Claude Code with Opus 5.5 Max — about 51% less. Fusion used roughly 7.2 million tokens per task, approximately half of what Claude Code consumed. GitHub’s own figures claim Fusion Max used about half the average API cost per task, about half as many tokens, and about 40% less time per task versus the same Claude Code configuration. Microsoft CEO Satya Nadella cited up to 77% lower cost based on GitHub’s internal DeepSWE benchmark evaluation, a separate and higher figure than the Artificial Analysis average, according to VentureBeat.

Because billing is pass-through per model, a single task on High or Max can consume more AI credits than the same task on Standard if Fusion invokes multiple models through Cascade or Critique patterns. The 30% discount on model costs for paid plans through November 30, 2026 helps, but it’s temporary. For a concrete scenario: a 50-developer team on Copilot Pro+ running 100 Fusion Max tasks per developer per month would pay $1,950/month in subscriptions plus $27,950/month in model costs at the measured $5.59 per task, totaling $29,900/month before discounts. Applying the 30% paid-plan discount on model costs reduces model costs to $19,565 and brings the total to $21,515/month. That math assumes the benchmark rate holds for your workload — which it may not, since token consumption varies by task complexity and execution pattern.

GitHub Enterprise customers now get Copilot for every licensed user without a separate subscription, paying only for metered AI usage from the first request, per WebProNews. There’s no per-seat credit allowance; usage is metered against the enterprise’s AI budget. Code completion keeps working when the budget runs out, but Copilot Chat, code review, and cloud agents stop. This shift from seat-based to usage-based billing aligns with Fusion’s variable-cost model but makes forecasting harder.

How Does Fusion Compare to Claude Code and Other Tools?

Tool / ConfigurationCoding Agent Index ScoreCost Per TaskTokens Per TaskKey Tradeoff
Copilot Fusion Max60$5.59~7.2MNear-frontier quality at half cost; variable multi-model billing
Claude Code (Opus 5.5 Max)~62$11.42—Consistent single-model billing; higher per-task cost
Devin Fusion (Opus 5.5 Max + GPT-6 Luna High)62$8.00—Competitive score; higher cost than Fusion Max

Fusion led on Terminal-Bench 4.0 with 71 points, but scored 51 on FrontierCode — behind Claude Code with Opus 5.5 at 56 and Devin Fusion at 54. FrontierCode tests repository-change tasks, suggesting Fusion’s orchestration shines on self-contained coding problems but trails on multi-file, cross-repository work. The Artificial Analysis test covered only the Max effort level; Standard and High haven’t been independently benchmarked yet. GitHub’s documentation notes that Fusion chooses between Anthropic and OpenAI models, but the exact pool isn’t published and will evolve.

The cost advantage comes partly from doing less model work overall — about half the tokens — not purely from routing to cheaper models. That’s an important distinction: if your tasks routinely trigger Critique patterns with multiple parallel reviewers, token consumption could approach or exceed single-model calls on complex work. The pass-through billing means GitHub has no incentive to minimize model calls beyond what the orchestration logic dictates.

This routing approach mirrors what we’ve seen in LLM routing layers where the middleware sends each request to the best-priced model for the task, though Fusion keeps the routing inside the Copilot ecosystem rather than exposing it as a separate layer.

What Should Engineering Leaders Watch For?

The billing transparency gap is real. When an answer is slow, expensive, or incorrect, teams need to know whether the result came from one model, a cascade, or a critique pass involving several models. GitHub shows which models were used when you hover the effort label, but there’s no per-task cost breakdown in the UI yet. For organizations running hundreds of tasks daily, that opacity makes budget forecasting difficult. The 30% discount expires November 30, 2026 — after that, model costs revert to full rate.

Administrators should audit model policies before rolling out Fusion broadly. Since Fusion only uses models enabled in enterprise and organization model policies, you can exclude expensive frontier models from the routing pool to cap per-task costs. Setting Fusion Standard as the default for most users, with High/Max opt-in for specific teams, gives you a cost ceiling while still capturing routing benefits for routine work. The local-model routing preview (currently Windows-only via MAI Code 1.1 Flash through Windows ML) adds another variable: local inference doesn’t make sessions offline, since routing decisions still happen in the cloud.

Fusion is GitHub’s entry into that space, but it’s tied to the Copilot ecosystem and its credit-based billing. Teams already using GitHub Enterprise get the most seamless integration — Copilot is now included, metered from the first request.

How Should You Roll This Out?

Start with Fusion Standard on a pilot team for two weeks. Track credit consumption per task against your previous single-model baseline — you’ll need to export billing data from the GitHub admin console since per-task breakdowns aren’t in the IDE. Set model policies to exclude the most expensive models from the Fusion pool unless explicitly requested.

Code completion continues working when the budget exhausts, but Chat and cloud agents stop — plan accordingly for teams that rely heavily on those features. The 30% discount through November 30 is a good window to establish baseline costs before full-rate billing kicks in.

The real question isn’t whether Fusion saves money on benchmarks — it does, roughly 50% on the tasks Artificial Analysis tested. The question is whether your team’s actual workload maps to those benchmarks, and whether you’re comfortable with GitHub making model choices while you absorb the variance. If you want predictable per-task costs, pin a single model. If you want the router to optimize for you, Fusion Standard is the low-risk entry point. Just don’t treat the $5.59 figure as a guarantee — it’s a benchmark average, not a price list. For teams running dual-tool stacks, the hidden overage problem we’ve documented with agentic workloads applies here too — token-metered billing turns predictable costs into variable expenses that can spike unexpectedly.