Most "which model should I use" decisions in AI coding tools boil down to a dropdown: pick the cheap fast model for boilerplate, pick the expensive slow one when you're stuck. GitHub's Project HydraFusion, now in research preview inside Copilot CLI, treats that as the wrong question entirely. Instead of picking a model per session, it picks an execution pattern per task, using multiple models within a single turn.
The core idea: three patterns, not one model
HydraFusion is selectable like any other model in Copilot CLI's /experimental configuration, but under the hood it decides — per task — which of three patterns to run:
- Single — one selected model solves the task directly, no orchestration overhead. Used when the task's capability signals (reasoning depth, tool-use complexity) suggest a single competent model is enough.
- Cascade — an efficient, cheaper model drafts a solution first. A quality gate then decides whether to accept that draft or escalate to a stronger model. Most simple refactors and boilerplate should resolve at the cheap tier.
- Critique — one model drafts a result, a second model from a different model family reviews it as a read-only critic, and the drafting model revises once based on that critique.
The Critique pattern is the interesting one architecturally. Using a different model family as the critic — not just a bigger model from the same family — is a deliberate hedge against a single model's blind spots. Two models from the same training lineage tend to share failure modes; a genuinely different model is more likely to catch a mistake the first one is confidently wrong about.
What this looks like in practice
# Select HydraFusion instead of a fixed model
copilot config set model hydrafusion --experimental
# A routine task likely resolves via Single or a cheap Cascade draft
copilot "rename this variable across the module and update its JSDoc"
# A task with ambiguous requirements is more likely to trigger Critique
copilot "refactor this auth middleware to support both JWT and session cookies without breaking existing routes"You don't choose the pattern yourself — HydraFusion's routing model reads capability signals from the prompt (estimated reasoning depth, code generation complexity, debugging vs. authoring, tool-use requirements) and picks a workflow to optimize for the balance of performance, cost, and latency.
The numbers that matter
On GitHub's internal CheckpointBench, HydraFusion lands within 0.1 percentage points of a top-tier frontier model's solo performance, at roughly 65% lower cost. That gap is close enough that, for most day-to-day coding tasks, the cost savings from routing simple work to cheap models plus escalating only when needed outweighs the latency cost of occasionally running two models instead of one.
The tradeoff that number doesn't show: Cascade and Critique both add latency versus a Single-pattern call to the same top model, since you're paying for a draft-then-review round trip on tasks that get escalated. For latency-sensitive interactive use (an inline completion, say) that overhead is a real cost; for an autonomous background task where wall-clock time matters less than output quality per dollar, it's close to free.
How this compares to manual model switching
Most of us already do a rough version of this manually — start with a fast model, escalate to a stronger one when the fast model visibly struggles. HydraFusion's value is that the escalation decision happens before you see a bad answer, based on task signals, rather than after you've already wasted a round trip on a model that was never going to solve it. The Critique pattern goes further than what manual switching typically does — most engineers don't habitually re-run a solved task through a second model family just to sanity-check it, even though that's exactly the kind of check that catches subtle bugs before they reach review.
Our take
This is a research preview, and the interesting failure mode to watch for is routing overhead on tasks that are ambiguous enough to trigger Critique but not actually complex enough to need it — you'd be paying for a second model's opinion on something a single competent model already had right. We'd want to see routing-decision telemetry before recommending it as a default for latency-sensitive workflows.
For batch and CI-driven coding tasks — automated refactors, dependency bumps, scripted migrations — where wall-clock latency matters less than getting a correct answer without babysitting a model choice, HydraFusion is worth trying now. The cost profile alone (near-frontier quality at a fraction of always running the top model) makes it a reasonable default for anything that doesn't need an interactive response in under a second.
Sources: