2026-11-13 · 9 min read

Your Model Router Guesses Once. Your Agent Changes Its Mind at Step Nine

Isometric diagram of two connected hexagonal model nodes — a large violet planner and a smaller indigo executor — passing a document cube along a glowing indigo path, with a gray feedback loop returning and one green success node.

Every model router I have seen in production makes the same bet: read the first prompt, estimate how hard the task is, and lock in a model for the whole job. That estimate happens at the least informed moment in the entire task — before anything has been read, run, or broken.

Consider the prompt "fix the flaky test." Eleven characters of English. It could be a fixture with a hardcoded sleep, a ten-minute fix. It could be a race in a shared cache that only surfaces when CI runs four jobs in parallel, a two-day fix. No classifier separates those cases from the prompt, because the information is not in the prompt. It is in the repository, and somebody has to go look. The act of looking is what turns an ambiguous request into a task with a known shape — and by then, the router has already spent its one decision.

Difficulty Is a Property of the Trajectory, Not the Prompt

Static routing is a reasonable piece of engineering with a narrow domain of validity. It works when tasks are short, homogeneous, and self-describing: a summarization call, a classification call, a rewrite. In those cases the first prompt really does contain everything you need, and picking the cheap model is close to free money.

It breaks precisely where routing starts to matter — long, agentic tasks. Those tasks have a shape: explore, plan, execute, hit friction, repair, resume. The cost of work is not uniform across those phases. Reading a dozen files and holding a dependency graph in your head is frontier-model work. Renaming a function across nine call sites and running the test suite is not. When you route on prompt one, you either pay frontier prices for the mechanical eighty percent, or you hand the exploration phase to a model that will confidently invent a plan based on the two files it skimmed.

What a Mid-Trajectory Switch Buys

Google's Antigravity team shipped a version of this idea this week. Their Orchestrator option runs Gemini 4 Carbon — a frontier reasoning model — and Gemini 4 Hydrogen, a faster and cheaper one, in the same session, and switches between them as the work evolves. The published loop is worth reading slowly, because it is a design, not a slogan: Carbon starts read-only, explores dependencies, resolves ambiguities, and writes a plan with explicit triggers for when the plan should be reconsidered. Hydrogen then takes over to write the edits, bump packages, and run tests. If Hydrogen hits friction, it hands back to Carbon, which inspects the current state, repairs the plan, and resumes.

The numbers they report: near-Carbon success rates on Terminal-Bench 4.1, with roughly 24% less quota consumed and 19% faster completion on average. Hydrogen on its own scores 57% on Terminal-Bench 4.1 — more than triple the 18.2% of the fast model it replaces — and 51 on the Artificial Analysis Intelligence Index, or 54 at its highest thinking setting.

Ignore the vendor framing and look at the structure. The frontier model's first job is not to write code. It is to produce a plan. The plan is the object that makes the handoff cheap, and that is the part most teams building their own router leave out.

There is a second reason the read-only phase is first. Exploration is where the model's mistakes are cheapest. A wrong plan is one page a human can reject in thirty seconds; a wrong implementation is a forty-file diff nobody wants to review. Spending frontier tokens on the phase where errors are still cheap is the actual argument, and it holds whether or not you use a vendor's orchestrator.

A Handoff Costs Whatever the State Costs

There are two ways to hand a task from one model to another. You can pass the conversation and let the next model re-derive the context, or you can pass a written artifact that states what is true. The first is nearly free to build and expensive to run: the cheap model re-reads every file the expensive model read, re-runs the same commands, and re-derives the same conclusions — sometimes correctly, often not. You have paid for exploration twice, and the second pass was done by the weaker model.

The second approach costs you an artifact and a habit.

That 24% quota saving is a net figure. It is what remains after handoff overhead has already been subtracted. Which tells you two things: the overhead is real, and it is bounded — but only because the plan exists. Remove the plan and the same architecture becomes slower and more expensive than a single model, which is exactly how teams conclude that routing does not work.

Do the arithmetic before you build anything. If your fast model costs roughly a tenth as much per token as your frontier model, and eighty percent of your steps are mechanical, moving them down cuts the bill by about five times. If the handoff adds twenty percent back in re-reading and re-planning, your net is closer to four. That is still a large win — but it is a win that disappears entirely if the re-reading pass has to rediscover context from scratch, because the cheap model is the one paying for that recovery.

The Handoff Contract

If you are building this yourself, the artifact is the product. Write it to a file in the workspace, not into the chat history, so that both models and any human reviewer read the same page. It needs six things:

  • The goal in one sentence, in the user's words, not the model's summary of them. Summaries drift.
  • The plan as numbered steps, with the current step marked. This is what lets the executing model start in the middle instead of at the beginning.
  • Invariants. Files out of scope. Public interfaces that must not change signature. The exact command that runs the tests. Constraints are cheap to write and expensive to rediscover.
  • What has already been tried and why it failed. This is the section people skip and the one that saves the most money. Without it, the executing model will cheerfully re-attempt the fix that was abandoned forty minutes ago.
  • Escalation triggers — the conditions under which the work comes back to the expensive model.
  • A definition of done. A specific test passing, a specific error gone, a specific diff reviewed. "Looks good" is not a stopping condition.

Version that file with the repository. A later run can then see how the last one ended, and you get a free audit trail of where the cheap model struggled — which is the raw material for improving your plan template instead of guessing at it.

Escalate on Evidence, Not on Vibes

The return path is harder than the outbound one, because a model running at speed does not reliably know when it is stuck. It produces plausible diffs. The tests stay green because it adjusted the tests. Asking a model to self-report confusion gets you an optimistic answer roughly every time. So the triggers have to be mechanical, checked by your harness rather than by the model's judgment:

  • The same test fails after two genuinely different fixes.
  • Twenty tool calls pass with no change in the set of failing tests.
  • The diff touches a file outside the scope declared in the plan.
  • The diff grows across two consecutive attempts instead of shrinking.
  • The fix turns out to require a contract change — a schema, a public interface, a migration.

De-escalation deserves the same treatment. Once the remaining work is specified and mechanical, move down and stay down. Bouncing a task back and forth on every step adds latency and burns the frontier quota you were trying to protect. A useful ceiling: if a task crosses more than three handoffs, either your plan is too vague or the task really is frontier-only, and you should stop pretending otherwise.

When Not to Route

The honest trade-off is that you are buying cost efficiency with machinery: a plan format, a trigger set, per-model evaluation, and logging. That is worth it under some conditions and a waste under others.

  • Short tasks. Under roughly ten steps, handoff overhead dominates. Pick one model and move on.
  • Failures that are expensive to detect. Cheap models fail quietly — a diff that compiles, passes shallow tests, and is subtly wrong. If your review process cannot catch that, routing converts a token bill into a review cycle or an incident.
  • No per-model evaluation. If you cannot score the fast model on your own task set, you are not routing, you are guessing with extra steps. A vendor benchmark is a starting point, not a decision.
  • Latency-critical inner loops. Every handoff is a round trip with a context rebuild. Nineteen percent faster on average can still mean a two-second stall at the wrong moment in an interactive tool.

What to Measure

Four numbers, all cheap to instrument once the handoff lives in a file: success rate per model per task class, quota per completed task rather than per request, handoffs per task, and rework rate after a handoff — how often the expensive model has to undo what the cheap one did. That last one is the tell. High rework means your plan is underspecified, and no amount of routing cleverness will repair an underspecified plan.

Routers are classifiers. Orchestrators are protocols. A classifier makes one guess and lives with it; a protocol has states, transitions, and a written record of where it has been. The second is more work to build, and it degrades gracefully — which is the only property that matters when the task turns out to be harder than the first prompt suggested.

Key Takeaways

  • A router that classifies difficulty from the first prompt is guessing at the moment of least information; difficulty lives in the repository, not the sentence.
  • The winning pattern is plan-then-execute across two models: frontier model explores read-only and writes a plan, cheap model edits and runs tests, friction sends work back up.
  • Handoffs are only cheap if the state is written down as a file: goal, numbered plan, invariants, failed attempts, escalation triggers, definition of done.
  • Escalate on mechanical evidence — repeated failures, stalled tool calls, out-of-scope diffs, growing diffs — not on a model's self-assessment of confusion.
  • Skip routing entirely for short tasks, for failures your review can't catch, and whenever you have no evaluation of the cheap model on your own workload.

[ Call to action ]

Ready to scale your engineering team?

Tell us the roles you need to fill and we'll get back within 24 hours.