GitHub's Model Router Won on Cost 3 Times. On Quality, Once.

TL;DR

Project HydraFusion is a research preview in GitHub Copilot CLI that stops routing every coding task to one big model. A router picks one of three execution shapes per task: a single model, a cheap model behind an escalation gate, or a draft reviewed by a critic from a different model family.

Across three agentic coding benchmarks it cut estimated cost by 36% to 67% versus Claude Opus 5. It also matched or beat Opus 5 on quality in exactly one of the three. Both of those facts are in GitHub's own table, which is more disclosure than most routing launches offer.

What actually shipped

This is not a waitlist. It is live on every Copilot plan: run /update in Copilot CLI, then /experimental on, then /model and pick "HydraFusion (Research Preview)". Billing is per token at each underlying model's standard rate, so any savings show up as real dollars rather than as credit-system arithmetic.

The router reads capability signals for reasoning, code generation, debugging, and tool use, then picks what GitHub describes as the least complex workflow expected to meet the task's needs. Three workflows exist:

• Single. One selected model solves the task directly. The status quo, chosen deliberately.
• Cascade. An efficient model drafts, a quality gate decides whether to accept it or escalate to a stronger model.
• Critique. One model drafts, an independent read-only critic from a different model family reviews it, and the drafting model revises once.

Cascade is where the money moves, and it is worth being precise about how. Think of it as a junior engineer who takes every first pass and a senior who only gets paged when the first pass fails review. You pay the junior on every single ticket. You pay the senior only when the page goes out.

The table is the disclosure

GitHub evaluated fixed HydraFusion policies on three agentic coding benchmarks with Opus 5 and GPT-5.6 Sol as baselines, all at the same medium reasoning level. Costs are estimated and account for every model invocation, including drafting, critique, revision, and escalation.

On TerminalBench 2.1, HydraFusion improved verified task quality by 4.9 percentage points at 67% lower estimated cost. On DeepSWE it came within 1.5 points of Opus 5 at 36% lower cost. On CheckpointBench it came within 0.1 points at 65% lower cost.

Read the two columns separately and the launch reads differently than the headline. Cost moved in the right direction three times out of three. Quality moved in the right direction once. VentureBeat put it bluntly: the benchmark table is the disclosure.

That is not damning. A 0.1 point drop for 65% less spend is a trade most engineering leaders would take without a meeting. But "frontier quality" in the title and "minus 1.5 points" in the table are describing the same system, and only one of them is going in the slide deck.

Where the savings actually come from

The important thing to understand is that HydraFusion is not making models cheaper. It is changing which model sees which task. That is a distribution win, not a capability win, and distribution wins have a specific failure mode: every task the gate under-triages is a task a weaker model shipped.

The quality deltas are the price of that triage, expressed in points. If your workload is mostly small, well-specified changes, the gate will be right most of the time and you keep almost all the savings. If your workload is gnarly, the gate has more chances to be wrong, and the escalation path means you paid for the failed draft too.

One of the three benchmarks is GitHub's own

TerminalBench 2.1 and DeepSWE are public. DeepSWE in particular is a strong choice: 113 original long-horizon tasks written from scratch across 91 active open-source repositories and five languages, never contributed upstream, each graded by a hand-written verifier rather than the tests that shipped with a merged fix. When an independent LLM judge re-reviews graded runs, it disagrees with DeepSWE's verifiers 1.4% of the time versus 32.4% for SWE-Bench Pro's inherited tests.

CheckpointBench is different. It is GitHub's internal multi-turn set, curated from real Copilot agentic sessions, each anchored to a public repository and an immutable commit so sessions replay deterministically. That makes it the most production-like of the three and the only one you cannot run yourself. It is also the row with the flattest quality delta. Both things are true at once, and only GitHub can check which one is driving the other.

Nvidia ran this play three weeks ago

The shape of this result is not unique to GitHub. NVIDIA NeMo Switchyard is an open-source orchestration layer doing the same job at the infrastructure level, and LangChain benchmarked it across 145 agent tasks: routing sent only 7% of turns to the frontier model, cut cost 74%, and gave up roughly six points of accuracy.

Six points is a much bigger concession than 1.5, but the trade is the same trade. Routing buys a large amount of money for a small-to-moderate amount of accuracy, and the whole market is currently discovering exactly where on that curve customers stop being happy.

Whether to turn it on

GitHub is explicit that first-turn, single-prompt coding tasks are the best place to start, with strong multi-turn performance on longer iterative sessions coming next. That is a real limit, not boilerplate: the escalation gate has only one draft to judge, so a long agentic session is exactly the case it is not yet tuned for.

• Try it if your Copilot spend is dominated by short, well-scoped tasks and you have a way to measure regression rate, not just cost.
• Wait if your team lives in long iterative agent sessions, which is where the preview explicitly is not optimized yet.
• Measure the escalation rate, not the average cost. That single number tells you whether the router is triaging your codebase well or just guessing cheaply.

Everything here is a research preview, and GitHub says results, models, workflows, availability, and names may change. Which is a polite way of saying the benchmark table you are optimizing against today may not describe the system you get next month.

Key Takeaways

• HydraFusion is live now in GitHub Copilot CLI on all Copilot plans via /experimental on, billed per token at each model's standard rate.
• It cut estimated cost versus Claude Opus 5 by 67% on TerminalBench 2.1, 36% on DeepSWE, and 65% on CheckpointBench.
• Quality only improved on TerminalBench 2.1 (+4.9 points). DeepSWE was 1.5 points down and CheckpointBench 0.1 points down.
• The savings come from routing, not from better models, so the quality deltas are the cost of imperfect triage.
• CheckpointBench is GitHub's internal benchmark and cannot be reproduced externally, so one of the three rows is unverifiable by you.
• NVIDIA's Switchyard shows the same trade at a steeper price: 74% cheaper across 145 agent tasks for about six points of accuracy.

Sources: The GitHub Blog: Project HydraFusion, GitHub Community Discussion #206492, VentureBeat, DeepSWE (arXiv 2607.07946), Terminal-Bench, LangChain: Switchyard agent routing benchmark, NVIDIA Technical Blog: NeMo Switchyard.