The Router System
Every prompt routed to the right effort and the right model.
Not every request deserves the same effort. A quick fact and a hard design problem both start as text in a box, but pouring the full engine into the fact is waste, and answering the design problem with a reflex is worse. The Router reads each prompt the moment it arrives and decides how hard to work and which model should handle it. You never pick a mode; it picks for you.
Why it exists
A system that treats every prompt the same drifts to a mediocre middle. It runs too slow and expensive on trivial work and too shallow on the work that actually matters. The whole value is in the spread: reflex-fast on a greeting, and willing to spend real depth on a doctrine rewrite.
Keeping that spread wide takes a deliberate call every time. The Router is what makes it. It exists so the fast things stay genuinely fast and the hard things get the whole system thrown at them, with sharp variation in between instead of one flat average.
How it works
The Router works in stages, cheapest first. When you submit a prompt, a classifier reads it and picks a mode: a plain reply, a quick native turn, or the full Algorithm. If it’s Algorithm work, the classifier also sets an effort tier from light to maximum.
The rule it uses is sharper than “how hard does this look.” It asks whether the ideal answer can be stated in one line before the work starts. A lookup or an opinion can, so it takes the fast route. An answer that has to be built by weighing messy evidence can’t, so it earns the full engine. A short question doesn’t get the fast lane just for being short.
That tier then picks an effort level, and the level picks a model: four rungs, from the strongest model for the hardest work down to a cheap fast one for simple lookups. Naming the choice as a level instead of a model means the whole lineup has one place to change when a better model arrives.
One more thing runs underneath. The main conversation can’t swap its own model partway through a turn, so the Router does its real work by programming the helper agents the task hands off to. The depth lives in those dispatched agents, aimed by that first read of the prompt.
When the Router is unsure, it rounds up. A timeout or an unclear read defaults to more effort, not less, because doing too little is the failure that actually hurts.
Where it fits
The Router runs before anything else and sets the terms the rest of the system works under. The Algorithm is its biggest customer: it reads the mode and tier the Router set, then runs its phases inside that budget. The Router decides the posture; the Algorithm executes it. Draw the line at “decide how to handle this” versus “do the work,” and it holds.
It keeps deciding, too. Every time a task fans out to a helper agent, the Router picks that agent’s model and effort again. So the same worker runs cheap and quick on an easy branch and heavy on a hard one, all inside a single request.
What it feels like
You just type. You don’t choose a mode or set a model, and you never flag a question as hard or easy. The system reads the request and matches its effort to it — a one-word answer comes back in a blink, and a real problem quietly gets the full treatment without you asking. When it works, the range is invisible. Simple things feel instant, hard things feel considered, and you never once had to tell it which was which.