Stop Sending Every Agent Turn to the Frontier Model

The router is one function, and it uses nothing beyond the Python standard library. It takes a turn and the state of the trajectory, and it returns a tier. The default is the Workhorse tier. The router escalates a turn to the Frontier tier on four signals:

• The turn is a plan or decompose step, where the model splits the task into steps.
• The pre-commit gate returned exit 1Exit code The number a program returns when it ends. 0 means success; any other number, such as 1, means failure. twice in a row for the same file.
• The diff adds, removes or changes a public signaturePublic signature The name, parameters and return type of a function or class that other code calls.. The check compares the ASTAST Abstract syntax tree. The structure a parser builds from source code, such as functions, classes and signatures. of the source before and after the edit. It is not a regexRegex Regular expression. A short pattern that matches text, such as every run of digits in a line. on the diff.
• The Workhorse tier output failed schemaSchema A formal description of the shape data must have, such as which fields exist and their types. validation.

I cap escalations per trajectory. A file that fails the gate twice in a row is pinned to the Frontier tier for the rest of the run. Pinned means the router keeps the file there, so it does not send the file back down after one good turn. The cap still outranks the pin. Once the cap runs out, a pinned file drops back to the Workhorse tier like every other turn.

Timing matters too. The router routes plan turns and pinned files before any draft exists. It routes every other turn once the Workhorse tier has written its draft, because the signature and schema checks judge that draft. When the router escalates such a turn, the Frontier tier runs it again. Every decision goes into a log with its reason. A router I cannot audit is a router I will not trust when the bill arrives.

#!/usr/bin/env python3
"""route_turn: pick a tier for one agent turn from mechanical signals only.

Default is the Workhorse tier. The router escalates to the Frontier tier when
  (a) the turn is a plan or decompose step,
  (b) the pre-commit gate returned exit 1 twice in a row for the same file,
  (c) the diff changes a public signature (AST check, not a regex),
  (d) the Workhorse output failed schema validation.
Signal (b) pins the file: later edits and repairs on it go to the Frontier tier.
Plan turns and pinned files route before any draft exists. Other turns route once
the Workhorse draft exists, since (c) and (d) judge it. Escalations re-run on Frontier.
Escalations are capped per trajectory, and the cap wins over a pinned file.
A pinned trajectory sends every turn to the Frontier tier, outside the cap.
Every decision is logged with its reason. Standard library only.
"""
import ast
import json
from dataclasses import dataclass, field

WORKHORSE = "workhorse"
FRONTIER = "frontier"
ESCALATION_CAP = 8        # per trajectory; 20 percent of a 40-turn run
FAILURES_BEFORE_PIN = 2   # after this many gate failures a file stays on Frontier


@dataclass
class State:
    escalations: int = 0
    gate_failures: dict = field(default_factory=dict)   # path -> consecutive exit-1 count
    pinned: set = field(default_factory=set)             # paths pinned to the Frontier tier
    log: list = field(default_factory=list)              # one dict per routed turn
    pinned_trajectory: bool = False                      # every turn on Frontier, no cap


def _public(name: str) -> bool:
    return not name.startswith("_") or (name.startswith("__") and name.endswith("__"))


def public_signatures(source: str) -> dict:
    """Name -> signature for public defs and classes, methods included as Class.method."""
    out = {}

    def walk(body, prefix):
        for node in body:
            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and _public(node.name):
                out[prefix + node.name] = (type(node).__name__, ast.dump(node.args),
                                           node.returns and ast.dump(node.returns))
            elif isinstance(node, ast.ClassDef) and _public(node.name):
                out[prefix + node.name] = "class"
                walk(node.body, prefix + node.name + ".")

    walk(ast.parse(source).body, "")
    return out


def export_change(turn: dict) -> str:
    """Why a Python edit or repair touches a public signature, or '' if it does not."""
    if turn["kind"] not in ("edit", "repair") or turn.get("before") is None \
            or not str(turn.get("path")).endswith(".py"):
        return ""
    try:
        changed = public_signatures(turn["before"]) != public_signatures(turn.get("after") or "")
    except SyntaxError:
        return "python source does not parse"
    return "diff touches public export" if changed else ""


def route_turn(turn: dict, state: State) -> str:
    """turn = {"n", "kind", "path"?, "before"?, "after"?, "schema_failed"?}."""
    kind, path = turn["kind"], turn.get("path")
    tier, reason = WORKHORSE, "default"
    export = export_change(turn)

    if state.pinned_trajectory:
        tier, reason = FRONTIER, "pinned trajectory"
    elif kind == "plan":
        tier, reason = FRONTIER, "plan step"
    elif kind in ("edit", "repair") and path in state.pinned:
        tier, reason = FRONTIER, "file pinned after repeated repairs"
    elif export:
        tier, reason = FRONTIER, export
    elif turn.get("schema_failed"):
        tier, reason = FRONTIER, "workhorse output failed schema"

    if tier == FRONTIER and not state.pinned_trajectory:
        if state.escalations >= ESCALATION_CAP:
            tier, reason = WORKHORSE, "cap %d reached, stayed on workhorse" % ESCALATION_CAP
        else:
            state.escalations += 1

    state.log.append({"turn": turn["n"], "kind": kind, "tier": tier, "reason": reason})
    return tier


def observe_gate(turn: dict, state: State, exit_code: int) -> None:
    """Feed a gate result back; a second failure in a row pins the file."""
    path = turn.get("path")
    if path is None:          # a whole-suite run names no file to pin
        return
    if exit_code == 0:
        state.gate_failures.pop(path, None)
        return
    state.gate_failures[path] = state.gate_failures.get(path, 0) + 1
    if state.gate_failures[path] >= FAILURES_BEFORE_PIN:
        state.pinned.add(path)


def dump_log(state: State) -> str:
    return "\n".join(json.dumps(entry, separators=(",", ":")) for entry in state.log)

The decision log holds one JSONJSON A common text format for structured data. A parser needs the whole object; half of one fails. object per line. That format is boring on purpose. I can grep it, and I can load it into a spreadsheet. After the run, it tells me why a given turn cost what it cost.

{"turn":1,"kind":"plan","tier":"frontier","reason":"plan step"}
{"turn":2,"kind":"read","tier":"workhorse","reason":"default"}
{"turn":18,"kind":"edit","tier":"frontier","reason":"diff touches public export"}
{"turn":32,"kind":"repair","tier":"frontier","reason":"file pinned after repeated repairs"}
{"turn":38,"kind":"edit","tier":"workhorse","reason":"cap 8 reached, stayed on workhorse"}

The video below runs the router over a scripted 40-turn trajectory. It prints every decision, then prices the run three ways. The trajectory is a fixtureFixture A fixed, scripted input for a test or demo. It plays out the same way every time., not a recording of a live agent. What the video shows is the router doing what the code says it does.

Three failure modes follow. The router or the lab already has a fix for each one.

Cascade thrash. The Workhorse tier fails the gate, so the router escalates. The Frontier tier fixes the file. For the next edit on the same file, the router drops back to the Workhorse tier, and the gate fails again. With no cap, this loop pays for both tiers on every cycle. So the router caps escalations per trajectory. It also pins a file to the Frontier tier after the file's second gate failure in a row. The third attempt on a hard file goes to the Frontier tier and stays there until the cap runs out.

KV-cache prefix loss on a tier switch. The cached input price assumes that the start of the prompt, its prefix, is already stored on the model that serves the turn. After a tier switch, the other model has never seen that prefix. So the first turn after a switch is a cold prompt, billed at that tier's uncached rate. At the lab defaults, a cold Frontier tier turn on Gemini 3.1 Pro costs $0.0880 instead of $0.0592. The lab's cold-cache preset sets the hit rate to zero, so you can see the worst case for a router that switches often. If your escalations come in clusters, the cost sits between the warm and cold numbers. If they alternate turn by turn, you are close to cold.

Trajectories that should never be routed. Some runs deserve the Frontier tier from the first turn. One is greenfield design: new code, with no gate to fail yet. Another is a security-sensitive change, where the failure is a wrong edit that passes the tests. A third is a refactor across several repositories, where the plan must hold across contexts the Workhorse tier will not see. For these I pin the whole trajectory, and the router has a mode for that. Set pinned_trajectory on the state, and every turn returns Frontier with the reason "pinned trajectory", outside the cap.

Latency moves the same way as cost. A Workhorse tier turn returns faster, in wall-clock time, than a Frontier tier turn on the same prompt. How much faster depends on your region, your prompt size and the hour. Measure it on your own traffic and enter the numbers into the lab, rather than taking a figure from me.

• Flip the default. Route every turn to the Workhorse tier, and make the plan turn the only escalation. Watch the gate pass rate for a day before you add the other three signals.
• Write the decision log before you write the router. Log one JSON line per turn, with the tier and the reason. If the reason field is ever empty or says "model asked for it", that is the bug.
• Put the escalation cap in the same config file as your spend cap. They are the same control at two different layers. The spend cap is the one that fires when the escalation cap is set wrong.