GitHub Project HydraFusion: Multi-Model Copilot Explained

Project HydraFusion is a research preview in GitHub Copilot CLI (Copilot's command-line interface) that orchestrates multiple models from different providers at runtime, and in GitHub's controlled offline evaluations it matched or exceeded the Claude Opus 5 coding baseline while cutting estimated workflow cost by up to 67%. HydraFusion is available now to users on all GitHub Copilot plans through the /experimental flag, and usage is billed on the tokens consumed by the models it routes to, at each model's standard rate, according to GitHub's announcement.

What Project HydraFusion actually is

HydraFusion delivers what GitHub calls frontier intelligence through runtime orchestration: for each task it creates a full execution plan, choosing from models across multiple providers to draft, critique and revise, or cascade to more powerful models to finish the job. GitHub positions HydraFusion as a key piece of its strategy for automated semantic routing between local, cloud, and compound models. From your side of the terminal, that complexity stays hidden — you select HydraFusion in the model picker like any other model, and it chooses a workflow that balances performance, cost, and latency for each task.

HydraFusion extends the Auto model selection feature GitHub launched earlier this year. Auto model selection reviews a task and matches it to the single best-suited model; HydraFusion goes further and constructs a multi-model workflow per request.

The three execution patterns

HydraFusion treats workflow selection as an optimization problem: it scores capability signals for reasoning, code generation, debugging, and tool use, then picks the least complex workflow expected to meet its quality bar. Additional model calls happen only when they are likely to improve the result. Each request currently gets one of three patterns:

Pattern	How it works	When HydraFusion picks it
Single	One selected model solves the task directly.	One model can clear the quality bar alone; preserves speed and efficiency.
Cascade	An efficient model drafts a solution; a quality gate accepts it or escalates to a stronger model.	The first attempt should be cheap, with a path to stronger inference if the candidate doesn't clear the gate.
Critique	One model drafts; an independent, read-only critic from a different model family reviews it (the same review pattern GitHub calls Rubber Duck); the drafting model revises once.	An independent perspective is worth more than another unaided attempt.

That selectivity is the cost story in miniature: most requests never pay for the full draft-critique-revise chain, because HydraFusion only escalates when the cheaper path looks insufficient.

How the routing was tuned

GitHub shaped HydraFusion's routing policies on real usage: CheckpointBench, the internal benchmark, was curated from actual Copilot coding-session trajectories, and policies were refined across all three evaluation sets rather than any single benchmark. Instead of hand-tuned thresholds, beam search built the decision policy, with each candidate measured against a frozen baseline on quality, cost, and failure modes. As new models land in Copilot — GPT-6 Astra's recent general availability shows that cadence — GitHub says it can evaluate them and fold their strengths into HydraFusion's model pool.

How to enable HydraFusion in Copilot CLI

HydraFusion is available to users on all GitHub Copilot plans through /experimental in Copilot CLI:

1. Run /update to install the latest version.
2. Run /experimental on.
3. Run /model, then select HydraFusion (Research Preview).

The preview is tuned for first-turn, single-prompt coding tasks: GitHub recommends substantial, well-scoped tasks you can hand to Copilot in autopilot mode in a single prompt. Longer, iterative multi-turn sessions are the stated next focus. Share findings through /feedback in Copilot CLI or the GitHub Community discussion. For help structuring work into single-prompt agent tasks, see AI Coding Agents: A Practical Guide to Working With Them.

Benchmark results vs. Claude Opus 5

Across three agentic coding benchmarks, HydraFusion delivered frontier-level quality with substantial estimated cost savings: on TerminalBench 2.1 it beat Claude Opus 5 by 4.9 percentage points of verified task quality at 67% lower estimated cost, and on the two harder sets it traded a sliver of quality for large savings.

What was measured

GitHub evaluated fixed HydraFusion policies on TerminalBench 2.1 (complex, multi-step tasks in terminal environments), DeepSWE (repository-level engineering requiring navigation of large codebases and cross-file dependencies), and CheckpointBench (an internal multi-turn benchmark curated from real Copilot sessions, each anchored to a public repository and immutable commit so sessions replay). Claude Opus 5 and GPT-5.6 Sol served as comparison baselines. Every policy ran with the same task inputs, tools, execution limits, pricing assumptions, and grading conditions, with all models at the same medium reasoning level. "Verified task quality" is the share of tasks confirmed correctly answered; cost figures are the complete estimated workflow cost, including every invoked leg.

Benchmark	Estimated cost vs. Opus 5	Verified quality vs. Opus 5
TerminalBench 2.1	67% lower	+4.9 points
DeepSWE	36% lower	-1.5 points
CheckpointBench	65% lower	-0.1 points

On DeepSWE, HydraFusion comes within 1.5 percentage points of Opus 5 at 36% lower cost; on CheckpointBench, within 0.1 points at 65% lower cost. Early internal testing echoed the numbers — GitHub quotes a Principal Software Engineer at Microsoft: "So far, the reasoning and task solving capability [of HydraFusion] is at or better than Opus."

What the numbers leave out

Three caveats matter before you quote these figures. First, they are vendor-reported, controlled offline evaluations, specific to the benchmark revisions, workflow configurations, model pool, and pricing assumptions GitHub tested — not independent measurements. Second, the published table reports only against Opus 5; the announcement gives no GPT-5.6 Sol-relative figures, even though GPT-5.6 Sol ran as a baseline. Third, the results show the best tuned HydraFusion configuration, not necessarily what the preview ships. GitHub itself flags TerminalBench 2.1 as relatively saturated, which is why DeepSWE's harder repository-level tasks were included. For Opus 5's own pricing and benchmark profile, see Claude Opus 5: Pricing, Benchmarks and What Changes; for why vendor-run scores deserve skepticism generally, see LLM Benchmarks Explained: Why Vendor Scores Mislead. Full run detail is in GitHub's benchmark write-up.

What HydraFusion means for your usage-based bill

HydraFusion billing is token-based: you pay for the tokens consumed by the models HydraFusion uses, priced at each model's standard rate. One task can touch several meters, because drafting, critique, revision, escalation, retry, and fallback all count as workflow legs. Three things to keep in mind:

• The savings are harness numbers, not invoice numbers. The 36–67% figures are estimated workflow cost versus the Opus 5 baseline in controlled offline evaluations. How that maps to real workloads is exactly what the research preview is designed to learn.
• The rates are not published. The announcement does not name the models in HydraFusion's pool, their rates, or how HydraFusion tasks map onto plan allowances such as premium-request treatment. For the mechanics of Copilot's metering, see GitHub Copilot Usage-Based Billing: A Developer's Guide.
• Cheaper by default, not by guarantee. HydraFusion routes most tasks to the least complex workflow expected to clear its quality bar, but an escalated Cascade or full Critique run invokes more model calls than a single-model pass.

The practical test: run the same task through HydraFusion and your usual model, then compare actual token spend before switching anything over.

The engineering guardrails

Multi-model orchestration is only safe for repository-level work with strict execution control, so GitHub built HydraFusion around five operating principles:

• Complete accounting. Cost and usage are aggregated across every workflow leg, including drafting, critique, revision, escalation, retry, and fallback.
• Bounded execution. Each leg gets explicit timeout and cancellation behavior, keeping execution and cost within defined limits.
• Isolated review. Critique steps run in isolated, tool-less contexts, while solver steps use the shared workspace and the normal permission-aware agent loop — critics assess work without modifying the repository.
• Fail-safe application. No patch is applied when a workflow is cancelled or fails validation, so incomplete changes never reach your repo.
• Validated routing. Workflow definitions, model bindings, fallback behavior, and model availability are verified before execution begins.

Internally, the runtime records the role, outcome, cost, latency, and diagnostics of each leg. Externally, you get one coherent response and one permission-aware change set. One known trade-off: HydraFusion shows workflow stages but holds intermediate drafts until the final result, because drafts may be revised or discarded and showing them live could make unfinished work look final. GitHub acknowledges the wait-without-visibility problem and says better progress updates are coming, guided by preview feedback.

What to do now

• If you want to try it: enable it with the three commands above, then hand it substantial, well-scoped coding tasks in a single prompt in autopilot mode. First-turn tasks are its sweet spot today.
• If you're on usage-based billing: benchmark HydraFusion against your current model on real tasks and compare per-task token spend before making it a default. The preview exists precisely to learn how orchestration affects cost and latency in practice.
• If your team standardized on Opus 5 for hard repository-level work: DeepSench shows HydraFusion 1.5 points behind Opus 5, and multi-turn sessions are not the preview's focus yet. Keep Opus 5 as the workhorse and treat HydraFusion as a cost saver for well-scoped single-shot tasks.
• Either way: report where HydraFusion excels and falls short via /feedback in Copilot CLI or the GitHub Community discussion. HydraFusion is active research — results, models, workflows, availability, and even the name may change as GitHub learns from the preview.