GitHub has stopped asking developers to pick a model for every coding task. On October 28, during GitHub Universe 2026, it made GitHub Copilot Fusion generally available. Fusion looks at each request and chooses the models and the amount of reasoning to apply.
The same announcement covered a redesigned Copilot app, a multi-repository agent feature called Copilot Projects, and a heavier tier of AI code review. This first part explains what shipped, how Fusion makes its choices, and who should enable it first. Billing, caveats and a comparison with rival tools follow.
Key Takeaways
- Fusion is generally available on all Copilot plans in VS Code, the Copilot app, Copilot CLI and JetBrains IDEs, with more clients “coming soon” (GitHub changelog).
- For each request, Fusion picks an execution pattern (single, cascade or critique), a reasoning level and the models that run it.
- Three effort tiers, Standard, High and Max, set how capable the models Fusion prefers will be.
- Administrators decide which models Fusion may use and whether it is the default.
- The performance and cost claims come from GitHub, plus Artificial Analysis figures that GitHub cites. Test on your own repositories before changing team defaults.
Table of Contents
- What GitHub shipped at GitHub Universe 2026
- How GitHub Copilot Fusion decides which model to use
- Who should switch GitHub Copilot Fusion on
- What GitHub Copilot Fusion means for AI credit billing
- Copilot Projects and the review bottleneck
- Caveats before you roll it out
- GitHub Copilot Fusion vs Claude Code and Codex
- Frequently Asked Questions
- Conclusion
What GitHub shipped at GitHub Universe 2026
The headline is Fusion, but it arrived alongside several other changes:
- Copilot Projects: a public-preview feature in the redesigned GitHub Copilot app that runs agents across repositories.
- Copilot code review Max: a public-preview effort level that uses several independent review agents.
- Enterprise access: GitHub Enterprise customers can now use every Copilot feature without a separate Copilot subscription, paying only for the AI credits they use (Technology.org).
Fusion has a short history. Its precursor, Project HydraFusion, started as a research preview in Copilot CLI on September 4, reached VS Code and the Copilot app on September 30, and became Fusion on October 28. According to a developer write-up, the product combines multi-model orchestration with Copilot’s Auto model selection.
The Copilot app is available on all Copilot plans. In Projects, you describe a goal, add context such as repositories, design mocks or Slack threads, and choose models and tools. Copilot then runs as many agents as the job needs and returns results such as pull requests for review (GitHub changelog).
How GitHub Copilot Fusion decides which model to use
GitHub’s Fusion documentation describes three decisions made per request: an execution pattern, a reasoning-effort level and the models that carry it out. Real-time system health and availability also factor in. Versatile models take straightforward work, and stronger-reasoning models take harder problems. This is the core of GitHub Copilot model routing.
Three execution patterns
- Single: one model handles the task.
- Cascade: an efficient model drafts, then a judge decides whether a stronger model should take over.
- Critique: a draft goes to several models for independent review, and the original model revises using the feedback.
The pattern is not locked for a session. A follow-up prompt can trigger a different one, as Cybersecurity News and the docs both note.
The trade-off is time. Cascade and critique add model calls for review, so they run slower than a single-model pass. Fusion tries to keep the main conversation on the same model where possible, to preserve cached tokens.
The three effort tiers
The Copilot app docs list the tiers as follows:
- Standard: prioritizes versatile models for everyday coding.
- High: prioritizes capable models for challenging tasks.
- Max: prioritizes the most capable models for the most demanding work.
Plan availability by tier is not fully confirmed. One secondary outlet, XenoSpectrum, reports that Standard is on all plans while High and Max are limited to supported plans. I could not see the official table, so check your own plan before you plan around it.
Which models are in the pool
GitHub’s documentation, as summarized here, does not give a full model list. Artificial Analysis identified Anthropic and OpenAI models in the pool, including Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra and GPT-6 Sol, according to VentureBeat. That is third-party identification, not a GitHub-published list.
Supported local models can take part through Fusion Standard in a public preview. Models excluded by data-resident or FedRAMP-compliant policies are left out. If none of Fusion’s models are available to you, Fusion does not appear in the model picker (Cybersecurity News).
What admins can control
Administrators choose which models Fusion can use and whether it is the default. The enterprise managed settings reference documents a “fusionTier” setting for the default effort level, per the GitHub community discussion and the developer write-up above.
Who should switch GitHub Copilot Fusion on
Fusion suits teams that currently choose models by habit or guesswork. If developers pick one frontier model for everything, routing may match effort to the task more sensibly. GitHub’s claim is that Fusion High and Max scored up to 8.7 points higher on task completion than equivalent effort levels from leading frontier models, with estimated costs up to 77% lower. GitHub measured this in its own Copilot harness (GitHub). Treat it as a vendor claim.
Independent numbers exist but are narrow. Artificial Analysis scored Fusion Max in Copilot CLI at 60 overall, at an average task cost of $5.59. The comparison figure for Claude Code with Opus 5.5 Max was $11.42. Artificial Analysis has not scored Fusion High or Standard, according to CellCog.
Good first candidates
- Teams with mixed workloads: quick edits and hard debugging both benefit from routing.
- Enterprise admins: model allow-lists and a default tier give you policy control without per-developer tuning.
- Cost-watchers: paid-plan users get a limited-time 30% discount on model costs when using Fusion. One report says it runs through November 30, 2026, and the post-discount price is unconfirmed (Shattered).
Who should wait or tread carefully
Developers who need predictable latency may find cascade and critique frustrating, because the extra review calls take time. Teams with strict data-residency or FedRAMP requirements should confirm which models remain available under their policy. And if you need to know exactly which model touched your code, remember that the pattern and models can change between prompts.
A sensible rollout is to enable Standard for a pilot group, compare completed tasks and pull-request quality against your current manual picks, then try High on harder work during the discount window.
What GitHub Copilot Fusion means for AI credit billing
Fusion has no separate fee. You pay for each model it uses at that model’s standard rate, and GitHub does not publish a fixed per-task multiplier, according to the GitHub community discussion. Cascade and critique runs involve more than one model, so your cost per task depends on which pattern Fusion picks. Plan for variance instead of a flat number.
The baseline is the usage-based model that replaced premium request units on June 1. Copilot usage is measured in AI credits, where one credit equals $0.01. Input, output and cached tokens are all metered at published API rates, per GitHub’s billing docs. Listed plan prices are Pro at $10 a month, Pro+ at $39, Business at $19 per user and Enterprise at $39 per user.
Three details matter for budgeting:
- Discount window: paid plans get 30% off Fusion model costs for a limited time. One report puts the end date at November 30, 2026, and the price afterward is unconfirmed (Shattered). Any pilot you run now will look cheaper than the steady state.
- Enterprise without seats: GitHub Enterprise customers can use every Copilot feature without a separate Copilot subscription and pay only for credits consumed. Under the published terms there is no monthly credit allowance per seat, and metering starts with the first request. The offer runs through GitHub’s sales team for now, with self-serve promised (Technology.org).
- When budget runs out: code completion and next-edit suggestions keep working. Copilot Chat, code review and cloud-based Copilot need available budget (VentureBeat).
Code review Max costs more than it first appears
Copilot code review Max is in public preview. It runs several independent review agents on models from different providers, then an aggregation agent consolidates findings, resolves disagreements and checks accuracy. That takes longer and uses more credits than the Lite or Balanced levels (GitHub changelog). GitHub’s code review docs give average costs per review:
| Review level | Average cost per review |
|---|---|
| Lite | about $0.25 |
| Balanced | about $1.50 |
| Max | about $10 (typical range $1.50 to $25) |
The docs advise Max for high-risk or release-critical pull requests. Admins can cap the maximum review effort per repository, which is the most practical guardrail. Since June, code review also consumes GitHub Actions minutes on top of AI credits, so the table understates the full bill (GitHub blog).
Copilot Projects and the review bottleneck
Copilot Projects pairs naturally with Fusion. You set a goal, attach repositories or other context, and Copilot spins up as many agents as needed. Output comes back as pull requests. The announcement also included cloud-agent session continuity across the Copilot app, VS Code, the CLI and github.com, though I did not find a detailed GitHub description of how it behaves.
The shift in workload is easy to miss. Agents that produce several pull requests at once move the effort from writing code to reviewing it. Code review Max is GitHub’s answer, and Copilot approvals are generally available. Even so, a machine-aggregated review does not remove the need for a human who understands the change. This is my own assessment, not a GitHub finding.
Caveats before you roll it out
- The benchmarks are largely GitHub’s. The headline figures, up to 8.7 points higher task completion and up to 77% lower estimated cost, come from GitHub’s own Copilot harness. The independent Artificial Analysis score covers only Fusion Max in Copilot CLI: 60 overall at $5.59 per task, against $11.42 for Claude Code with Opus 5.5 Max (XenoSpectrum). Standard and High have not been scored.
- Parallel agents can conflict. Agents working across repositories, or on overlapping files in one repository, may produce changes that clash or duplicate each other. GitHub’s notes here do not describe a conflict-resolution mechanism, so assume you will do some of that reconciliation yourself.
- Review capacity is the next bottleneck. More generated pull requests means more review load. Max review costs real money and time, so reserve it for risky changes.
- Predictability suffers. Pattern and models can change between prompts, and cascade and critique add latency.
- Preview status. Copilot Projects, code review Max and local-model support in Fusion Standard are all in public preview, so behavior and pricing may change.
GitHub Copilot Fusion vs Claude Code and Codex
The comparison below uses only what is confirmed. I have no verified feature or pricing details for Codex or Cursor from the research behind this piece, so I leave them out of the table instead of guessing.
| Question | Copilot Fusion | Claude Code |
|---|---|---|
| Model choice | Automatic routing across a multi-vendor pool (third-party identified) | The cited benchmark baseline used Claude Opus 5.5 at Max effort |
| Cost per task (Artificial Analysis) | $5.59 (Fusion Max, Copilot CLI) | $11.42 (Opus 5.5 Max) |
| Quality gap | Within two points on the Coding Agent Index (CellCog) | Reference point |
| Admin controls | Model allow-list, default setting, per-repository review caps | Not covered here |
For a team choosing a tool, the decision is mostly about workflow. Copilot Fusion fits teams already on GitHub who want routing, policy controls and review inside one billing system. If your team prefers one model it trusts, or works outside GitHub, a single-vendor agent may be simpler to reason about. Whichever you pick, run the same ten real tasks through each tool and compare cost, completion and review effort. If you are tracking OpenAI’s coding models in particular, our note on GPT-6.1 Terra covers a lower-cost option.
Frequently Asked Questions
Is GitHub Copilot Fusion free?
There is no separate Fusion charge. You pay for the models it uses at their standard rates, drawn from your AI credits. Paid plans currently get a 30% discount on those model costs, reportedly through November 30, 2026.
Which plans and tools support Fusion?
It is generally available on all Copilot plans in VS Code, the Copilot app, Copilot CLI and JetBrains IDEs. One outlet says High and Max are limited to supported plans, but I could not verify that in the official docs.
Can I still choose a model myself?
The notes do not say whether manual selection stays available alongside Fusion. They do say administrators control which models Fusion can use and whether it is the default.
Do enterprises need a Copilot seat now?
No. GitHub Enterprise customers can use every Copilot feature without a separate Copilot subscription and pay only for credits used. For now this goes through GitHub sales, with self-serve promised later.
Is Copilot code review Max worth the cost?
For release-critical or high-risk pull requests, GitHub’s docs recommend it. At an average of about $10 per review, it makes little sense for routine changes. Use the per-repository cap to keep spending in check.
Conclusion
Fusion is a sensible default for teams tired of arguing about models, and the enterprise credit-only option lowers the barrier to trying it. The evidence for its savings is still thin outside GitHub’s own tests, and the 30% discount will flatter early results. Start with a small pilot on Standard, record credits spent and review time per task, and set a review-effort cap
