Model routing is a runtime layer that decides, for each individual request, which language model or sequence of models should serve it, so easy work costs pennies and only genuinely hard work burns the flagship model. It matters now because GitHub made routing the default path in Copilot on 28 October 2026 with Copilot Fusion, turning the model picker into an effort dial and pushing the whole industry toward multi-model orchestration.
Key takeaways
Model routing replaces one-model-fits-all with three patterns: Single (one model), Cascade (cheap draft, escalate on failure) and Critique (draft, parallel review, revise).
GitHub Copilot Fusion, generally available since 28 October 2026, implements all three and bills each model at its standard rate, with a 30% discount on paid plans through 30 November 2026.
Artificial Analysis reported Fusion Max within two points of Claude Code running Opus 5.5 Max at about half the average API cost per task, but that is a vendor-published benchmark, not an independent audit.
The judge is the whole game in a cascade: a weak quality gate escalates everything (no savings) or accepts garbage (no quality).
You can build a working cheap-first cascade router in Python tonight, and the section below gives you the code.
Why is model routing suddenly the default?
At GitHub Universe on 28 October 2026, GitHub took Copilot Fusion generally available on all Copilot plans across VS Code, the Copilot app, Copilot CLI and JetBrains IDEs. Fusion is not a model. As GitHub's chief product officer Mario Rodriguez told VentureBeat, it is an orchestration engine at runtime: you pick an effort level (Standard, High or Max) and the router decides, per prompt, which models to use and how to combine them. Fusion merges two earlier pieces: the Project HydraFusion multi-model orchestration research preview from September 2026 and Copilot's automatic model selection.
The same week, the economics moved with the technology. Anthropic filed its S-1 targeting a roughly $100 billion IPO, with first-half 2026 revenue of $16.3 billion and net revenue retention near 900%, according to the weekly developer-tools roundup from OriginBrief. When the model vendors are valued on usage, burning the flagship model on every keystroke is the most expensive habit a team can keep.
Fusion's pricing is straightforward: you pay for each model it uses at that model's normal rate, with no separate Fusion fee, and paid plans get 30% off model costs under Fusion through 30 November 2026. Fusion only draws from models your enterprise or organisation policies allow, and Artificial Analysis identified Claude Opus 5.5, Claude Sonnet 5.5, GPT-6 Astra and GPT-6 Sol among the models in its pool.
What do the Single, Cascade and Critique patterns actually do?
GitHub's docs name three execution patterns, and they are worth memorising because they are exactly the patterns engineers hand-roll in multi-agent systems:
Single: one model handles the request end to end. Everyday edits and questions.
Cascade: an efficient model drafts; a quality check accepts it or escalates to a stronger model. Work that is usually easy but sometimes hard.
Critique: one model drafts, several models critique in parallel, the drafter revises. Hard bugs and multi-file changes.
Cascade is the budget path: pay for a cheap attempt and let a checker decide whether it is good enough before spending on a better model. Critique is the quality path: a second set of eyes when correctness matters more than speed. The two failure modes of a cascade are asymmetric and both hurt. A strict judge escalates everything, so you pay the cheap call plus the expensive call on every request and save nothing. A loose judge accepts bad drafts, so your quality floor is whatever the cheap model feels like. Either way, the router is only as good as its gate.
The honest numbers on Fusion's headline claim
GitHub's headline number comes from testing published on 28 October by Artificial Analysis on its Coding Agent Index: Fusion Max averaged $5.59 per task against $11.42 for Claude Code running Opus 5.5 Max, roughly 51% less, scoring within two points and finishing in about 40% less time per task. That is a genuinely impressive ratio, but treat it as a vendor-published benchmark: GitHub's own launch materials quote it, and no independent audit of the methodology exists yet. Two caveats from the docs themselves deserve attention: Fusion has no context window of its own (each step uses the running model's limit, and the displayed figure is the smallest in the pool), and if a discarded draft already edited your files, those edits are not rolled back automatically. Review before you commit.
Can you build a cheap-first cascade router yourself?
Yes, and the pattern is small enough to read in one sitting. The pieces are: a complexity signal that guesses whether the cheap model has a chance, a draft call, a judge, and cost accounting so you can see whether the router is actually saving you money. Below is a working skeleton with mocked model clients; swap the two functions for real API calls and you have a production-shaped router.
import re
from dataclasses import dataclass, field
Illustrative rates (USD per 1k tokens), not live prices.
CHEAP_RATE = 0.00015
FLAGSHIP_RATE = 0.003
COMPLEX_SIGNALS = [
r"\b(refactor|rewrite|architecture|multi-?file)\b",
r"\b(race condition|deadlock|concurrency)\b",
r"\b(root cause|why (is|does)|debug)\b",
r"
```", # a code block is attached: review needs care
]
def looks_complex(prompt: str) -> bool:
long_prompt = len(prompt.split()) > 120
return long_prompt or any(re.search(p, prompt, re.I) for p in COMPLEX_SIGNALS)
def cheap_draft(prompt: str) -> tuple[str, int]:
# Replace with your cheap model call; returns (text, tokens_used).
return "Draft answer for: " + prompt[:80], 400
def flagship_answer(prompt: str, draft: str) -> tuple[str, int]:
# Replace with your flagship call, seeded with the failed draft.
return "Revised answer for: " + prompt[:80], 600
def judge(draft: str, prompt: str) -> bool:
"""Toy gate. A production judge is tests, a rubric-scored
LLM-as-judge, or deterministic checks (schema, lint, types)."""
needs_code = "code" in prompt.lower() or "
" in prompt
if needs_code and "
return False
return 20 < len(draft) < 4000
@dataclass
class RouteDecision:
tier: str
escalated: bool
judged_ok: bool
cost_usd: float
def route(prompt: str) -> tuple[str, RouteDecision]:
draft, cheap_tokens = cheap_draft(prompt)
cost = cheap_tokens / 1000 * CHEAP_RATE
ok = judge(draft, prompt)
if ok:
return draft, RouteDecision("cheap", False, True, cost)
answer, flagship_tokens = flagship_answer(prompt, draft)
cost += flagship_tokens / 1000 * FLAGSHIP_RATE
return answer, RouteDecision("flagship", True, False, cost)
for p in ["summarise this changelog", "debug the race condition in our worker pool ```
"]:
text, d = route(p)
print(f"tier={d.tier} escalated={d.escalated} cost=${d.cost_usd:.5f}")
The structure is deliberate: the cheap model's draft is handed to the flagship on escalation, so the expensive call starts from something rather than from zero. The complexity heuristics are the weakest part on purpose. Real routers score capability signals per request, the way Fusion scores reasoning, code generation, debugging and tool use, then choose the cheapest pattern that clears the quality bar.
Does the maths actually save money?
Do the ledger honestly, because a cascade adds calls. Take 1,000 requests a day, 2,000 tokens each, an 80% judge pass rate, illustrative rates of $0.15 per million tokens for the cheap model and $3 for the flagship. All-flagship costs $6.00 a day. The cascade: 800 cheap-only requests at $0.00075 each ($0.60), plus 200 escalations at roughly $0.00675 each ($1.35), totalling $1.95. That is a 67% saving, but it assumes the judge is free, which it is not: an LLM judge adds its own tokens to every request. If your judge costs as much as the draft, the break-even escalation rate moves against you fast. The cheapest possible judge is one that costs nothing: unit tests, lint, schema validation, or a deterministic rule. This is why Cascade shines for code, where tests are a perfect judge, and struggles for open-ended prose, where the judge is another expensive call.
When should the router escalate, and when is one model enough?
Escalate when the judge says no, obviously, but the interesting decision is the fast path before the draft. Skip the cheap stage entirely and go straight to the flagship when the request shows strong complexity signals: multi-file changes, ambiguous requirements, security-sensitive code, or anything where a wrong draft costs more to verify than a right answer costs to generate. Use Single with a mid-tier model for everyday edits and questions; Fusion Standard does exactly this. Reserve the Critique pattern for hard bugs and refactors where a second opinion is cheaper than a wrong merge. Our earlier guide on cutting the LLM API bill covers the sibling techniques, prompt caching, batching and semantic caching, that stack with routing rather than competing with it.
What is still unknown about model routing?
Plenty. Nobody has published long-term data on how routers behave as model prices shift under them; a router tuned for today's price gap quietly degrades when the cheap model gets pricier. Judge quality remains the open research problem: an LLM judge inherits the same failure modes as the drafter, and there is no agreed standard for calibrating one. Fusion's headline benchmark is vendor-published, and the 30% discount that makes its maths attractive expires on 30 November 2026. Finally, the cheap first stage does not have to be a hosted model at all. A small open-weight model running on your own hardware, the approach in our laptop field guide, is the cheapest possible drafter for a cascade, and for EU teams it keeps the easy requests inside your own infrastructure. The pattern to remember is not Copilot Fusion itself but what it standardised: route first, spend second.
Originally published on LogicStack. Run the code examples right in your browser with our free interactive Python and SQL playgrounds — no setup, no sign-up.
