How this maps onto Codex CLI

Same rubric. Two Codex levers underneath it, not one.

Codex CLI's model selection is documented in its configuration reference as two separate config.toml keys: model (which model — a full swap) and model_reasoning_effort (minimal | low | medium | high | xhigh, a reasoning-depth dial on the Responses API within whichever model is selected). Both can be set globally in ~/.codex/config.toml, overridden per-project in a trusted repo's .codex/config.toml, or swapped per invocation with a named --profile. That's a different shape from a single-vendor model family with one "smallest → largest" ladder — it's two independent dials.

Undercut's tier names — cheap, standard, frontier, apex — are generic on purpose. models.md already carries an OpenAI column for the eval harness, but those are OpenRouter-catalog slugs, not necessarily Codex CLI's own bundled model names — the file says explicitly to map each tier to "that agent's closest current model at that tier's capability level" rather than hardcoding a slug. For Codex specifically, that mapping is honestly two-dimensional: a cheap unit of work should get both the smaller model and a low model_reasoning_effort; an escalated unit gets either lever turned up, whichever the person configuring Codex has available. We have not independently verified which exact Codex model IDs (e.g. current gpt-5.x-codex variants) exist at each capability tier as of this writing — treat the models.md OpenAI row as a starting point, not a Codex-verified mapping, and confirm current slugs with codex --version/your Codex model picker before wiring a profile to it.

Nothing about this sits between Codex CLI and the OpenAI API. It's a policy file Codex reads at dispatch time, same as any other skill — no proxy, no network hop, nothing to route around if you remove it.

Install for Codex CLI

Free. MIT. Nothing installs, nothing proxies your traffic.

Option 1 — skills CLI

vercel-labs/skills auto-detects Codex CLI on your machine (pass -a codex to target it explicitly) and drops the skill into Codex's own skills path.

      $ npx skills add undercutsh/firstpass -a codex
      
    

Option 2 — copy the skill directory directly

Clone or download undercutsh/firstpass, then copy skills/firstpass/ into one of the paths Codex CLI's own docs list as scanned for skills (per Codex's skills documentation): repo-scoped at .agents/skills/ (from your working directory up to the repo root), or user-level at $HOME/.agents/skills/ — note this is a different directory convention from Claude Code's .claude/skills/.

      $ mkdir -p .agents/skills && cp -r firstpass/skills/firstpass ./.agents/skills/firstpass
      
    

Validate it yourself

1Read the published results — testing/README.md and the raw JSON in testing/results/
2Reproduce for free, no API key, no spend: node src/main.js --mock
3Run live on the OpenAI family with an OpenRouter key — a single-vendor smoke test is pennies

Zero lock-in. It's a policy Codex CLI follows — remove the skill and you're back to status quo.

How it works

The Undercut Rubric · v1

Six flags assign a tier. Three triggers are the only way up.

This is a named, versioned spec — not internal logic we could quietly change. When the rubric changes (a new flag, a different cap), the version number moves and the changelog says why.

Every unit of work gets scored against six flags, then assigned the cheapest tier that can plausibly handle it. It only moves up a tier when something objective proves it needs to — a failed check, a measured disagreement, an explicit uncertainty flag. It never moves up on a guess, and it never moves back down mid-task.

unit of work
›
6-flag rubric
›
0 flagscheap~90% of units land here ✓
1–2standard
3+/ownfrontier

        ↑ escalate +1 tier
        only on: fail ×2 · two runs disagree · tagged "uncertain"
        residue only — never redoes the batch
      

See the rubric

Step 1 — Base tier, six-flag rubric

Unverifiable — can output be checked mechanically? (tests, schema, diff, grep)

Ambiguous — one right answer, or several defensible ones?

Blast — reversible? touches money, auth, user data, production, deletes?

Cross-cutting — one file/source, or reasoning across many?

Novel — pattern-following, or genuinely new design?

Format-strict — must output match an exact schema?

0 flags → cheap · 1–2 → standard · 3+ or any ownership/judgment call → frontier. Apex only when you can write one sentence stating why the marginal intelligence pays for the cost.

The override — single biggest lever

Cheap-to-verify ⇒ cheap-to-generate. If output can be checked mechanically, it starts at the lowest tier regardless of how hard it looks — verification catches failure. Only unverifiable work needs to start high.

Step 2 — Escalate exactly one tier, on evidence only

Verification fails twice at the current tier
Two cheap-tier runs disagree on ambiguous-flagged work
The worker tags an item "uncertain"

Residue-only handoff

The next tier up gets only the failed or uncertain items, plus verification notes. It resolves the residue — it never redoes the batch.

Hysteresis — guardrails

Never de-escalate mid-task. Max one retry per tier. Anything still unresolved goes to a single batched apex tie-break call. One hard file in a 700-file job doesn't drag the other 699 up a tier.

 unit of work
      |
  6-flag rubric
      |
  +---+----+
  | 0 flags|--> cheap
  | 1-2    |--> standard
  | 3+/own |--> frontier
  +---+----+
      | fail x2 / disagree / uncertain
      v
  escalate +1 tier
  (residue only)
      |
  still unresolved?
      v
  single batched
  apex tie-break

Why it holds up

Flags steer. Verification and escalation decide.

Even when the rubric flags are scored imperfectly, the escalator still routes work to the right tier almost every time — because a wrong flag only ever costs one extra cheap attempt, never a wrong answer or a big bill.

See the data

A stock dispatcher model reproduces the rubric flags imperfectly — Haiku hits 90% agreement, Sonnet 93%. The weakest flag (format-strict) is only 60%. None of that matters: under the shipped policy, both dispatchers still route 100% of units to the correct tier. A wrong flag changes the ladder cap, never the base tier — worst case, one extra cheap attempt.

Haiku dispatcher
90% flag agreement
100% tier-match
Sonnet dispatcher
93% flag agreement
100% tier-match

The rules are about the work, not the model.

Every rule is a property of the unit of work — verifiable, ambiguous, blast-radius — never a specific model's known weakness. Vendor cards go stale as models change; work properties don't. It's also hard-won — a format-strict rule that worked on Anthropic backfired on Gemini, which is exactly why the rubric no longer encodes per-vendor behavior.

Codex CLI already reads a SKILL.md. Give it one that stops overpaying.