Jev Isn’t a Chatbot — Stop Routing Like One

A frontier model writes three paragraphs explaining why a ticket belongs to the docs lane, and a regex in the dispatcher fishes the word docs out of paragraph three. The decision was one word long. The seat it sat in was built for essays.

TypeSafe Jev, launched Sep 15, is sold squarely for that one-word seat: text state in, a typed answer out, no prose. Within a week it was also being tried as an eval judge and as a context compactor, the two jobs a no-prose classifier should hold least. By Tuesday you can have an inventory of the decisions your fleet makes, four tests that separate a decision seat from a reply seat, and a checked-in table saying which decisions a fast classifier may take and what each must prove before it enforces anything.

Chatbots suggest; agents act, and every act starts with a small decision: which lane, which model, allow this call, is this session stuck, does this alert need a person. Route those through a reply model and you buy latency and parsing bugs. Route the wrong ones through a classifier and you buy quiet errors nobody reads.

Sep 15–20: TypeSafe Jev ships, and the week argues about its seat

TypeSafe launched Jev on Sep 15, 2026, as its first System One model. The launch post calls it “a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” Input is text only, per the models page. Output is a Choice among options you define, a Score on a scale, or a Noul, the probability that a yes/no statement is true.

The post says Jev “gives up string generation” and “can’t hallucinate”; the second is a claim about schema conformance, not about being right. TypeSafe reports 70 to 500 ms end to end and $0.042 per million input tokens, output free.

On Sep 20, Theo Browne posted a 30-minute video, “Jev is incredible”, whose description says the model “doesn’t replace reasoning models like Astra/Fable.” His working rule, paraphrased: if a person could answer in under ten seconds once they have seen the information, the model is probably good for it; if the task needs thinking, it is not. He frames Jev as a smart if statement and rules out two uses: judge and compactor.

The same week pulled the other way. Braintrust (Sep 18) and LangChain (Sep 20) both published experiments with Jev in a judge slot, and a Sep 17 WorldofAI roundup listed judging outputs among its uses. The sharper fight was compaction: on Sep 17 tamara proposed scoring each tool call with Jev and dropping the irrelevant ones, hours later Alex Volkov showed a Jev plugin pruning a session from about 1M to 86K tokens in roughly a second, and Theo answered with a thread whose first point is that compaction is not a filter.

TypeSafe’s primitives page states the rule more tightly than any video: “Ask for a judgment a knowledgeable person makes in a second given the right context.” Everything below turns that sentence into a table.

Screenshot: TypeSafe docs, “Primitives (Questions) - TypeSafe AI” (undated), captured Sep 21, 2026.

Step 1: Inventory the decisions your fleet already makes

Start from logs. Pull a week of dispatcher, router, permission and alerting events and list every point where code or a model picked one outcome from a small set. The five from the opening show up in almost every fleet; most have a few more, such as which CI checks run on a pull request.

For each, record what decides it today, how often it fires, the exact state the decider sees, and the shape of the answer. Shape is the first sort. One label from a list, a level on a scale or a yes/no makes a candidate. Prose answers (explain, summarize, draft) are already in the reply seat and stay there.

Decision	Decided today by	State it needs	Answer shape
Which lane takes this task	dispatcher prompt to a frontier model	task text, lane definitions	one of N lanes
Which model tier runs it	static rule or router prompt	task text, repo tags	one of three tiers
Allow this tool call	permission rules, vendor classifier	tool name, arguments, recent turns	allow / ask / deny
Is this session stuck	idle timer	last events, idle time	yes / no
Does this alert need a human	on-call rotation	alert payload, recent history	yes / no
Which CI checks run	run everything	diff summary, task list	per-task yes / no
Did this PR pass review	reviewer agent	diff, tests, spec	verdict with reasons
Summarize or prune the session	harness compaction	the full transcript	prose, or an edited history

Write down the rows a person decides by reading a dashboard. Those are where a fast classifier saves the most and risks the most.

Step 2: Run each candidate through the four seat tests

A decision seat is a question a classifier can answer about as well as a careful person at a glance. All four tests are required, and on paper they cost nothing.

Test 1: a human answers in under ten seconds from the state alone. Print exactly the state the classifier would receive, hand it to a colleague with the question, and time them. Inside ten seconds passes. If they open another tab, ask what a lane name means or reason aloud, it fails: the decision needs context or thinking the state does not carry.

Ten seconds is Theo’s rule of thumb; TypeSafe’s “in a second” is stricter. Either way, the test grades the question.

Vendor-reported ranges from TypeSafe. The dashed line marks the ten-second human test.

Test 2: the criteria read literally. Write criteria for every option as if a stranger will apply them word for word, because the classifier will. The jaggedness page for jev-1.13 is plain about it: “jev-1.13 answers the question you wrote, not the one you meant.” Criteria built on judgment words (appropriate, reasonable, best fit) fail, as do lanes defined by who owns the work rather than what the task contains.

Jev has no abstain answer, so every Choice gets an explicit unclear option with its own criteria.

Test 3: the state fits 32K. TypeSafe documents two limits that apply at once: 64K tokens per request, and 32K for the state plus the longest question. If the honest state is a transcript, a repository or a log directory, the row fails unless code narrows it first; the jaggedness page says to “retrieve and filter in code first, and send only the fields the question needs.” A tool call and its last few turns fit easily; a session does not.

Test 4: no date or number math. “Jev is not a calculator. We strongly recommend implementing any mathematical logic in code,” the page says, and “jev-1.13 reads dates as text, not as ordered quantities.” Ordering, durations, counts against a limit and arithmetic stay in code. A date part may be extracted as a Choice, such as which of three dates in an email is the expiry date, and then code does the subtraction.

Most real decisions split rather than pass or fail whole. “Is this session stuck?” is a clock plus a judgment: code owns idle time and retry counts, as the stall-flag pattern already does, while a classifier may answer the semantic half, whether the recent events show the agent repeating the same failing action. Split the row and seat each half.

Step 3: Ship the decision table, reply column included

The table is the deliverable: one row per decision, one column per test, a seat and a next action. Here is the sort for the inventory above; yours will differ, which is why you run the tests on your own state.

Decision	Under 10 s	Literal criteria	State ≤ 32K	No date or number math	Seat	Next
Which lane takes this task	pass	pass once lanes are defined by task content	pass	pass	Decision: Choice with unclear	eval, then shadow
Which model tier runs it	pass	pass with written tier criteria	pass	pass	Decision: Choice with a confidence floor	route table
Allow this tool call	pass per tool class	pass per class	pass: call plus recent turns	path checks in code	Decision: veto only	thresholds per class
Is this session stuck	split	split	pass	fail for the clock	Code for timers; decision for “repeating itself?”	split the row
Does this alert need a human	pass	pass	pass	counts in code	Decision: Noul	page on error
Which CI checks run	pass	pass per task	pass with a capped diff	pass	Decision, nominated	shadow first
Did this PR pass review	fail	fail	fail	not applicable	Reply: judge	code checks plus a real judge
Summarize or prune the session	fail	fail	fail	not applicable	Reply: compactor	harness and a human

Two rules keep the table from becoming a wish list. Passing all four tests nominates a seat; it grants nothing. And the reply column is never empty: judge and compactor appear in every version, with the reason, because they are the two seats cheap classifiers get pushed into first.

Four tests nominate. Only an eval on your own history earns enforcement, and a missed budget sends the row back.

Where a row passes, the wiring is the same everywhere: the classifier returns a typed answer and code decides what happens. Ask several questions of the same state in one call and compose the policy in code, as in fanning out Jev judgments. The model-tier row gets its own playbook in routing cheap models with Jev, including why low confidence keeps a task on the frontier tier.

Step 4: Earn enforcement with a labeled eval and a written error budget

A nominated seat enforces nothing until it beats a number you wrote down before you looked.

1. Sample your own history. Per nominated row, pull past decisions with the state available at the time: an illustrative 100 to 200, weighted toward denials, escalations, misroutes and pages that mattered.
2. Label with the answer a careful person would give, not the fleet’s. If two labelers disagree, the criteria failed Test 2; fix them first.
3. Write the error budget first, per direction. Misrouting may tolerate a few misses in a hundred because lanes can hand work back. A missed page tolerates far fewer than a needless one. An unsafe allow on a destructive tool tolerates none, which is why that class never auto-allows on a classifier alone.
4. Run the classifier on the same state. Count agreement, each error direction and the unclear share, and keep the denominator.
5. Decide on the budget. Inside it, promote to shadow. Outside, fix criteria or state and re-run once; outside again, the row moves to the reply column.

Thresholds are their own discipline. A Noul returns a probability and no confidence value, while Choice and Score return both, so a cutoff tuned on one does not transfer. The per-tool-class version, and why a clean small sample is still not proof, lives in Jev confidence gates before the tool runs. Promotion then climbs a ladder from shadow to canary to enforce, which shadow-mode Jev before it skips your CI tests lays out for every row.

For any seat that can allow or skip something, write the failure behavior before go-live. When the classifier times out, is rate-limited or errors, write and destructive calls deny, routing falls back to one fixed, logged default, and alert triage pages. Keep permission rules or the sandbox behind every seat anyway: a classifier is a guardrail, never the boundary.

Step 5: Keep judge and compactor in the reply column, and write down why

The judge seat. Split judging into three layers and seat each one.

• Exact checks belong to code. Tests passed, the schema validates, the claimed file exists, the diff touches only allowed paths. No model answers a question a script can.
• Bounded rubric checks and triage may use a classifier, in front of a real judge. Read past the headlines and that is what this week’s experiments built. Braintrust’s post sketches bands: auto-accept above 0.95 confidence, send 0.70 to 0.95 “to a more capable LLM judge”, treat anything lower as inconclusive or for human review, and warns: “These confidence values are not operating thresholds out of the box.” LangChain’s test used five weather requests; on the binary pass/fail score Jev matched the human-labelled oracle on all 500 repeated decisions, and the authors call the results “promising, but early”, adding that “a judge can still be consistently wrong.”
• Open-ended quality and merge or release verdicts never sit with a classifier as sole judge. A community MCP server, jkudish/jev-mcp, ships a jev_gate tool described as a way to “Gate a merge or a ship on completion claims”. That is the seat to refuse: the agent under review chooses whether to call it, and the verdict is a probability on a question no ten-second reader could answer.

Screenshot: Braintrust, “Eval agent responses with Jev” (Sep 18, 2026), captured Sep 21, 2026.

The grader types in the evals playbook are the pipeline these layers plug into. A fast classifier sits at the front as a filter, never at the end as the verdict.

The compactor seat. Writing a summary is synthesis: deciding what mattered, restating it, carrying constraints forward. A model that generates no text cannot write one. The variant being tried instead is filter-style compaction, which scores each turn and drops the low scorers.

By our own reading it fails three ways. The state is the session, far past 32K long before compaction is due, so the classifier scores fragments without the whole. It returns a probability with no reasoning trace, so nobody can audit why a turn vanished. And it edits history, which collides with prompt caching.

Constraints are at stake too: Claude Code’s permission-modes docs warn that a boundary stated in chat can be lost when compaction removes the message, and point to a deny rule for a hard guarantee.

Run a who-breaks-the-cache check on anything that edits history, whether plugin, hook or runner filter:

1. List every component that can remove or rewrite a prior turn.
2. Record where its first edit lands relative to the cached prefix.
3. Replay one long session with and without it and compare the cache-read tokens your provider reports on the next few requests.
4. On prefix-keyed caches, an edit before the cache point means everything after it is read again without the discount, every time. Whoever owns the component owns that bill.

Compaction stays with the harness and, at milestones, a person; the context engineering playbook covers how. A classifier may flag turns that carry a user-stated constraint for a writing model’s summary. It never deletes on its own.

Step 6: Check the table in as a file the fleet reads

Put the table next to the code that calls the classifier and review changes to it like code. TypeSafe’s agent-skill docs make the same point about constants: “Put the constants (questions and thresholds) in a single place so they’re easy to review.” They also note that agents are not great at writing questions, so a person owns the question text in this file, not the agent that proposed the seat.

# decision-seats.yaml (illustrative shape; one file, reviewed like code)
model: jev-1.13.0              # pinned; re-run every row's eval when it changes
seats:
  - id: task_lane
    seat: decision
    status: shadow             # nominated | shadow | canary | enforced | retired
    type: choice
    question: Which lane should take this task?
    options:
      docs: The task changes only documentation files.
      frontend: The task changes UI components, styles or client routes.
      backend: The task changes API handlers, jobs or database code.
      unclear: The task spans lanes, or the text does not say what changes.
    state_fields: [task_title, task_body]
    tests: {under_10s: pass, literal: pass, fits_32k: pass, no_math: pass}
    eval: evals/task_lane.jsonl
    error_budget: {wrong_lane_per_100: 3, unclear_share_max: 0.15}
    on_error: default_lane_logged
    owner: platform
  - id: pr_review_verdict
    seat: reply
    reason: judge; code runs exact checks, a frontier judge or a person decides
  - id: session_compaction
    seat: reply
    reason: compactor; synthesis, and anything that edits history passes the cache check

Review the file when a row breaches its budget, when a new decision shows up in the logs, and whenever the pinned model version changes. The reply rows are not decoration: with a written reason in place, nobody promotes a judge next quarter without editing a line someone will read.

Six ways a TypeSafe Jev seat goes wrong, and the signal for each

The essay question. Someone asks the classifier for the best next step. Signal: answers pile into unclear or spread evenly across options. Fix: split it into small questions and compose in code.

State creep. The state template grows a field at a time until it is half a transcript. Signal: request errors on the largest states, or agreement dropping after a template change. Fix: re-run Test 3 on every template change.

Math by the back door. “Is this older than 30 days?” slips into a Noul. Signal: eval disagreements cluster on dates and counts. Fix: code does the comparison; the classifier only extracts.

The triage band becomes the verdict. The auto-accept band turns into the merge decision the day the stronger judge is switched off to save money. Signal: merged changes whose record shows only a classifier score. Fix: merges require a code-check record plus a judge or human record.

The silent compactor. A plugin prunes history for speed. Signal: cache-read tokens fall with no model change, or early instructions stop being followed. Fix: remove it, or put it through the cache check first.

The seat with no fail mode. Rate limits arrive and nobody wrote the seat’s behavior. Signal: classifier errors in provider logs that never reach your decision records. Fix: on_error is required, and a row without it does not merge.

The seat table is fleet policy, not a prompt

The table, the evals, the budgets and the fail modes live in the layer that runs the fleet: dispatcher, router, permission hook, pager. That layer is what a multi-agent command center is once you strip the dashboard off, and the one place that sees decisions across every vendor’s agents. Whether a coordinator should exist at all is settled in when not to use a coordinator; this table sorts the decisions any coordinator, router or dispatcher makes once it does.

A fast classifier makes a very good if statement. Give it the questions a person answers at a glance, keep the thinking and the writing where they happen, and write down which is which.

FAQ

Can TypeSafe Jev be used as an LLM judge?

As a triage filter in front of a real judge, yes, on bounded rubric questions with criteria and a labeled eval on your own cases. As the sole judge of open-ended quality, or for merge and release verdicts, no. Code runs the exact checks, and a frontier model or a person owns the final verdict.

Sources

• TypeSafe: Introducing System One Models & Jev — Sep 15, 2026 launch post
• TypeSafe docs: Primitives — the three answer types and the one-second judgment rule
• TypeSafe docs: Jev 1.13 jaggedness — literal reading, large state, dates and math
• TypeSafe docs: Models — text-only input, the 64K and 32K limits
• TypeSafe docs: Agent skill — constants in one reviewable place
• Theo Browne, “Jev is incredible” — YouTube, Sep 20, 2026
• Braintrust: Eval agent responses with Jev — Sep 18, 2026
• LangChain: Jev-as-a-Judge for Agent Evals — Sep 20, 2026
• jkudish/jev-mcp — community MCP server with a jev_gate tool
• Claude Code docs: Permission modes — boundaries lost to compaction