GitHub Copilot Fusion became generally available on 28 October 2026. Instead of manually choosing an AI model for every coding task, developers can select Fusion and an effort level; GitHub then routes work to an eligible model or orchestrates multiple models. Fusion supports Standard, High and Max effort settings and is offered across VS Code, JetBrains, the Copilot app and CLI. Billing still depends on the actual models used.
News date: 28 October 2026. Verified: 29 October 2026. Primary reference: GitHub's Copilot Fusion release notes. Performance figures here are GitHub-reported results from specified tests; RKWS has not separately benchmarked the product or billed workloads.
What is GitHub Copilot Fusion?
GitHub Copilot Fusion is a model-routing and orchestration feature for GitHub Copilot. A coding assistant can be good at one task and less efficient at another; Fusion aims to select the most appropriate available model and, when beneficial, coordinate more than one model during a request.
It combines concepts from GitHub's Project HydraFusion research and automatic model selection. Developers still describe the software change they need, but do not have to select a particular language model before each step.
This does not mean the product can select from every AI model on the market. In managed environments, the available set is governed by Copilot-supported models and the organization's policies.
What changed in the Copilot Fusion general release?
GitHub moved model routing and orchestration into a generally available Copilot experience and introduced clearly differentiated effort levels. It also described administrative controls, rate-based billing for underlying models and client support across multiple development tools.
| Element | October 28 launch | Why it matters |
|---|---|---|
| General availability | Copilot Fusion GA | Broad availability, subject to client and plan policies |
| Effort levels | Standard, High and Max | Developer chooses task ambition rather than a single model |
| Execution | Single, Cascade or Critique patterns | Tasks may use one or multiple models |
| Billing | Based on each underlying model actually used | Not a fixed price per Fusion request |
| Admin controls | Model policies and default setting controls | Organization governs allowed model choices |
| Local models | Separate experimental preview | Not every GA Fusion user gets local routing by default |
How do Copilot Fusion Standard, High and Max differ?
GitHub describes three effort levels that trade efficiency against the resources devoted to complex work. The developer selects the level; Fusion decides which eligible model or combination to employ.
| Level | Intended task | Example to evaluate |
|---|---|---|
| Fusion Standard | Versatile, day-to-day coding | Small refactors, documentation and routine fixes |
| Fusion High | Challenging problems and deeper reasoning | Debugging a test failure across several files |
| Fusion Max | Most demanding coding and complex reasoning | Understanding a difficult architectural defect |
The highest setting is not automatically the best business choice. Evaluate whether the increase in task success or review quality justifies any added resource consumption or cost.
What are Single, Cascade and Critique execution patterns?
GitHub's key innovation is that orchestration can take several shapes. Each pattern has benefits and drawbacks; the system chooses according to the task and allowed models.
Single: one model handles the task
Single routes a request to one model, which can use permitted tools and produce the result. It is suitable when a direct answer or modest code change does not warrant further model coordination.
Cascade: a first answer is checked and potentially escalated
Cascade asks an efficient model to draft a solution. A quality check then decides whether to accept it or escalate to a stronger model. The goal is to use expensive capacity only when necessary, but the checking process can still miss errors.
Critique: a second model reviews the first
Critique has one model draft a result and another review it. The first model may revise the answer based on feedback. This can catch issues, but a second model is not an independent proof of correctness; its critique can also be mistaken.
In all three patterns, tests, static analysis, code review and release approval remain necessary. See our AI coding agent development guide.
What performance evidence has GitHub shared?
GitHub reports that Fusion Max scored 60 on the Artificial Analysis Coding Agent Index, within two points of Claude Code with Opus 5.5 Max in the stated comparison. GitHub also reports about half the average API cost per task, approximately half the tokens and roughly 40% less time per task in that evaluation.
These are benchmark observations, not guaranteed customer savings. Models, task sets, scoring criteria and rates can evolve. A single number does not establish how much an Indian software agency will save while maintaining a legacy WordPress project or operating a production web app.
For a real comparison, measure accepted pull requests, regression failures, developer corrections and full task costs on your own repository.
How does GitHub Copilot Fusion pricing work?
GitHub says a Fusion request is billed for the underlying model or models it actually uses, at each model's standard rate. That matters because orchestration may involve more than one model. GitHub has also announced a temporary 30% discount on model costs for paid Copilot plans when using Fusion.
Do not interpret this as a permanent 30% discount on every GitHub service, a fixed unlimited monthly inference allowance, or a guaranteed 30% reduction in a business's total software costs.
| Question | What GitHub says | What teams should do |
|---|---|---|
| One price per Fusion request? | No: costs reflect the underlying models | Observe usage for real tasks |
| Temporary promotion? | 30% model-cost discount for paid plans | Check promotion expiry and eligibility |
| Max always economical? | No universal claim | Measure accepted results against expense |
| Enterprise model restrictions? | Respects enabled organization models | Review policies before rollout |
Is Copilot Fusion available in VS Code, JetBrains and CLI?
GitHub lists support on all Copilot plans in Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI and JetBrains IDEs. The basic starting flow is to update the relevant client, open the model picker, select Copilot Fusion and choose an effort level.
- Update your supported Copilot client.
- Verify the Copilot plan and organization policy allows the feature.
- Open the model selection interface and choose Copilot Fusion.
- Select Standard, High or Max for the intended coding request.
- Review generated changes and run your normal tests before merging.
- Inspect usage and adjust effort based on measured task quality.
For enterprise customers, administrators can enable or restrict the models Fusion is allowed to use and can set a default effort configuration under managed policies.
What about GitHub Copilot Fusion using local AI models?
GitHub made a separate announcement on 28 October 2026 about intelligent routing to local, on-device models. That capability is an opt-in experimental preview, not the default GA behavior of cloud Copilot Fusion.
For supported Windows hardware, the announcement describes managed setup of MAI Code 1.1 Flash through the Windows ML provider. Other paths depend on model, device and client support. See the local-model preview announcement for current requirements before advising that any laptop can run model routing offline.
Local execution can reduce some network dependence, but it does not automatically guarantee privacy, suitable hardware performance or identical quality to a cloud model. Sensitive code policies still apply.
How should an Indian development agency evaluate Fusion?
A useful pilot should cover the tasks the team actually performs. For example, select a small bug fix, a multi-file refactor and a challenging debugging issue. Compare Fusion against the team's current workflow under the same source code, testing rules and review criteria.
- Choose representative tasks with known acceptance tests.
- Run Standard first for everyday work and compare High or Max only when needed.
- Measure wall-clock completion time and developer review time.
- Track actual model usage and cost for accepted changes.
- Test false fixes, regressions and security-sensitive code paths.
- Record any failed or incomplete tasks, not just successful demonstrations.
- Scale only after the team's productivity and code quality improve.
Use our AI agent observability framework for operational metrics and the agent security checklist for tool access boundaries.
Does multi-model orchestration replace human code review?
No. A multi-model workflow may improve confidence or efficiency, but models can agree on the same incorrect assumption. A reviewer still needs to assess whether the change meets the business requirement, preserves security and behaves correctly with the application's other components.
Teams should also evaluate repository permission scopes, secret handling, third-party integrations and organizational policies. Our MCP versus API explainer covers how tool connections fit into agent architecture.
Frequently asked questions about Copilot Fusion
Is GitHub Copilot Fusion generally available?
Yes. GitHub announced general availability on 28 October 2026.
What are its three effort levels?
Standard for everyday work, High for challenging tasks and Max for demanding reasoning and coding.
Does Fusion use multiple models on every request?
Not necessarily. Its Single pattern uses one model; Cascade and Critique may involve additional models.
What does Copilot Fusion cost?
GitHub bills by the underlying models used, with a limited-time model-cost discount for paid plans.
Can Fusion run local models?
GitHub has announced opt-in local model routing in experimental preview for supported clients and devices. It is not the same as general availability of every local-model option.
Final takeaway: test outcomes, not model names
Copilot Fusion moves model selection toward automatic routing and controlled orchestration. For developers, this may reduce unnecessary model switching. The business result still depends on good requirements, passing tests, accountable reviews and total cost. Contact RKWS for assistance planning AI-enabled development workflows.
Primary sources: GitHub Copilot Fusion GA, 28 October 2026; local-model routing preview; JetBrains IDE rollout details.
Frequently asked questions
What is GitHub Copilot Fusion?
GitHub Copilot Fusion is a generally available system, launched on 28 October 2026, that selects and orchestrates one or more eligible AI models for coding tasks according to the effort level chosen by the user.
What are Copilot Fusion Standard, High and Max?
They are effort levels: Standard for everyday work, High for challenging tasks and Max for demanding reasoning and coding problems.
How does GitHub Copilot Fusion charge users?
GitHub says each underlying model it uses is billed at that model's standard rate. Paid plans receive a temporary 30% discount on model costs when using Fusion, subject to the promotion terms.
Does Copilot Fusion support local models?
GitHub separately announced opt-in local-model routing as an experimental preview for supported devices and clients on 28 October 2026; that capability is not the same as the generally available cloud routing experience.
Is GitHub Copilot Fusion available in VS Code and JetBrains?
GitHub says Fusion is available on all Copilot plans in VS Code, the Copilot app, Copilot CLI and JetBrains IDEs; users should update their client and check organization policies.
