Report GitHub Copilot Fusion Matches Opus 5.5 Closely at Half the Task Cost

GitHub Copilot Fusion Max scored 60 on the Artificial Analysis Coding Agent Index v2.0, finishing only two points behind Claude Code with Opus 5.5 Max while using approximately half the tokens and costing about 51% less per benchmark task.

The results, published on 28 October 2026, provide independent evidence that coordinating different AI models can offer a useful balance between coding performance and model usage. However, the findings do not establish that every software development task will become cheaper or faster.

Copilot Fusion is a model routing and orchestration system, not a new foundation model. It selects models according to the requirements of a coding task and can coordinate several models when additional reasoning or review is needed.

We examined the independent benchmark, the product announcement and the available technical information to understand what Fusion does, where it performed well and what developers should check before adopting it.

Key findings

• 60 on the Coding Agent Index: Fusion Max finished two points behind Claude Code with Opus 5.5 Max in the independent evaluation.

• Approximately 51% lower task cost: Fusion required about half the average API expenditure of the compared Claude Code configuration.

• 7.2 million tokens per task: Fusion used approximately half the tokens of Claude Code with Opus 5.5 Max.

• 71 on Terminal-Bench 4.0: Fusion led the systems discussed in the independent benchmark report on this component.

• Approximately 40% less time: GitHub reported this reduction in task completion time, but the independent article did not provide the underlying timing data.

What GitHub Copilot Fusion is

GitHub Copilot Fusion is an AI model orchestration system for software development. It decides which available models should work on a request and how those models should cooperate.

Developers using AI coding assistants often choose between models that have different strengths. Some handle straightforward code generation quickly, while others are better suited to difficult debugging, planning or repository-wide changes.

Manually choosing a model can work, but it also requires developers to understand the differences between available options and remember to change models when their tasks change.

Fusion attempts to automate this process.

Instead of selecting an individual foundation model, the developer selects Copilot Fusion and an effort level. The system then decides whether to use a single model or coordinate several models to complete the task.

Fusion combines technology from GitHub's earlier Project HydraFusion research preview with its automatic model selection system.

The model pool identified in the independent evaluation includes models from Anthropic and OpenAI, such as Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra and GPT-6 Sol.

The exact model selection can vary by request and by the policies configured for an organisation.

How GitHub Copilot Fusion routes coding tasks

Fusion evaluates the requirements of a request, including reasoning, code generation, debugging and tool use.

It can then choose between three execution patterns.

Single model execution

The Single pattern sends a task directly to one model.

This approach can be suitable when the system determines that a single model can complete the request without additional review or escalation.

For example, a straightforward code explanation may not require several models working together.

Cascade execution

The Cascade pattern begins with an efficient model and checks whether its response is acceptable.

If the result does not meet the required standard, the system can escalate the task to a more capable model.

This approach attempts to avoid using a more resource-intensive model for every request while retaining a path for difficult tasks.

However, escalation can introduce additional model calls. The benefit depends on how often the initial model succeeds and how much work is repeated.

Critique execution

The Critique pattern uses one model to produce an initial response and another model to review it.

The original model can then revise its answer using the review feedback.

This may help with tasks where an additional check can identify weaknesses in an initial implementation.

It does not guarantee that the final code will be correct. Models can overlook the same problems, and human review remains necessary for important changes.

GitHub Copilot Fusion benchmark results

The independent evaluation tested Copilot Fusion Max through GitHub Copilot CLI using the Coding Agent Index v2.0.

The index combines three coding evaluations with equal weighting. Its results measure performance under specific benchmark conditions rather than every possible software development task.

The composite score suggests that Fusion Max approached the overall performance of the compared Claude Code configuration while consuming fewer model resources.

However, the component results show that the advantage was not uniform.

Fusion performed particularly well on Terminal-Bench 4.0, but it scored below Claude Code with Opus 5.5 Max on FrontierCode.

Developers should therefore avoid interpreting the overall score as evidence that Fusion is equally effective across debugging, repository modification and question-answering tasks.

Why Fusion used fewer tokens

One of the most important findings is the difference in token consumption.

The independent evaluation reported 7.2 million tokens per task for Copilot Fusion, approximately half the token usage of Claude Code with Opus 5.5 Max.

Token consumption matters because model providers generally account for the amount of information processed and generated during requests.

A coding agent may consume tokens while reading repository files, planning changes, executing tools, reviewing results and correcting mistakes.

Reducing unnecessary model work can therefore affect the resources required to complete a task.

Fusion's routing and orchestration design offers a possible explanation for its efficiency. It can assign simpler work to suitable models and reserve more demanding processing for situations where it is needed.

However, the benchmark does not isolate the contribution of every routing decision. The observed reduction should not be attributed to a particular execution pattern without additional evidence.

Token efficiency also does not guarantee better software quality. An agent can use fewer tokens and still produce code that requires substantial human correction.

What the cost comparison actually means

The independent benchmark found that Fusion Max required approximately 51% less average API cost per task than Claude Code with Opus 5.5 Max.

This is a task-level comparison between specific configurations.

It does not mean every developer will reduce their Copilot spending by the same percentage.

Real applications involve different tasks, repository sizes, model usage patterns and review requirements.

Fusion also bills according to the underlying models used during a request. When several models participate, their usage contributes to the overall charge.

GitHub announced a temporary 30% discount on model costs for users on paid Copilot plans using Fusion. This promotion is separate from the independent benchmark comparison.

Organisations should not combine the promotional discount with the benchmark reduction to estimate guaranteed savings.

The total cost of software development also includes human review, testing, debugging, security checks and deployment work.

A lower model cost per benchmark task may be valuable, but the more useful measure is the cost of producing an accepted, working change.

Fusion Standard, High and Max explained

Copilot Fusion provides three effort levels that developers can select according to task complexity.

Fusion Standard

Standard prioritises versatile models for everyday coding work.

It may be appropriate for routine explanations, smaller edits and development tasks that do not require extensive reasoning.

Fusion High

High prioritises more capable models for challenging work and deeper reasoning.

Developers may consider it for debugging or implementation tasks that require more investigation.

Fusion Max

Max prioritises the most capable models for demanding tasks and complex reasoning.

This is the configuration used in the independent Coding Agent Index evaluation.

The published benchmark results should not automatically be applied to Standard or High. Different effort levels may use different model combinations and produce different performance, latency and usage patterns.

We recommend testing the effort levels separately before choosing a default for a development team.

How Fusion compares with Claude Code

The headline comparison concerns Copilot Fusion Max and Claude Code running Claude Opus 5.5 at its Max setting.

Both configurations are designed to handle software development tasks involving reasoning, code changes and tool use.

Fusion differs because it can coordinate models from several providers instead of relying on a single selected foundation model throughout the task.

In the published evaluation, Claude Code with Opus 5.5 Max maintained a small lead in the overall Coding Agent Index and a stronger result on FrontierCode.

Fusion achieved lower measured task costs and token consumption, while performing better on Terminal-Bench 4.0.

These differences suggest that model orchestration can be competitive with a strong individual-model configuration.

They do not establish a universal winner.

Teams working on complex repository changes may value different capabilities from teams that primarily use agents for terminal operations or code explanations.

Both products should be assessed against the actual work developers need to complete.

Availability and supported development tools

GitHub announced Copilot Fusion as generally available on 28 October 2026.

It is available across Copilot plans in Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI and JetBrains IDEs.

Support for additional clients is planned.

Developers can update a supported client, open the model picker, select Copilot Fusion and choose the preferred effort level.

Users who previously enabled certain automatic model selection or HydraFusion preview settings may find their configuration transferred to the corresponding Fusion effort level.

Availability in a supported client does not guarantee that every model will be permitted in an enterprise environment.

Administrators can control which models Fusion is allowed to use and can configure default settings for managed users.

Enterprise controls and security considerations

Dynamic model routing introduces an important governance question for organisations handling sensitive source code.

When an orchestration system selects models automatically, developers may not know in advance which provider will process a particular request.

GitHub states that Fusion respects enterprise and organisation model policies.

Administrators can review eligible models, control their availability and disable individual models for Fusion without necessarily removing those models from other Copilot workflows.

This helps organisations restrict routing according to their internal policies.

However, model availability controls are only part of the security picture.

Teams should also review how source code is handled, which tools agents can access and whether generated changes require approval.

Automated code generation can introduce bugs, insecure dependencies or incorrect assumptions even when the model performs well on coding benchmarks.

For production repositories, developers should continue using tests, code review and established deployment controls.

Limitations of the independent benchmark

The Coding Agent Index provides useful comparative evidence, but its results reflect selected tasks and evaluation methods.

The index weights three benchmark components equally. A particular organisation may care much more about one type of task than another.

The published Fusion evaluation also tested the Max effort level through GitHub Copilot CLI. It does not establish identical results across every supported client or effort level.

Task costs depend on the model combinations used during testing. Changes to routing policies, model availability or underlying model behaviour could affect future results.

GitHub's claim of approximately 40% less time per task was not accompanied by independently published completion-time measurements in the benchmark article.

The cost and token findings have independent support, but the timing claim should remain identified as GitHub-reported.

Finally, benchmark completion does not capture every part of production software delivery.

Teams may still spend time reviewing code, investigating failures, resolving integration issues and confirming that changes meet business requirements.

What this means for you

We recommend evaluating Copilot Fusion against your existing AI coding workflow rather than choosing it solely because of its benchmark position.

Use the following checklist before adopting it across a development team.

1. Identify common tasks. Separate routine coding, debugging, repository changes, code review and documentation work.

2. Establish a baseline. Measure task completion, model usage, developer review time and overall workflow duration using your current assistant.

3. Compare effort levels. Test Fusion Standard, High and Max on representative assignments.

4. Evaluate accepted changes. Measure whether generated code passes tests and meets the requested requirements.

5. Track token consumption. Compare model usage across completed tasks rather than individual requests alone.

6. Review total operating costs. Include retries, additional model calls, human corrections and integration work.

7. Check model policies. Confirm which providers and models are permitted to process company code.

8. Test complex repositories. Include tasks that require understanding dependencies and changing several related files.

9. Review latency. Measure the time required to produce an acceptable result, including any escalation or critique stages.

10. Monitor results after deployment. Reassess performance as routing behaviour, supported models and product settings change.

Fusion is particularly relevant to developers who regularly switch between models or want an assistant to manage those choices automatically.

It may also interest teams trying to control AI usage without restricting every developer to the same foundation model.

However, organisations with strict provider requirements, established single-model workflows or specialised coding tasks should test the routing behaviour carefully.

Conclusion

GitHub Copilot Fusion introduces a different approach to AI-assisted development by treating model selection and coordination as part of the coding workflow.

The independent benchmark found that Fusion Max approached Claude Code with Opus 5.5 Max in overall coding performance while using approximately half the tokens and requiring about half the average API cost per task.

However, Fusion did not lead every benchmark component, and GitHub's reported completion-time improvement lacks the same published independent detail.

We recommend testing Fusion on representative development tasks and comparing accepted code quality, token consumption, review effort and total workflow costs. The benchmark provides a reason to investigate model orchestration, but production results should determine whether it is the right choice.