On Wednesday 28 October 2026, GitHub Copilot Fusion became generally available (anyone on a Copilot plan can turn it on, not only a research preview). The sentence people will screenshot is this one, from the GitHub changelog: Fusion Max scored within two points of Claude Code with Opus 5.5 Max, at about half the cost. The sentence is real. It is also three different measurements wearing one coat. This page takes the coat off.
If you only keep one line, keep Mario Rodriguez’s, GitHub’s chief product officer, as quoted by VentureBeat the same day: “It’s not a model. It’s an orchestration engine at runtime.” An orchestration engine is a program that decides which other programs to call, and in what order. The menu says Fusion. It does not say which brain answered.
Start with the program, not the picker
A computer follows instructions. A program is a stored set of those instructions. A model, here, is one kind of program: a huge list of numbers that guesses the next piece of text. Those numbers are the weights (the stored guesses). The weights do not choose their coworkers. Something else has to point a task at a model.
A token is a chunk of text the model reads or writes, often a word or part of a word. You are billed by tokens, not by how wise the answer felt. An agent is a model plus a loop. The loop reads what the model just wrote and, if that text asks for an action, does the action, then pastes the result back. A tool is one allowed action: edit a file, run a test, search the repo. A harness is the loop, the tools, and the rules around them. Claude Code is a harness. Copilot CLI is a different harness. The same model in two harnesses is two different workers.
A router is the switch that sends a job to one worker. An orchestrator is the switch that can send the job to several workers and stitch their answers into one. Copilot Fusion, in GitHub’s own docs, is both: “an intelligent runtime model router and orchestrator.” Runtime means it decides while you are waiting, not when GitHub compiled the app.
The older Copilot Auto mode was only the first half of that picture. Auto picked one model for a request. Project HydraFusion, the research preview Fusion is built from, picked a pattern and could call several models inside one turn. The 28 October changelog says Fusion joins those two. I am not treating the preview and the product as the same pool of models. Pools change. The next section is the product as the docs describe it today.
The same trap, a product name that sounds like a new brain, came up with JetBrains Air, which is not a new model either, and with Claude Code and Codex running the same model.
What you actually click
You do not pick Claude, or GPT, or Gemini. You pick Copilot Fusion, then an effort level (how hard the switch is allowed to try, which also changes the bill).
GitHub’s docs, not the short changelog, spell the levels like this.
| Effort | What the docs say it prioritizes | When they say to use it |
|---|---|---|
| Fusion Standard | Cost, quality, and latency (how long you wait) together | Everyday work. The docs say Standard selects one model for each task |
| Fusion High | Balanced orchestration, with moderate token savings | A hard bug, or a change across several files, when extra model calls are worth the credits |
| Fusion Max | The strongest reasoning it can buy, while still watching tokens | The deepest analysis |
| Fusion Fast | Fast models only | You cannot select this. The docs say it is only used in Visual Studio Code inline chat |
Standard is the important row. “One model for each task” means Standard is mostly a router. High and Max are where the second and third model calls show up. The changelog’s three adjectives, versatile, capable, and most capable, hide that split. Use the table.
It is on every Copilot plan, in four places: Visual Studio Code, the GitHub Copilot app, GitHub Copilot CLI, and JetBrains IDEs. Other clients are “coming soon.” If you were on the research preview’s Auto, HydraFusion, or HydraFusion Max, GitHub says those selections move themselves onto the matching Fusion effort. An administrator can also set Fusion, at any effort, as the default. You may already be on the switch without having chosen it.
Three ways one prompt can be done
A pattern is the shape of the work, not the name of a model. The docs say Fusion picks a pattern per prompt, so two messages in the same chat can take different shapes. Picking the pattern is described as a light step. Extra model calls happen only when the task is judged to need them.
Single means one model does the task. The docs tie this to everyday work, and they say Standard selects one model per task. Rodriguez told VentureBeat the same thing in plainer words: a single mode goes “directly into the model that we believe is the best for the task.”
Cascade means a cheaper model writes a draft, then a judge (another model, asked only to accept or escalate) either keeps that draft or sends the job to a stronger model. Escalate means call the expensive one after all, not instead of having tried the cheap one. You can be billed for both.
Critique means one model drafts, several models criticize that draft at the same time, the notes are merged, and the original model rewrites. The changelog shortens this to “another model reviews it.” The docs say “multiple models” and “in parallel” (at the same time, not one after another). Where those two GitHub pages disagree, I am keeping the docs. Parallel critics are more calls, and more calls are more tokens.
Here is the sentence in the docs that the launch posts skip. If Fusion discards a draft, “changes that the draft already made in your workspace, such as file edits, aren’t undone automatically.” A cascade can write files with the cheap model, decide the draft is bad, call a stronger model, and leave the cheap model’s edits sitting in your tree. Review the diff before you commit. A diff is the list of lines that changed. Commit means saving those lines into the history of the project.
Two smaller limits, also from the docs, not from the keynote. Fusion does not have a context window of its own. A context window is how much text a model can see at once. The number shown next to Fusion is a conservative stand-in: the smallest window among the models it might call. A step that lands on a model with a larger window still only promised you the small number. And Fusion “works separately from subagents and doesn’t start them.” A subagent is a helper agent spun up to do a side job. Fusion will not do that for you. If your workflow depended on subagents, this switch does not replace that workflow.
The bill is per model, not per click
There is no Fusion tax, and there is no Fusion discount baked into the product price. GitHub’s docs: you are “billed for each model it uses, at that model’s standard rate.” High and Max “may consume more AI credits than” Standard, because they may call more than one model. An AI credit is the unit Copilot uses to meter that usage. One click can be two or three model bills.
Through 30 November 2026, paid Copilot plans get 30 percent off those model costs when the work goes through Fusion. That date is in the docs, and GitHub’s own X post on 28 October says the same end date. The 30 percent is a coupon on top of the per-model rates. It is not the “half the cost” in the benchmark. Stacking them in your head will make a spreadsheet lie.
Hari Pokhrel, a principal software engineer at AT&T, is quoted in the changelog on a narrower win than “half.” On Fusion Standard, he says, people stopped leaving a powerful model selected after a hard task. The waste he describes is a forgotten setting, not a better brain. That matches what Standard is: one model, chosen for you, so you do not have to remember to switch back.
What the score of 60 actually is
A benchmark is a fixed set of tasks, scored the same way every time, so two systems can be compared. An index is several benchmarks averaged into one number. Artificial Analysis (an independent lab that publishes those comparisons) scores coding agents, not bare models. The thing on the chart is a harness plus a model plus a setting.
Coding Agent Index v2.0, the version they used, has three parts, weighted equally (each is one third of the score):
- Terminal-Bench 4.0 is work done in a terminal (the text window where you type commands).
- FrontierCode v1.1, from Cognition, is a change to a real open-source repository, graded on whether a maintainer would merge it. A maintainer is the person who can accept a change into the project. A blocking check that fails scores zero.
- SWE-Atlas-QnA-AA is questions about a repository, revised by Artificial Analysis from Scale AI’s set. It asks “what does this code do,” not “please change it.”
Artificial Analysis posted the chart on 28 October 2026. The bars round to 62 for Claude Code with Opus 5.5 Max, 62 for Devin Fusion (Opus 5.5 Max plus GPT-6 Luna High), and 60 for Copilot Fusion Max. GitHub’s changelog says 60, “within two points.” Same picture.
The chart is the one attached to Artificial Analysis’s post that day. I did not re-run the tasks. The lower plot is index versus dollars per task. Fusion sits in the cheap-and-high corner of that plot. The corner is not a promise about your repository.
The dollars, from that same post, not from GitHub’s rounding:
| System, as Artificial Analysis named it | Index | Cost per task | Tokens per task | Where it is strong, where it is not |
|---|---|---|---|---|
| GitHub Copilot, Fusion Max, measured in Copilot CLI | 60 on the chart | $5.59 | 7.2 million | Leads Terminal-Bench 4.0 at 71. FrontierCode 51. SWE-Atlas-QnA-AA 57 |
| Claude Code, Opus 5.5 Max | 62 on the chart | $11.42 | About twice Fusion’s. They did not print the other side’s exact count | FrontierCode 56 |
| Devin Fusion, Opus 5.5 Max plus GPT-6 Luna High | 62 on the chart | $8.00 | About 30 percent more than Fusion’s 7.2 million | FrontierCode 54 |
Read the middle column before the first. $5.59 is about half of $11.42. That is the “half” in the headline, and it is an average across this index, in this harness, at Max. It is not your next pull request. Half the tokens is the same comparison: 7.2 million for Fusion, and Artificial Analysis’s words “approximately half” for Opus inside Claude Code. I am not inventing the missing exact count.
The split inside the average is the part worth money. Fusion leads the terminal tasks and trails on FrontierCode, the test that asks whether a maintainer would merge the change. Five points behind Claude Code there (51 against 56) is a different fact from “two points behind overall.” If your work is “change this repository until it is mergeable,” the headline average is the wrong number. If your work is a long session of commands in a terminal, their lead on Terminal-Bench is the number that matches the job.
Two more numbers that must not be stirred into the $5.59.
GitHub says Fusion finished tasks in about 40 percent less time. I do not see that figure in Artificial Analysis’s 28 October post. VentureBeat says the time claim is GitHub’s, not an independent measurement. I am leaving it in GitHub’s column.
VentureBeat also reports a GitHub internal test, on a benchmark called DeepSWE, using Copilot’s own harness: Fusion High and Max beat “comparable frontier-model configurations by up to 8.7 points,” and cut estimated cost “by as much as 77 percent.” “Up to” and “as much as” are maximums, on a different test, in a different harness. They are not a second printing of the 51 percent gap between $11.42 and $5.59. Do not average 77 and 51.
A public mirror of a leaderboard, captured the same day, prints 59.9, 61.7, and 61.5 where the chart prints 60, 62, and 62. That is one decimal place, not a different exam. I did not recompute either print.
The pool is not a promise, and your admin can shrink it
GitHub’s changelog does not name the models inside Fusion. Artificial Analysis, describing the system it measured, says the pool included Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra, and GPT-6 Sol. Opus and Sonnet are Anthropic’s models. Astra and Sol are OpenAI’s. The docs refuse that kind of list. They say the pool “changes as new models become available” and as GitHub re-evaluates them. I am not gluing the 28 October measured pool onto next month’s product.
An earlier HydraFusion note, 14 October, listed a pool that also included GPT-6.1 Sol and GPT-6 Luna. That was the preview. I am not treating it as the GA (general availability) list.
Your company can make the measured pool impossible. Fusion only uses models your plan includes and your administrators have not turned off. Admins can disable a model for Fusion without disabling it for people who pin that model by hand. Policies can also restrict Fusion to data-resident models (models that stay in a chosen region) or to FedRAMP-compliant ones (a U.S. government security bar). If none of Fusion’s models are left, the docs say Fusion does not appear in the picker at all.
So the bar at 60 is Fusion Max, in Copilot CLI, with the pool Artificial Analysis saw that day. If your organization has removed Opus 5.5, you are not on that bar. Rodriguez told VentureBeat that organizations can get visibility into which models were used. The changelog says admins can see what Fusion picks from. Neither source, in what I read, shows you a per-request receipt inside the chat. “We can audit it” and “I can see it in the transcript” are different claims. I am not merging them.
A local model does not make the session offline
The same day, GitHub shipped a second switch: Fusion may call a model running on your machine. The changelog calls it an experimental preview (opt in, still changing). The Fusion docs call selecting local models a public preview. I am keeping both labels, because both pages are GitHub’s and they do not match.
The local models they name are MAI Code 1.1 Flash and Qwen3.8 Flash Next. MAI Code is Microsoft’s. Qwen is an open-weights family (you can run the weights yourself; the nickname on the page is the docs’ spelling, including the odd “3.8”). A managed download of MAI Code 1.1 Flash is Windows-only, through Windows ML. On Windows, macOS, and Linux you can instead point Fusion at a local server that speaks the OpenAI protocol (the same shape of request OpenAI’s API uses). The docs say a local model is more likely to be chosen on Standard, not on Max. In the Copilot app, intelligent local routing currently supports the managed Windows model only.
Then the sentence that matters. From the local-model changelog: “Local inference doesn’t make your session offline. Copilot Fusion still makes routing decisions in the cloud.” Inference is the model answering, as opposed to training (the practice that changes the weights). The answer may be computed on your laptop. The decision to ask your laptop is still made on GitHub’s side. Local models “may have different safety protections” from Copilot’s cloud models. And adding a model with your own key does not put that model into Fusion’s pool. Eligibility is a separate list.
If you turned this on to keep code off the network, you have not done that. You have moved one hop. The router still sees the task.
What to do on Monday
| What you might do | What the sources support |
|---|---|
| Leave Fusion on Standard for ordinary edits | The docs say Standard picks one model per task, and balances cost and latency. This is the AT&T quote’s actual use |
| Move to High or Max for a hard, well-scoped change | You are opting into extra model calls. Each call is billed. The 30 percent coupon runs through 30 November 2026, on paid plans |
| Read the diff before you commit | A discarded cascade draft does not roll back edits it already wrote |
| Pin a named model when you must say which one wrote the code | Fusion returns one answer and does not, in the sources I read, print the model name into the chat. Admins can see the pool. That is not the same as a line in your transcript |
| Trust the index only for the slice that matches the work | 71 on terminal tasks, 51 on “would a maintainer merge this.” The 60 is the average |
| Turn on a local model and call the laptop offline | GitHub says the routing decision stays in the cloud |
| Expect Fusion to launch subagents, or to match a context window you saw on Opus | It does not start subagents. The window it shows is the smallest among the models it might call |
I did not run Fusion. I did not re-score the 290 tasks in Index v2.0. The numbers above are GitHub’s pages, Artificial Analysis’s 28 October post and chart, and VentureBeat’s interview with Rodriguez. Where those three disagree, the disagreement is left in the paragraph, not averaged out.
Common questions about GitHub Copilot Fusion
Is GitHub Copilot Fusion a model?
No. GitHub’s docs call it a runtime model router and orchestrator. It picks a pattern, calls one or more models your plan allows, and returns one answer.
Does Copilot Fusion cost extra?
There is no Fusion fee. You are billed for each model it calls, at that model’s standard rate, so High and Max can use more credits than Standard. Paid plans get 30 percent off through 30 November 2026.
Is Copilot Fusion as good as Claude Code with Opus 5.5?
On the Artificial Analysis Coding Agent Index, Fusion Max scored 60 against 62, at $5.59 against $11.42 per task. It led on terminal tasks and trailed on FrontierCode, 51 against 56.
Does a local model keep my Copilot session offline?
No. GitHub says Copilot Fusion still makes routing decisions in the cloud, even when the answer is computed on your machine.