Skip to content
Board advisory and board seats: full for 2H FY26 and 1H FY27. 1 of 3 positions open from 2H FY27 onward.
See details →
AI

Route the Writer Cheap. Verify Separately.

I let a decision model pick the model and effort for every subagent. The savings only hold because an independent reviewer is routed on its own.

By Michael YorkNovember 22, 2026 8 min read 1,639 words All AITable of contents

Picking a model for a delegated task is a decision you can make in a fraction of a second, and write down. I make it before every subagent I launch in my own projects. The savings it produces are real, but they only hold because checking the work is a separate step that gets routed on its own. Route the writer cheap and skip the independent reviewer, and you've just bought cheaper mistakes.

The tool I use is Jev, a decision model from TypeSafe (opens in new tab), wrapped in the open-source Jev Model Router (opens in new tab) plugin for Claude Code. This is my personal workflow on my own projects, not a company standard. I'll walk through the rules I run, what one real session looked like, where it failed first time, and what I'd keep out of the task text before I'd let anything like it near regulated work.

What the router actually does

Plain mechanism first. Before I hand a task to a subagent, the task description goes to Jev, which answers a set of narrow questions about it: what kind of work it is, how hard, how much reasoning it needs, whether it needs tools. The plugin's own code, not a model, turns those answers into a ranking. It scores each candidate model at every reasoning effort it supports, against estimated quality, estimated cost per call and estimated latency, and hands back a pick plus the cheapest, fastest and smartest alternatives.

I see the pick and the alternatives, and I decide. Jev recommends; it doesn't dispatch anything and it doesn't move traffic. My personal setup allows Claude models only, through a provider allowlist, inside Claude Code. That matters, because a router that picks a vendor per call is a different animal. I'd treat that kind as a sub-processor selector with a file behind every request. This one recommends a model from a list I already approved, and the request still goes to the vendor I already contracted with.

Claude Code makes the result easy to act on. Its subagent documentation (opens in new tab) lets each subagent carry its own model and its own effort level, and a per-invocation model setting wins over the subagent's definition. So the recommendation turns into two fields on the dispatch, not a session-wide switch.

The rules I run

A router with no policy around it just produces opinions. These are the rules that turn its opinion into a decision:

  • The main session writes its own code. Delegated implementation goes to Sonnet.
  • Opus reviews. Code review, root-cause analysis and adversarial verification run on Opus. Security-sensitive code, and its review, run on Opus at high effort.
  • The top tier is earned. Fable, the most capable model in my list, runs only on hard work that isn't security work, when Jev rates difficulty at 3.0 or above on its 4-point scale, when I ask for it, or when it's taking over a change Opus already failed twice.
  • Effort has a ceiling. High is the cap. The two levels above it need a Jev difficulty of 3.0 or more. Sonnet never runs above medium; if a task needs more than that, it goes to Opus at medium instead.
  • Every review ends with one line. VERDICT: pass or VERDICT: fail. Two fails on one change hand the implementation up to Opus. A third fail stops the work and asks me.

Rules in a config file get skipped under deadline, so a few of these are enforced. A Claude Code PreToolUse hook (opens in new tab) runs before a tool call executes and can deny it. Mine refuses to launch a subagent unless Jev has run recently for the current request, refuses any dispatch that doesn't name an effort level, and refuses effort above the ceiling. If Jev is unreachable, the next dispatch goes through at a fixed effort, because I'd rather lose the optimization than stall the work. That fallback is a deliberate choice, and it's written down where I can see it.

The gate is also what makes the decision recordable. The gate also means no subagent launches on a default nobody chose.

One session, with the numbers Jev gave me

Here's a real content session, with one caveat up front: every dollar figure below is Jev's own estimate, not a billed amount. I'm reporting what the router said, not what the invoice said.

Mining source material. The job was to read 11 newsletter issues and check each idea against roughly 200 existing posts for duplicates. Jev rated it 2.39 of 4, "moderate," and picked Opus at low effort: about $0.29 per call, roughly $2.87 for the task. Sonnet at high effort was cheaper per call, about $0.16, and on price alone it would have won. My gate caps Sonnet at medium, so it was never an option. That's the policy overruling the optimizer, on purpose.

Drafting a researched article. Jev rated this 2.5 of 4, "hard," and again picked Opus at low, at about $7.71 estimated for the task. To approach it, Sonnet would have needed xhigh effort, and it still scored lower on Jev's quality estimate, 69 against 75.

A week-in-security research piece. Rated 2.82 of 4. This time Jev moved the pick up to Opus at medium, with a quality estimate of 84, at about $8.27. The harder task got more reasoning, without me having to notice it was harder.

The analysis itself came back in about 125 to 240 milliseconds per call. That's the part people underestimate. A routing decision that cheap and that fast can run on every dispatch instead of once a quarter, and a per-task choice beats a standing default for the same reason I argued in model selection is capacity planning: the right model depends on the work, and the work changes every hour.

Where the cheap pass failed

Four article drafts came out of that session, each written by Opus at low effort. All four failed their first independent review.

The reviewer was a separate Opus instance, also at low effort, told to fetch every cited link and end with a verdict. Between them, the reviewers caught a misquoted SEC filing, the wrong signatory on a contract, a market-share figure credited to one model that actually belonged to four, links to pages that weren't live yet, and a sentence that overstated a fact. Any one of those, published under my name, is the kind of error a reader remembers longer than the argument.

After the fixes, all four passed a second-round check.

This is the result I care about most. Without the review, every one of those errors was headed for publication. A cheap writer plus an independent cheap verifier shipped none that the review found. One expensive pass, trusted without review, still wouldn't have been checked by anyone.

So verification isn't a step you bolt on after routing. It's the reason routing down is safe at all. The reviewer gets its own routing decision, its own model and effort. The reviewer opens every link. The writer's low effort setting is a bet, and the reviewer is how I find out whether the bet paid. (A neighboring point in stop gating the $40 question still holds: there are tasks where you just buy the frontier model and don't argue. The difficulty threshold is my version of naming those up front.)

The router has a freshness date

Here's the plain limitation. The router ranks models on scores somebody has to keep current. When I checked its status during this session, it showed a live catalog of 468 models, but its reviewed-model data was last updated on September 18, 2026. Two months old, in a market where models ship every few weeks.

Every pick rests on a dated ranking, and nobody alerts you when the date gets old. That date deserves the attention you'd give the age of a threat feed. A stale ranking gives you a confident recommendation for last quarter's market.

There's a second, quieter limit. Jev's cost and quality numbers are estimates, not billed usage. Different tools already disagree on how many tokens a call used, which I wrote about in three token counts, zero you can attest to. The router's estimates are a fourth number. I use them to choose, not to report.

The router is a third party too

This is the part I'd insist on before anything like this touched regulated work. The router is itself a service that receives your task descriptions.

The project's README is specific about it. What leaves the machine is "the task text (up to 6,000 characters) and optional context notes," which go to Jev through either OpenRouter or TypeSafe, depending on which key you configure, under their privacy policies. The model catalog and the model-score file are public downloads that send no data. The README also says there's no telemetry, and the bundled server isn't minified, so you can audit what runs.

Whatever you type as the task description reaches a party you may not have reviewed. So I keep task text to the shape of the work, never its contents:

  • No customer data of any kind: names, account numbers, credit attributes, support tickets pasted in for context.
  • No secrets: keys, tokens, connection strings, or log lines that might carry one.
  • No unreleased material that would hurt if it leaked, like incident details or a deal under negotiation.
  • Describe the task the way you'd describe it in a public ticket title: "review a diff to the session-timeout handler" is enough for a routing decision.

If a firm wanted this pattern, I'd put the router on the third-party inventory like any other vendor that sees request text, read the privacy terms of whichever path the key selects, and give the routing call its own data class rule. The subagent still gets the full context. The router only needs to know what kind of work it's looking at.

AIAI AgentsClaude CodeModel RiskAI Cost