model-routing

name	model-routing
description	How and when to delegate coding work across models — pick the right lane (cheap execution, senior review, explicit judgement, or dual super-judgement), size the reviewer to the work, and know when a manual gate is required. Use when deciding whether to spawn a subagent, which model/effort to hand a task, how to route a code review, or when to escalate. Also covers reaching Codex from Claude.

Model-routing: which model does which job

You are orchestrating coding work across several models. A strong model plans and judges; cheaper ones execute. Route by these rules. The dated evidence snapshot and lane mapping live in model-routing.md plus config/model-evidence.json at the kit root. Use delegation-evidence lane <lane> when installed; evidence is advisory and the versioned routing gate remains authoritative. Use delegation-route resolve --lane <lane> for the operational decision. It is read-only and never dispatches a model. For native Claude/Codex agents, the lead must resolve first; invoking an explicit-only profile is the manual selection event. GLM/Kimi runners enforce the same graph directly and refuse drift.

When to delegate at all

• Default to solving simple, well-scoped work directly. Do not spawn a subagent for a routine single-file change.
• Delegate the clear-spec, mechanical, or high-volume work (bulk implementation, migrations, data crunching, extraction) to the cheap execution lane.
• Reach for multi-agent orchestration only on an explicit decision, never on autopilot. In an orchestration/ultra mode, let the orchestrator fan out — don't add a second manual delegation layer on top.

The lanes

• Execution / routine review (cheap): bulk implementation, migrations, tests, extraction, repo mapping, and the default diff/bug-review lane.
• Senior review / taste / security: security-adjacent code (route here directly), user-facing surfaces (UI, copy, API design), material correctness review, and the escalation target for the cheap lane.
• Judgement: Fable xhigh for architecture/trade-offs/synthesis or Sol high for technical feasibility/repository fit/failure modes. Both are manual-qualified, explicit-only, thinking-not-typing profiles.
• Super-judgement: only for exceptional, difficult-to-reverse decisions. Fable and Sol reason independently, cross-review after both verdicts exist, and the lead decides. Never trigger it automatically.

An optional external candidate such as GLM-5.2 earns one of these lanes only after its versioned evaluation gate allows that exact role. GLM clerk/scout are provisional and require --allow-provisional; builder is a blocked candidate and reviewer is disabled. An installed CLI or visible model name is not qualification.

Kimi K3 is provisional for clerk, scout, builder, and frontend-builder at max; senior is a blocked candidate, while reviewer and judgement are disabled. Provisional dispatch requires --allow-provisional. Provider quota failures are temporary runtime failures, not quality evidence.

Sizing and escalation

• Size the reviewer to the work, not to a general leaderboard. A diff the cheap lane wrote against a plan the strong model authored is reviewed by the mid model that already has the context. Reserve the top model as reviewer only when its gradient is required: high-level design/taste, synthesis across attempts, or independently checking something it produced.
• Route review by content, not by habit — send security/auth/payments/ migrations/user-facing to the senior lane; keep routine bug-hunting on the cheap lane (often cheaper and higher-recall there).
• Escalation ladder: cheap → senior → judgement. Never retry the same failure on an unsuitable cheap worker twice — escalate. Security never delegates downward: it starts on the senior lane.
• Delegated output is unverified until you check it. Never ship or build on a delegated diff or finding without reading it or reproducing the claim — and make the check exercise the deliverable (run the command, read the output); grepping a README, testing something adjacent, or printing True while exiting zero proves nothing.

Tie-breakers

• When evidence conflicts: required lane evidence > deliverable quality > cost.
• cost is per task, not per token. A model that burns more tokens at a lower price can still finish the job cheapest.

Reaching Codex from Claude (cross-provider)

If a GPT/Codex model earns a lane in your table, drive it from Claude. For interactive or context-preserving work prefer the codex@openai-codex plugin: the codex:codex-rescue agent (agent-invokable), plus the user-run slash commands /codex:review and /codex:transfer — suggest these to the user, you can't invoke them. /codex:transfer hands the session off as a resumable Codex thread, the only path that carries the conversation across. For programmatic/parallel work use the Codex CLI and pin both model and effort: codex exec --ephemeral -p <profile> "<prompt>" </dev/null (profile pins both) or codex exec -m <model> -c model_reasoning_effort=<level> -s read-only "<prompt>" </dev/null (-s workspace-write to let it edit; add --json/-o <file> for a clean, parseable return). Each codex exec starts fresh — run it from the repo root and reference files by path. Use it for a cheap high-volume lane or an independent second-opinion review from a different model family.