GitHub Copilot Fusion vs. Claude Code: The Routing vs. Self-Selection Divide

GitHub recently made a rather provocative claim: Copilot Fusion Max scores 60 on the Artificial Analysis Coding Agent Index, only two points behind Claude Code, while the average API cost per task is roughly half. The numbers themselves are eye-catching, but reading a two-point gap as a straight-up "tie" misses a more fundamental question — Fusion isn't a model at all. It's a router.

Fusion Isn't a Model, It's an Orchestration Layer

GitHub's definition of Fusion is clear: for each prompt, it picks the model and the collaboration pattern between models on its own, and users never directly touch the underlying models. Three collaboration modes have been disclosed so far. Single-model mode, where one model handles the whole task from start to finish; Cascade mode, where an efficient model drafts first and a "judge" decides whether to accept the draft or escalate to a stronger model; and Critique mode, where other models review the draft and the original model revises accordingly.

The implication of this design is that Fusion's score of 60 isn't the result of any single model — it's the result of a scheduling strategy. It's closer to an engineering optimization of "use cheap models for most of the work and only bring in expensive models at key points" than to matching Claude Code on raw model capability. The claim of "within two points" compares an orchestration system against a specific product, and the dimensions aren't entirely equivalent.

What deserves credit is the cost-side performance. By the figures provided, Fusion Max achieves 60 while averaging about half the API cost per task of its competitor — a real difference when using coding agents at scale.

Artificial Analysis Coding Agent Index is a third-party benchmark specifically designed to evaluate the overall performance of coding agents. Unlike traditional code generation benchmarks (such as HumanEval) that only test single-turn function completion, it focuses more on an agent's end-to-end capabilities on real tasks: understanding requirements, multi-file editing, running tests, and iterative fixes. Scores typically combine task completion rate, code correctness, and efficiency, with a maximum of 100. The score therefore reflects the capability of an "agent system" rather than a "bare model," which also explains why a routing system can appear in the same table as a specific product — though note that details like task distribution, scoring weights, and whether human intervention is allowed can significantly affect score comparability.

Who Holds the Control

The product philosophies of the two are exact opposites. In Fusion, you only choose an "effort level" — standard, high, or max — and the system decides the model. Claude Code hands the choice back to the user: you specify Opus or Sonnet via /model, then separately set an effort level from low to max.

This isn't a minor detail. For developers who need predictable behavior and want to repeatedly tune for specific tasks, being able to specify the model means minimizing uncertainty; for users who don't want to study model differences and just want results, Fusion's automatic routing reduces the decision burden. The former is the mindset of a professional tool, the latter that of a managed service.

Model routing is a scheduling technique that dynamically selects the underlying model at inference time based on the input. Common strategies include: tiering by task difficulty (cheap small models for simple tasks, escalation to large models for complex ones), dispatching by domain expertise (code, math, and writing each playing to their strengths), and cascading — where a low-cost model attempts first and escalates when it fails or has insufficient confidence. The core value of routing is approximating the average quality of a single strong model with blended costs, but the trade-off is reduced behavioral predictability: the same prompt may yield different results depending on routing decisions. For developers, a routing system is a black box, making debugging and reproducing issues harder than with a fixed model.

The Hidden Costs of Billing Models

The billing structure directly affects long-term expenses. Fusion bills each model actually invoked at its standard rate, so the high and max tiers may consume more credits — the money saved by routing is partly offset at high-intensity tiers. The source material mentions that paid Copilot plans get a 30% discount on Fusion model costs until November 30, but this is a limited-time offer and not suitable as a long-term cost baseline.

Claude Code takes the subscription quota route, drawing from the plan's usage limits within a Claude plan. The cost boundary is clearer, but heavy use may hit the quota ceiling first. Neither model is inherently superior — it depends on usage intensity and preference for cost predictability.

API token-based billing vs. subscription quota system are two fundamentally different cost models. Token-based billing (used by Fusion) means each call is settled by multiplying input/output token counts by the corresponding model's unit price, with costs growing linearly with usage but with transparent, precisely calculable boundaries; high-intensity tiers have higher unit prices because they call more expensive models. The subscription quota system (used by Claude Code) trades a fixed prepaid monthly fee for a certain usage limit, after which you're rate-limited or downgraded — costs are predictable, but there's the "waste if underused, wall if overused" problem. When choosing, assess the variance of your usage intensity: teams with high fluctuation are better suited to pay-as-you-go, while teams with stable high intensity find subscriptions more economical.

An Operational Risk You Must Know About

The most easily overlooked yet most important point in the source material: if Fusion discards a draft, the file modifications that draft has already produced are not automatically rolled back. This means that while automatic routing is trial-and-error in the background, half-finished changes may be left in the workspace. Manual review before committing is a necessary step, especially in multi-turn collaboration modes like Cascade and Critique. This kind of "side effect of orchestration" is a cost item easily missed when evaluating agent tools.

How to Choose

The two-point gap claim holds, but it measures the performance of a routing system on a specific benchmark and doesn't mean equivalent capability. For scenarios requiring fine-grained control over models and behavior, Claude Code's explicit selection is more suitable; for those hoping to outsource model selection while keeping average costs down, Fusion's automatic orchestration is appealing. What really deserves attention is the actual bill after the discount expires, and the file changes left behind by discarded drafts.

(This article is based on a retelling from a single video source; GitHub's benchmark data and discount details should be verified against official documentation.)

One-line Summary

GitHub Fusion Max approaches Claude Code's score through routing orchestration, but control and cost structures are entirely different.

Paragraph Summary

GitHub claims Copilot Fusion Max scores 60 on the coding agent benchmark, just two points behind Claude Code, at about half the API cost per task. But Fusion is essentially a router, not a model, automatically orchestrating underlying models through single-model, Cascade, and Critique collaboration modes, with users only choosing an effort tier; Claude Code leaves model selection to the user. The product philosophies are opposites: the former is a managed-service approach that reduces decision burden; the latter is a professional-tool approach emphasizing predictability. On billing, Fusion charges each model's standard rate, and high-intensity tiers may offset routing savings; Claude Code draws from a subscription quota with clear boundaries but possible ceilings. Additionally, when Fusion discards a draft, file modifications aren't rolled back, requiring manual checks before committing. The two-point gap holds, but doesn't mean equivalent capability.