Alibaba Cloud's HiRoute team published a routing experiment on 22 October in which a mixed-model setup completed an engineering design review at 91.39%–92.01% below the cost of running the same task entirely on the strongest model in the plan. The headline invites the obvious conclusion — reserve the expensive model for the hard parts — but the more useful evidence sits in the task shape and in the single run where the cheap model failed. Those two details tell you when a number like this is likely to survive contact with your own workload.
The assignment was a messaging-system design review: research six candidate technologies, verify the official documentation, assemble a comparison, and deliver a memo on one decision — if the system fails midway and retries, how does it avoid processing the same business event twice, or missing it entirely? The team ran three configurations on the same source material with the same delivery requirements: all GPT-6 Astra; all Qwen-3.8 Flash; and a split in which Qwen produced the six research deliverables and Astra wrote the decision memo. According to the published configuration, Qwen ran at xhigh reasoning and Astra at medium.
Two of the three runs per configuration cleared the whole-delivery gate written for the assignment. Cost was computed across those qualifying runs, including every failed attempt and the routing evaluation itself, at API-equivalent list prices.
The measured results: research-check accuracy averaged 99.03% for the split and 99.72% for all-Astra. Critical decisions without major errors came out at 3/3 for the split, 3/3 for all-Astra, and 1/3 for all-Qwen. Whole-task cost for the split was 91.39%–92.01% lower, roughly one twelfth.
The 1/3 is the load-bearing number. Qwen's research was accurate — near parity on checks — and the gap opened only at judgment. Two of its three recommendations treated a guarantee that holds inside one component as a guarantee for the whole design. That is a composition failure, not a retrieval failure: more documents would not fix it, because the missing step is deciding whether a component-level property survives the interaction of components. The practical boundary for routing is therefore not hard-versus-easy but collect-versus-compose. Collecting, verifying and formatting tolerate a cheaper model well. Anything that requires reasoning about how guarantees compose under failure tends to need the stronger one, and the failure is quiet: the wrong memo reads as complete.
The published account does not isolate four variables, and each one matters if you want to move the number to your own work.
First, model and reasoning budget move together. Qwen ran at xhigh and Astra at medium, so the comparison changes two things at once. Part of the saving may come from spending more reasoning tokens on the cheap model rather than from choosing it. To attribute the effect to routing alone, the all-Astra arm would need the same per-stage reasoning settings; if Astra at high effort closes most of the decision gap, the routing gain shrinks.
Second, the task is unusually favourable. It is research-heavy and decision-light: six deliverables of collection feeding one memo. The saving is approximately the price ratio multiplied by the share of tokens that moved to the cheaper model. Work where every step is judgment — root-causing a race condition, reconciling two inconsistent specifications — leaves little to route, and the ratio collapses toward whatever it costs to redo the judgment after the cheap model gets it wrong.
Third, the baseline is list price. At API-equivalent rates the arithmetic is dominated by the ratio between the two models' per-token prices. On a subscription, a committed-throughput plan, or self-hosted capacity, the marginal cost of a token is not the list price, and a 92% cut in notional spend is not a 92% cut in budget.
Fourth, the sample is thin and the gate was written by the team shipping the router. Two qualifying runs per arm is not enough to separate a real effect from run-to-run variance, especially when one run per arm already failed. The definition of same quality is also deliberately modest — meeting the same delivery standard, not matching scores. That is the honest framing, but it means the gate is a floor rather than a measurement of closeness near the decision boundary. A 0.69-point accuracy gap with no published per-check counts and no blind review of the memos should be read as noise.
The second case study is where the engineering constraint shows up. Adding synchronous and asynchronous JSON stream iteration to HTTPX took 31 minutes 36 seconds, with three automatic model switches — Qwen to Astra, back to Qwen, then Astra again — and no human prompt or code patch. The router started on the economy model with a stage-competence floor of 0.5. After the first research stretch the preceding stage scored 0.41, below the floor, so Astra was asked to write the context summary for the handoff; after the summary the stage scored above the floor and Qwen continued; at the next handoff a score of 0.485 triggered the final upgrade, and Astra implemented the feature, ran tests and repaired the asynchronous iterator closure and encoding issues. The result passed 343 independent checks: 108 feature, 229 regression, 6 incrementality.
The switches happen only at context handoffs, and that is not a matter of taste. Changing models mid-task normally breaks the KV cache and forces a re-prefill of the context, so the router re-decides only when compaction or history rebuilding is already going to invalidate the prefix. Routing granularity is therefore bounded by context structure rather than by task difficulty. If an agent runs long stretches without compacting, the router has few legitimate decision points; if it compacts often, switches become cheap but the model keeps losing detail to summaries. Either way, the saving depends on a property of your harness, not only on the models.
The stage-competence score deserves the same scrutiny. A model-generated scalar compared against a fixed floor of 0.5 decided both upgrades, on values of 0.41 and 0.485 — fifteen thousandths below the line in the second case. Whether one threshold calibrated on one task family means anything on another is the open question, and the write-up does not answer it. The Sessions view, which records the model that actually ran, token usage and stage scores, is the right instrument for checking it: it makes each routing decision auditable after the fact.
What travels from this experiment is not the percentage. It is the allocation rule — spend reasoning capacity where guarantees have to compose, and let cheaper models do the collecting — plus two accounting habits the write-up demonstrates: keep the acceptance criteria and every failed attempt in the record, and include the routing evaluation in the cost. The 92% should be read as an upper bound on a favourable shape, measured twice, by the team that built the router. The transferable claim is narrower and still useful: when most tokens are collection and a small number of judgments decide the deliverable, routing by stage can cut cost by an order of magnitude without moving the decision. When judgment is spread evenly through a task, expect much less.
Sources: Alibaba Cloud Native Community, "HiRoute Smart Routing in Action: GPT-6 Astra × Qwen-3.8 Flash, Same Quality at 90% Lower Cost," 22 October 2026 — https://www.alibabacloud.com/blog/hiroute-smart-routing-in-action-gpt-6-astra-%C3%97-qwen-3-8-flash-same-quality-at-90%25-lower-cost_603659 ; "HiRoute is Open Source: Help Your Agents Do More and Your Subscriptions Go Further," same publication — https://www.alibabacloud.com/blog/hiroute-is-open-source-help-your-agents-do-more-and-your-subscriptions-go-further_603660