agent-routing

name	agent-routing
description	Decide which model (Haiku/Sonnet/Opus) and effort level each subagent gets, when to cascade cheap-first behind a verifier, and how to run improvement loops safely (evaluator-as-selector, stop on regression). Use when spawning subagents via the Agent or Workflow tools, when fanning out more than a handful of agents, or when the user asks which model or effort a task should route to. Grounded in measured calibration data (references/calibration-2026-07-15.md), not vibes.
compatibility	Designed for Claude Code / Claude Code on the Web — assumes an orchestrator with Agent/Workflow subagent tools exposing per-call model and effort options. Not applicable to claude.ai chat use.
metadata	{"author":"Oskar Austegard and Claude (Fable 5)","version":"1.2.0"}

Agent Routing — model + effort selection for subagents

Before spawning any subagent, answer one question: is the task mechanically checkable, or does it require judgment? Checkable → Haiku at effort: 'low' behind a verifier. Judgment → up-tier. The routing table refines this split; the rest of the skill governs cascades and loops.

Do not up-tier checkable work "to be safe." Measured Haiku 4.5 failure on every checkable task family tested is ≈0, at effort: 'low', with chain-of-thought suppressed (evidence: references/calibration-2026-07-15.md). The burden of proof is on routing up: reflexive up-tiering costs 3–5× for safety that the data says is imaginary. Spend effort, not tier, and only where reasoning depth demonstrably falls short.

To turn a judgment-shaped task INTO a Haiku-executable one (explicit procedures, n-shot examples), use the sibling down-skilling skill. This skill decides the routing; that one engineers the prompt.

Context handoff — routing picks the tier; the prompt carries the context

Subagents inherit nothing: not the conversation, not loaded skills, not the existence of artifacts already on disk. Every index, scan output, artifact path, or tool-invocation recipe the orchestrator relies on must be serialized into the subagent's prompt (or written to a file the prompt points at). Otherwise the agent falls back to blind rediscovery — and the tier premium is spent on crawling, not judgment. A Sonnet with no handoff wastes more than a Haiku with a good procedure.

This is the context-side twin of down-skilling: that skill engineers the procedure into the prompt; this rule makes the artifacts and tools travel with it. Checklist per spawn: (1) artifact paths + how to query them, (2) tool commands verbatim (interpreter path included — subagents don't know your venv), (3) explicit anti-patterns ("no ls/glob discovery"), (4) an output spec. Skills that orchestrate fan-outs should embed this (see exploring-codebases for the worked exploration case).

Evidence: 2026-07-16, four Sonnet Explore agents launched onto a 2,300-file repo without the handoff opened with ls crawls despite a full tree-sitter symbol index sitting on disk; relaunched with per-agent index slices + the verbatim tool command + anti-crawl rules, discovery cost dropped to ~zero.

Routing table

Task shape	Model	Effort	Verify with
Extraction, classification, format transforms, schema-bound output	haiku	low	schema / spot-check
Closed-form computation, state tracking, multi-hop lookup	haiku	low	deterministic check
Constraint-bound generation (exact counts, required tokens, lipograms)	haiku	low	mechanical checker
Bulk scans/greps, per-file summaries, fan-out reads	haiku	low	sample audit
Code edits with tests available	haiku first	low–medium	run the tests
Judging / scoring another model's output	sonnet+	medium	— (judge ≠ worker)
Ambiguity resolution, novel synthesis, architecture, taste	sonnet/opus	high	human or panel
Long-horizon multi-step agentic work, cross-file reasoning	sonnet/opus	high/xhigh	milestone checks

Cascade (default composition)

When a near-free verifier exists, compose instead of choosing a tier up front:

result = haiku(task, effort=low)
if verify(result) fails:  result = sonnet(task)      # escalate on evidence
if verify(result) fails:  result = opus(task)         # rare

Input-cost ratio is Haiku 1× · Sonnet 3× · Opus 5×. Expected cascade cost ≈ c_haiku + p_fail × c_sonnet, so the cascade beats Sonnet-direct while Haiku's failure rate stays below ~2/3, and beats Opus-direct below ~4/5 (derivation in the reference). Every checkable task measured has Haiku failure ≈0, so the cascade is nearly pure savings.

No verifier ⇒ no cascade. Route by the table instead, because silent Haiku errors compound downstream with nothing to catch them.

Loop discipline

Never blind-loop. Re-applying the same prompt to a model's own output is the identity at best (an LLM call already unrolls its reasoning depth internally) and regression-then-freeze at worst — in calibration, a re-looped haiku broke its own middle line on iteration 2 and froze on the broken text for every iteration after. Loops only pay when an out-of-band evaluator scores each iteration.

1. Loop only with an out-of-band evaluator — ground truth, mechanical checker, or an up-tier judge scoring every iteration.
2. Select, don't trust the last: final = argmax_r eval(answer_r). Never ship iteration N just because it's newest.
3. Stop on first regression. If eval(r) < eval(r-1), stop — loops froze on degraded output rather than recovering, so early-stop risk beats drift risk.
4. Loop for diversity, not depth. Vary the prompt/angle per iteration to explore; identical re-application converges instantly.
5. "Improve this" with no headroom is the danger zone. It pressures the model to change something; without a selector, that change ships.

Judge rules

• Judge model ≠ worker model; judge at least one tier up (Sonnet judging Haiku, Opus judging Sonnet). Same-model self-assessment is untested — don't assume it.
• Prefer mechanical checkers over judges wherever a spec can be executed (word counts, schemas, tests, regex): free, deterministic, zero judge tokens.
• Judges are for rubric quality, not arithmetic — don't ask Sonnet to verify a sum a Python one-liner can check.

Escalation triggers (route up despite the table)

• The verifier fails twice at the same tier.
• The task requires weighing trade-offs with no checkable ground truth.
• Output will be shipped verbatim to a human without review.
• The subagent must plan its own multi-step tool strategy over many turns.

Recalibrate when

• The task is off the measured battery. No deterministic task has made Haiku fail yet, so the cliff is past what's been probed — test harder instances before trusting Haiku on a genuinely novel task family.
• The work is multi-turn agentic tool use. That was not calibrated; treat the table's up-tier rows there as prior, not measurement.
• A model rev bumps. Re-run the battery (generators + scorer described in references/calibration-2026-07-15.md) before trusting the table.