GitHub's new Copilot router does not give you a discount. It gives you a different bill. Project HydraFusion, shipped into the Copilot CLI on September 4, charges for every model it invokes at that model's published rate — and two of its three execution patterns fire two or three billed calls to answer one prompt. The headline number, 67% lower cost than Claude Opus 5, is a measurement of a benchmark's task mix, not a price change on your account.
The timing matters more than the feature. Your included Copilot credit pool shrank three days before this landed. If you turn /experimental on across the fleet this week on the strength of a blog post, you will be running an unpriced experiment against a smaller allowance.
What GitHub Actually Shipped, and What It Bills
HydraFusion is a runtime planner inside GitHub Copilot that picks an execution pattern per task, not a cheaper model. GitHub describes three patterns: Single — "one selected model solves the task directly"; Cascade — "an efficient model drafts a solution and a quality gate decides whether to accept it or escalate to a stronger model"; and Critique — "one model drafts a result, an independent read-only critic from a different model family reviews it, and the drafting model revises once."
Count the billable calls. Single is one. Cascade is one on the happy path and two when the gate escalates. Critique is three, by construction — draft, review, revise — and the critic is explicitly from a different model family, so a single turn can carry two vendors' token rates.
GitHub is not hiding this. Its own billing line reads: "Usage is based on the tokens consumed by the models HydraFusion uses, priced at each model's standard rate." A GitHub engineer put it more plainly in the launch discussion: "There is no separate HydraFusion charge. You pay for the constituent models it runs, so the cost of a turn is the sum of its phases." The blog's own evaluation guidance tells you to "aggregate cost and usage across every workflow leg, including drafting, critique, revision, escalation, retry, and fallback."
Six legs. That is the unit of billing, and it is the sentence that should be on your slide, not the 67%.
The 36-67% Spread Is the Story, Not the 67%
Across the three benchmarks GitHub published, the measured saving moved by 31 percentage points — and the benchmark most like enterprise work saved least. Here is the full table from GitHub's post, which VentureBeat summarised as cost wins in every test and a quality match in only one:
| Benchmark | Quality vs Opus 5 | Estimated cost vs Opus 5 |
|---|---|---|
| TerminalBench 2.1 | +4.9 points | 67% lower |
| CheckpointBench | −0.1 points | 65% lower |
| DeepSWE | −1.5 points | 36% lower |
Terminal-Bench scores agents on command-line software engineering tasks — navigating a codebase, running commands, fixing a bug through a shell. CheckpointBench, the middle row, is GitHub's own: an "internal multi-turn benchmark curated from real GitHub Copilot agentic coding sessions," which GitHub says produces "a realistic evaluation set that closely mirrors production agentic sessions." It is the one row of the three nobody outside GitHub can replay. DeepSWE is a different animal. The paper describes it as "113 original, long-horizon software engineering tasks" across five languages and 91 repositories, written from scratch and never contributed upstream, where the reference solutions "touch 5.5x more code" than SWE-Bench Pro's despite shorter prompts.
That is the shape of the work your platform team actually does: multi-file changes with long execution paths. On that benchmark the router returned the smallest saving and the largest quality loss simultaneously. The relationship is not mysterious — a cascade saves money when the quality gate accepts the cheap draft, and a gate accepts fewer drafts as tasks get harder. Harder work escalates more, and escalation is what you pay for.
GitHub also scopes the preview narrowly: "for this preview, first-turn, single-prompt coding tasks are the best place to start," adding that "we'll be focusing on strong multi-turn performance with longer, iterative sessions next." The measurement is not purely single-prompt — CheckpointBench is multi-turn — but the tuning target for this preview is, and long iterative agent sessions are the case GitHub says it has not optimised yet.
Where a Cascade Stops Saving Money
A cascade stops saving money at the escalation rate where the draft plus the escalated solve costs more than going straight to the strong model — and you can compute that from GitHub's own published rates. Per the Copilot models and pricing page, Claude Opus 5 bills $5.00 per million input tokens and $25.00 per million output. Claude Sonnet 5 bills $2.00 and $10.00 — exactly 0.40x Opus on both sides. Claude Haiku 4.5 bills $1.00 and $5.00 — exactly 0.20x.
Normalise an always-Opus turn to 1.0. A cascade costs the draft on every turn plus a full strong-model pass on the share of turns that escalate. Call that share e:
- Sonnet 5 drafting: 0.40 + e. Break-even at e = 60%.
- Haiku 4.5 drafting: 0.20 + e. Break-even at e = 80%.
Two caveats, both in the same direction. GitHub does not publish the roster — a GitHub engineer in the launch discussion said "the lineup shifts as new models ship and our evals show what performs best, so we don't publish a fixed roster" — so those two drafters are illustrative substitutions, not HydraFusion's actual pool. And the arithmetic assumes each pass burns similar token volume, which flatters the cascade: the escalated call also carries the draft and the gate's verdict in its context, so the real break-even sits below 60% and 80%. We covered the same compounding effect when one pull request billed 156 million tokens on cache reads alone.
Critique is harder to defend on cost. Three billed calls answer what a single-model turn answers in one, and a read-only critic still ingests the entire draft plus the surrounding context before it writes a verdict. That pattern only beats a direct Opus turn if the drafting family is dramatically cheaper — the same judgment-cost arithmetic that made pooling LLM-judge verdicts worth $800 at JPMorgan instead of re-running them.
And a cheaper model is not automatically a cheaper turn. We measured the inversion directly: Haiku burned more tokens than Sonnet on the same spec because it took more attempts to get there. Rate per token is not cost per task.
Your Included Credits Shrank on September 1
Copilot's promotional credit allowance expired three days before HydraFusion shipped, and the drop is large. GitHub moved every Copilot plan to usage-based billing on June 1, 2026, retiring premium request units in favour of AI Credits consumed "based on token usage, including input, output, and cached tokens, according to the published API rates for each model."
Per GitHub's usage-based billing documentation, the standard monthly included amounts are 1,900 credits per user for Copilot Business and 3,900 for Copilot Enterprise. During the promotional window that ran June 1 to September 1, those figures were 3,000 and 7,000. One AI credit is $0.01. So a Business seat's included usage fell from $30 to $19 a month — a 37% cut — and an Enterprise seat's from $70 to $39, a 44% cut.
That is the environment a "67% lower cost" headline just landed in. Engineering leaders watching September credit burn spike against a smaller pool have every incentive to flip the router on and hope. This is the second time Copilot's meter has moved out from under buyers this year; the June transition already turned a $39 seat into a $750 month for teams that had not re-baselined.
What happens at the ceiling is a policy choice you have already made by default. GitHub's docs are explicit: with additional usage allowed, "usage continues at published per-credit rates" and is charged to your organization; with it disallowed, "usage is blocked until the next billing cycle." There is no soft landing — the June billing post also confirmed that "fallback experiences will no longer be available."
The Case for Turning It On Anyway
The steel-man is strong, and it deserves stating before the caveats bury it. A cascade is a genuinely sound piece of engineering economics: you pay a cheap model on every request and a frontier model only on the requests that need one. Where the gate is well calibrated and the work is routine, that is strictly better than paying frontier rates for boilerplate.
The CheckpointBench row is the honest headline, and it is the strongest evidence against everything above. That is the benchmark GitHub says "closely mirrors production agentic sessions," and it returned a 0.1-point quality delta at 65% lower estimated cost — not a rounding trick, and a trade most teams would take without argument. If it transfers, the escalation-rate worry is academic. The catch is that CheckpointBench is GitHub's own internal benchmark, curated and scored by the vendor on sessions nobody else can replay: the row that most resembles your work is also the only one you cannot audit. And at least one developer in the launch thread reported a real result: "the credits burn has been 10% of what I'm used to."
That number is one person's workload, unaudited, on a preview. It is also exactly the kind of evidence you should be generating on your own repositories before committing a fleet. The pattern is familiar from the broader routing market — OpenRouter raised $113M on a 30-85% savings range, and a range that wide is a statement about workload variance, not about the router.
What You Cannot Measure Yet
Three attribution gaps stand between you and a defensible number, and all three are GitHub's to close. First, the roster is unpublished by design, so you cannot price a turn in advance. Second, you cannot see which models ran: a developer in the thread asked for exactly this — "the most useful single addition would be the name of the model chosen for the implementation phase" — and it does not exist today. Third, there is no cost-quality control. Another developer asked for one: "I wish I could set a cost/quality temperature."
There is precedent for the opacity. GitHub's pricing page already notes that "Copilot code review is an exception — the model is selected automatically and is not disclosed." HydraFusion extends that pattern from one feature to your main coding loop.
Net effect: your invoice becomes a single aggregate against a model mix you cannot inspect, chosen by a planner you cannot tune, on a roster that changes without notice. That is a governance problem before it is a cost problem, and it is the same visibility gap that makes managed AI gateways unable to cap spend rather than merely observe it. Benchmark tables will not settle it either — as we found scoring agent patches, the scope of what an agent touches drives cost as much as whether it succeeded.
Three Moves Before You Enable It Fleet-Wide
This Week:
- Export your last 30 days of AI Credit consumption per user from the billing page, before anyone enables
/experimental. Without that baseline you have no counterfactual, and September's numbers are already distorted by the promotional expiry. - Enable it for one bounded cohort — a single team on a single repository — and leave the rest of the fleet on an explicitly chosen default model.
- Set the universal user-level budget. GitHub's budget documentation calls it "your primary tool for ensuring fair access to the shared pool," and warns that "any budget set to $0 USD stops usage immediately." Pick a real number, not zero and not infinity.
This Month:
- Measure cost per completed task, not cost per turn. The denominator is merged pull requests or closed tickets. A router that halves per-turn cost and doubles turns has saved you nothing.
- Split the measurement by task class. One-shot terminal fixes versus multi-file changes, tracked separately. The 36-to-67% spread is precisely this variable, and your mix is not GitHub's.
- Ask your GitHub account team three questions in writing: what escalation rate are we seeing, what pattern mix, and when does per-turn model attribution ship.
Before Your Next Billing Cycle:
- Decide the additional-usage policy deliberately. Allowed means uncapped spend at published rates; disallowed means engineers stop mid-task with no fallback. Both are defensible; drifting into one is not.
- Re-run the break-even with whatever drafter you can confirm. If your escalation rate lands north of 60% on a mid-tier drafter, the router is costing you money and a fixed model choice is cheaper.
The Bottom Line
Every platform shift arrives as a headline percentage and settles as an invoice. Reserved instances were going to cut your cloud bill until the utilisation numbers came in. Serverless was cheaper per request right up to the point somebody counted the requests. HydraFusion belongs to the same family: the mechanism is real, the engineering is sound, and the saving is entirely contingent on a variable the vendor measured on its own corpus and will not measure on yours.
The 36-to-67% spread across three benchmarks is not noise to be averaged away. It is the router telling you, in advance, that your answer depends on your work.
A router that bills every leg is not a discount. It is a bet on how often the cheap model is right — and GitHub will not yet tell you the odds.
Continue Reading
One PR Billed 156M Tokens. Cap the Reads, Not the Rate. Anthropic Cut Cache Reads 75%. Opus 5 Still Undercuts It. Haiku Burned More Tokens Than Sonnet. Spec It in Code. Copilot's New Billing Turned a $39 Seat Into $750/Month. AI Gateway vs API Management: No Managed Gateway Caps Your Spend Claude Matched the Patch. Qwen Overshot. Score the Scope. A Third Skipped a SaaS Buy. Now Price the Run Cost. OpenRouter's $113M Bet: Intelligent Routing Slashes AI Inference Bills 30-85%