Cut your AI coding bill up to 71%. Not your pass rate.

Savings calculator

What's tiered routing actually worth to you — or your team?

The savings % below comes from the blended code/reasoning/mechanical results in RESULTS.md, not a marketing multiplier. Plug in real spend to see it in dollars.

Estimate, not a quote. Built from the 30-task blended suite in RESULTS.md (5 seeds, deterministic graders). Real workloads escalate more than benchmarks, so treat this as a ceiling, not a guarantee — and it assumes Team-tier enforcement so the policy actually applies to every seat, not just the devs who opted in.

For your team

One skill. Three reasons to care.

The problem

Your agent picks one model per session — and defaults to the expensive one for everything.

Claude Code, Codex, Cursor, and Copilot let you set a model once per session. That session then handles trivial, mechanical work at the same tier as genuinely hard reasoning. One Claude Code Max subscriber's self-reported usage data showed 93.8% of their tokens going to the top-tier model — with nothing pulling cheap, mechanical work back down.

It's one user's numbers, not an industry audit — the GitHub issue has stayed open with real engagement, which suggests the pattern isn't unique to one account.

Undercut replaces confidence with three objective triggers: a failed verification, a measured disagreement between two cheap-tier runs, or an explicit uncertainty flag. Nothing escalates on a vibe.

vs. cap-based routers

Caps throttle spend. Undercut routes work.

Most "cost control" tooling watches the meter: every unit still runs at the top tier until a budget cap stops the whole session. Undercut decides the tier per unit, before it runs — the cap never has to save you because the spend never happens.

They compose: Undercut routes first, your gateway's caps and compression still apply to whatever runs.

The proof — measured, not modeled

Controlled A/B. Same tasks, same grader, only the routing policy changes.

How it works

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

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 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.

Honest limits — and what this means for governance

What this doesn't do.

• Not a proxy. Doesn't enforce anything at the network layer.
• Not a gateway or compression proxy. Composes with those — routes first, they compress second.
• Doesn't auto-flag in production. The dispatching agent scores the flags itself (measured robust to getting them wrong — see above).
• Doesn't help when the cheapest tier lacks the capability entirely (OpenAI + Python is the documented case — no headroom to save).
• Doesn't replace the planning decision. Planning is separate from execution routing; this ladder is for execution units.
• Doesn't promise a dollar figure for your workload. Savings are workload-dependent — real workloads escalate more than benchmarks and land below these numbers, not above.

One skill is a habit. A team needs a policy.

The free skill only saves what every individual dev remembers to install and follow. Teams turns the same rubric into something the org can point to, measure, and rely on — without adding a network-layer gateway.

Still not a proxy. Teams enforces the policy through org-wide configuration and the escalation ledger above — not by sitting on the network path between your agent and its model calls. It composes with whatever gateway you already run.

Pricing

Free for individuals, forever. Teams and Enterprise ship at launch.

Nothing below is live yet — the skill is; Teams and Enterprise are what we're building toward, priced honestly ahead of shipping instead of dropped on you at launch.

Compare in detail

Pricing and feature scope for Teams/Enterprise are the current build target, not a signed rate card — see docs/business/business-model.md for the working plan. They'll firm up at launch.

Try it

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

or copy skills/firstpass/ straight into your agent's skills directory.

Validate it yourself

1. 1Read the published results — testing/README.md and the raw JSON in testing/results/
2. 2Reproduce for free, no API key, no spend: node src/main.js --mock
3. 3Run live on your own vendor/benchmark with an OpenRouter key — a full 4-vendor × 2-benchmark run is ~$4–5 total, a single-vendor smoke test is pennies
4. 4Diff any two saved runs: node src/main.js --compare a.json b.json

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

Not the one setting this up? Forward this page. Everything above the install command reads without a technical background — the engineer on your team just needs the command block.

Prior art

Others have tried cheaper-model routing. Here's what's different.

peragwin's subagent-model-routing gist and soumabali/token-router both explored assigning cheaper models to subagent work. Undercut adds the objective escalation loop on top: measured disagreement instead of self-reported confidence, hysteresis so a run can't thrash between tiers, residue-only escalation with a structured handoff, a calibration feedback loop, and — the part that's actually rare in this category — published, reproducible A/B results. Anyone can re-verify any cell in the tables above.

Not competing with your gateway.

Compression proxies like Edgee shrink what goes over the wire for a given call. Undercut decides which model handles the call in the first place. Route first, compress second — they stack.

FAQ

Undercut the top tier. Not the quality bar.

Nothing about this page expires. What does keep happening is the token bill, one session at a time, on whatever your agent is currently doing with mechanical work.