GitHub Copilot Fusion routes work across models
Developer Tools

GitHub Copilot Fusion routes work across models

GitHub Copilot Fusion coordinates models for coding tasks, balancing capability, cache reuse, cost, and reasoning effort.

Key insights

  • Copilot Fusion combines model routing with a framework for having models work as a team.
  • Users choose Standard, High, or Max; Fusion handles the model decisions behind that tier.
  • Routing takes model capability, reasoning effort, cached context, and context-window size into account.
  • Microsoft says Copilot Fusion became generally available in October 2026.
  • The session identifies escalation decisions, latency, cache tradeoffs, and benchmark-to-real-work gaps as ongoing challenges.

GitHub Copilot Fusion coordinates multiple models for a coding task instead of requiring the user to choose one model for every step. It matters to developers who use Copilot and want model selection to account for task difficulty, cost, and conversation context. Microsoft Events demonstrates the approach in a Microsoft Ignite session, including how model routing and shared runtime design fit together.

What's new

Copilot Fusion brings together two ideas: routing a task to a suitable model and using a team of models during the work. The session describes an earlier Auto approach that selected a model for a prompt, followed by Hydra, which matched one model to a task. Fusion combines routing with an orchestration framework in which models can take different roles, such as drafting, reviewing, and revising.

The practical change is that users choose a tier—Standard, High, or Max—rather than manually deciding which model should handle each part. Fusion generates a plan for the current turn. That plan can specify models and reasoning effort for drafting, review, and a possible rewrite, and those choices can vary from turn to turn.

That does not mean that every task benefits from using more models. The speakers emphasize that every additional model call has to earn its place. A team can add latency, and switching models can discard useful prompt-cache state. The harness therefore has to weigh likely quality improvements against the cost and time of additional work.

Who it is for and what you need

Fusion is aimed at people using GitHub Copilot for software development, particularly tasks where the agent may need to work through several steps or handle a difficult codebase. The session says Project HydraFusion launched as a public preview in Copilot CLI during summer 2026, then says GitHub Copilot Fusion became generally available in October 2026.

The session describes the Copilot harness as a shared runtime built on the Copilot SDK, used across VS Code, the Copilot app, and Copilot CLI. This design lets the feature be implemented once and made available to clients that update to a runtime version that supports it. Users select a Fusion tier; the product handles the underlying plan and model choices.

The speakers frame model orchestration as an engineering problem, not just a model-picker choice. Model capability, reasoning effort, context size, and cache status can all affect the decision. For teams building coding agents, the underlying lesson is to consider these factors together rather than routing solely to the lowest-priced model.

How it works

  1. Choose a Fusion tier. Select Standard, High, or Max to set how much effort Fusion should make on the task.
  2. Fusion evaluates the turn. It narrows the available models based on which ones are suitable for the task, using model scores and a classifier as part of the process described by the speakers.
  3. The runtime accounts for session state. It considers reasoning effort, cache availability, and whether the conversation fits a candidate model’s context window. A switch may mean reprocessing context that was cached for another model.
  4. Fusion creates a plan and carries it out. The plan can assign different models to draft, review, and revise work. The system can run critics in parallel, while the session says each run is capped at revision.

Cache reuse helps explain why the cheapest model on a price list is not always the cheapest choice for a turn. The speakers use a long-session example: after about 300,000 tokens with one model, continuing with that model can reuse cached context. Switching to another model may require paying to process the context again. In the example, the cached input price for the current model and the uncached input price for another model can be the same.

Context length matters too. If a session’s context is larger than a candidate model’s window, selecting it could trigger compaction—reducing the conversation context to fit. That can add time and cost. A routing decision therefore needs to consider the current conversation, not only the apparent difficulty of the latest message.

Limitations and alternatives

Fusion does not remove the tradeoffs involved in multi-model work. The session calls out four open engineering challenges: deciding when to escalate, balancing cache reuse against switching, limiting the delay from additional models, and judging benchmark results against real work. In particular, an escalation decision can be difficult when there are no tests available to judge a draft.

Microsoft presents benchmark results for Fusion Max across coding tasks, including lower cost in the comparisons shown. Those results are the speakers’ reported evaluations, not a guarantee that every task or repository will see the same outcome. Their own caution is that benchmark scores can be noisy and real sessions run longer.

For users who want direct control over the model, Fusion’s tier-based approach differs from manually choosing a model for each request. The session describes the shift as a way to automate the model coordination users sometimes perform themselves. It does not suggest that one tier or routing plan is the right choice for every workload.

Sources

Frequently asked questions

What does GitHub Copilot Fusion do?

It coordinates models for a task, including routing work and assigning models to stages such as drafting, review, and revision. Users select Standard, High, or Max.

When did GitHub Copilot Fusion become generally available?

The session says GitHub Copilot Fusion became generally available in October 2026, after Project HydraFusion had launched as a public preview in Copilot CLI during summer 2026.

Why might Copilot Fusion keep using a more expensive model?

That model may already have the conversation context cached. Switching can require processing the context again, so the smaller or cheaper model may not reduce the cost for that turn.

What factors does Copilot Fusion consider when routing models?

The session describes model capability, reasoning effort, prompt-cache state, and context-window size as factors that affect the plan for a turn.