Jev, the small judge I put in front of big models
Jev is a small classifier from TypeSafe. You hand it some text and a few typed questions, and it hands back probabilities, in about half a second, for about a hundredth of a cent. I use it to decide which model does a job, whether finished work needs a second look, and when a chatbot should call in a stronger model.
What it is
Jev doesn't write. It judges. Every call is a piece of text (the state) plus questions, and each question has one of three types.
noul
A yes or no question, written as a statement. Jev returns the probability that the statement is true. TypeSafe calls this type a noul. Said out loud it sounds a lot like "null", so it's easy to mishear.
choice
Pick one of several options you describe in words. You get a probability for each. Always offer an "other" option, so input that fits none of them has somewhere to go.
score
Rate on an ordered scale of up to ten levels, each described in words. You get a position along the scale.
"The record shows something actually ran and passed (a test, a build, a command with an exit code) rather than only the worker stating that the work is done."
Jev returns 0.91 (example value)
I read these numbers as scores to rank by and set thresholds on, not as calibrated odds. A 0.8 means more likely than the 0.6 beside it. It does not mean true four times in five.
A noul in code
This is the real first question my review gate asks about every piece of work a worker hands back, using the small Python client in my public repo:
from jev.client import Jev, noul
questions = {
"was_verified": noul(
"The record shows something actually ran and passed (a test, a "
"build, a command with an exit code) rather than only the worker "
"stating that the work is done."
),
}
answers = Jev().ask({"completed_work": summary}, questions, label="review_gate")
p = answers["was_verified"]["value"] # probability the statement is true, 0 to 1Write it as a statement, not a question, because Jev answers the literal wording. The client also asks every choice twice with the options reversed and flags any answer that flips, since option order can move a result.
Four ways I use it
Deciding which model does the work
Before an agent (Claude Code or Codex) starts a task, it writes the task down as plain facts: the goal, the files, the change, how we'll know it's done, and what it depends on. Jev answers eight questions about that digest. Is the approach settled? Could a worker who never saw the conversation do it? Does the done-check prove anything? What are the stakes? Then plain code turns the answers into a decision: keep it with the main model, hand it to a cheaper model, or bring in a reviewer first.
Seven weeks of agent work listed about 14% (about $1,070) under an all-Opus bill, while paying for more independent review than before.
That figure prices the same tokens at Claude Opus 5.5's list rates, token for token, with no allowance for redone work, so read it as an estimate under those assumptions, not a measurement.
Where it came from: cheap models took the build work. The cheapest, GPT-6 Luna, listed at $46 for tokens that would list at $1,330 on Opus, about 3.5% of the price. All the build work (Luna and two mid-priced models) listed at $220 against about $1,627. Luna went from writing 7.5% of the output tokens in my agent work to 41%. The overhead is the router itself: 1,419 routing decisions cost $0.14.
How it's counted: from my own usage logs, the 27 days before the router went live against the 51 days after, leaving out one-shot batch jobs. List-price equivalents, because I pay flat subscriptions, at OpenAI and Anthropic list prices fetched 2026-11-09. Before is 2026-08-24 to 2026-09-19; after is 2026-09-20 to 2026-11-09. New models and prices arrived during the comparison, so these numbers describe what happened rather than isolate the router's effect. Read the full report: method, tables, caveats and what review caught.
Checking work that comes back
When a worker hands back finished work, a handful of nouls read the record. Did a check actually run and pass? Does the change span several files? Does it reach people outside? Is it hard to undo? Did it drift from the task? If a passing check ran and nothing drifted, the gate stays silent. Otherwise it recommends a second read, and the stakes decide who does it. It never grades whether the code is correct. It asks about the shape of the work, which a classifier can see, and leaves correctness to tests and reviewers.
When the gate calls for a second read, the reviewer is a model from a different family than the one that wrote the work, and it gets the spec, the evidence and the diff, not the author's reasoning. Review is a deliberate spend: its share of list-price cost rose from 5% to 11% after the router went live.
The cross-family reviewer ran 430 reviews after the router went live, and about 7 in 10 raised at least one issue (labels checked by hand on a sample). The 1,486 review-gate checks that decided when to call it cost $0.39.
Some of what those reviews caught before it went live:
- A clock-sync guard that could leave venue TVs showing an old blind level after a display reconnected.
- A new tournament clock that could silently overwrite one already running.
- An unverified assistant answer that would have been marked as checked. The fix was in the feature's first commit, so it never shipped.
- An admin check that accepted the wrong kind of sign-in.
How it's counted: review labels come from a keyword pass over each review's final message, checked by hand on a random sample. Each example above was matched to a commit on the same file that made the requested fix after the review ended. They are the clearest cases, not a random sample.
A chatbot waterfall
I built Winston, a whiskey recommendation assistant for a Denver pub. Each customer message runs down a waterfall:
- Fixed rules answer the common cases for free.
- For everything else, a fast answer is drafted and a few nouls check whether it reads the customer right.
- Only the messages the nouls flag go to Claude Sonnet for a second look.
Projected about 64% cheaper than calling the large model on every turn.
Over the first 81 messages with their path logged, the rules answered 49%. Of the 40 that went through the gate, 29 were flagged, and the second look changed 25 of those.
In a review of 38 labelled live messages from 2026-10-08 to 2026-10-20, the gate sent 25 of the 28 that needed a second look. That is a small live sample.
How it's counted: the noul cost is measured (about $0.00006 per gated message); the Sonnet second look is priced at an estimated $0.014 per call.
Sorting a pool of unusual ideas
My idea engine, Sfumato, has a fast diffusion model, Inception Labs' Mercury, write dozens of unusual ideas for a hard problem, one call per idea. Jev sorts the pool so the interesting ones come to the top: in the published version it picks from the pool as a multiple-choice question with a real "none of these" option, asked eight times in both option orders. Then a reasoning model, or I, work each picked idea through for the principle worth keeping. Jev is good at bringing the interesting end of a large pool to the top. It is less proven at fine ranking inside a pool that is already good, so when it matters I read the whole pool.
How you could use it
If you run an LLM product, the pattern carries over: put a cheap judge in front of the expensive call, and let code decide when the expensive call is worth making. For a tool that reads privacy policies, for example:
- Split the policy into clauses.
- Ask a few nouls about each clause in one call, such as "This clause allows sharing personal data with third parties for advertising." and "This clause says how long personal data is kept."
- Send only the clauses that clear your threshold to the big model for the full analysis.
A 60-clause policy, one Jev call of about 550 input tokens per clause; the big model is Opus 5.5 at $4 per million input and $20 per million output tokens, with 400 tokens in and 150 out per clause.
- Jev triage on all 60 clauses
- $0.0014
- Big model on all 60 clauses
- $0.28
- Triage, then the big model on 15 flagged clauses
- $0.07
What to watch for
- Write each question as a statement and pin its wording with a test. A threshold you picked for one wording does not carry over to another.
- Ask about the presence of something, never its absence. Two questions that are logical opposites don't always come back as opposites.
- Give every choice an "other" option, and ask choices in both orders.
- Pick thresholds on a labelled sample of your real traffic. A hand-built test set may not look like it.
- Read rates across many calls, not one score. Asking the same thing twice can move a single score.
- Keep arithmetic, counting and dates in code.
- Decide what happens when the judge is unavailable. My checks fall through to the expensive path.
How others are using it
Jev came out in September 2026, and people already use it for routing, citation checks, extraction, ranking, moderation and agent review, plus a YouTube sponsor skipper and a harness where Jev plays Pokémon Red. The pattern is the same everywhere: Jev picks or checks a bounded option, and ordinary code acts on it. The shipwithjev directory lists 620 entries, but that is a catalog of posts, repos and guides, not a count of active users. Independent studies show answers and probabilities can shift with the question wording and the answer options, and TypeSafe's speed and price figures are its own claims.
- Sponsor SkipA Chrome extension that finds and skips YouTube sponsor reads.
- Jev plays Pokémon RedJev picks among legal moves while code presses the buttons.
Read more
- quartermasterThe router and checks.
- sfumato-idea-engineThe idea engine.
- poker-club-appThe poker league app real players use every week.