Jev shipped into early access on 15 September 2026, which means nothing about it is in any model's training data and most of what is written about it is guesswork. Everything below is written against TypeSafe's published documentation.
The trade
Every model you have used was built to write. That single capability is what makes language models feel general, and it is also what makes them slow, expensive and hard to fully trust.
Jev gave it up. It cannot write you a sentence. What it does instead is decide — in 70 to 500 milliseconds, returning a value from a set you defined, with a calibrated confidence number your code can gate on.
The name for this is a System One model. Psychologists split human thinking into two systems: System Two is deliberate and generative, the part that sits down and reasons something out; System One is the fast, automatic part that recognizes a face or judges that a room is tense. Language models were built for System Two, and we have been asking them to do System One work because they were the only tool on the table. That is why an agent spends twelve seconds and real money answering "is this ticket urgent."
The question to ask is never "can Jev do this?" It is "is this half of the work a decision?" Almost every agent call has a decision half and a generation half tangled together. Finding the seam is the whole skill.
The three primitives
Pick by what the answer means, not by what feels natural to write.
| Takes | Returns | Use when | |
|---|---|---|---|
| Choice | Options plus state | The chosen option, a probability for each, and a confidence | The alternatives are distinct and unordered |
| Score | State plus 2–10 ordered levels | A probability-weighted value, probabilities per level, a legend, a confidence | You are measuring a position on a spectrum |
| Noul | A statement plus state | A probability from 0 to 1 that the statement holds | The question is genuinely yes or no and you will threshold it |
Picking wrong does not raise an error. It returns a plausible, well-formed, confidently-scored answer to a question you did not mean to ask, which is the failure worth designing against.
The test for Choice versus Score: shuffle your options. If shuffling changes nothing — billing, technical, account, spam is the same set in any order — it is a Choice. If shuffling destroys the meaning — low, medium, high, critical has a direction — it is a Score, and using Choice throws away the ordering.
The test for Noul versus a two-option Choice: ask what your code does next. If you are going to compare against a threshold, you want a Noul. If both labels are real categories, refund versus exchange, use Choice.
A Score is a position, not a level
The most misread thing in the API. A Score does not return one of your levels. It returns each level number multiplied by its probability, summed — so a four-level rubric can come back as 2.6, and there is no level 2.6. Round it to the nearest level and you have thrown away exactly the information you called Score to get.
Confidence is the reason the model exists
Every Choice and Score answer carries a confidence between 0 and 1, derived
from how the probability mass is spread across your options or levels. It adds
no information the probabilities did not already carry; it is a convenient
summary of the distribution's shape, which is why TypeSafe also returns the full
probabilities so you can compute your own measure if theirs does not fit.
A Noul carries no confidence. It returns one probability, and how far that sits
from 0.5 is the signal. An audit or a gate keyed on confidence silently skips
every Noul in a request — usually where the guardrails are.
The documented way to use it is three tiers, not one number:
- High — act automatically, no human in the path.
- Medium — proceed with caution: confirm, flag, or gather more state.
- Low — do not act. Route to a human, or fall back to a language model.
Where you draw the lines depends on what happens when you are wrong. Read-only work can act at moderate confidence. Destructive operations want above 0.9. The advice is to start conservative, test against your own data, and adjust.
A gate that never fires is not broken. If your task is genuinely easy, the probability mass really is peaked and high confidence is the honest answer. Raising the bar until something trips manufactures uncertainty that is not there, and you will start routing correct answers to humans to justify the check.
Where it earns its keep
Three patterns show up first in production, and all three are the same move: a bounded decision placed in front of unbounded generation.
- Model router. Jev sits upstream and decides whether a request needs the fast model or the powerful one. The routing decision has no prose in it; the thing you route to does the writing.
- Tool-call guardrail. Before a tool call executes, Jev checks it: does this modify production, is it in scope, can it be undone. This only became practical when the check got cheap enough to run on every call.
- Pre-filter. Jev handles the easy majority and only the residue reaches the language model. Expect your language model spend to fall and the average quality of its remaining calls to drop — you removed all the easy cases. That looks like a regression on a dashboard and is not one.
The design principle underneath all of them: decompose. Ask atomic questions in one request rather than one compound question. Every question in a request is evaluated in parallel against the same state, so four questions cost roughly what one costs, and the combination logic lives in your own code where you can read and test it.
Where it is the wrong tool
- Anything that ends in prose. Summaries, replies, explanations, generated code. The half it gave up is still a half.
- Anything unbounded. The option set has to exist before the call. That constraint is what makes the output type-safe.
- Anything a plain
ifalready handles. Jev is cheap against a language model. It is not cheap against arithmetic.
The numbers, and the ones that bite
- Price: $0.042 per million input tokens. Output is free because there is no output.
- Latency: 70 to 500 ms, end to end. That is a range, not a guarantee — if it straddles your budget, measure rather than assume.
- Cardinality: single-stage selection caps at 255 options. Beyond that you go two-stage: pick a coarse group, then pick within it. A 1,400-category catalog is a two-stage problem, not an impossible one.
- Context: 64k tokens per request overall, and 32k for the state plus the single longest question. Two budgets, and the second one catches people out.
- Input: text only. Pre-process images or audio into text first.
- Score levels: two to ten.
- Language: English is the primary training language and where accuracy is best. Other languages including CJK scripts are handled but not equally well — test on your own content and watch confidence when routing.
Early access means these can move. Check the docs before you build a design around any specific figure.
Check whether it stuck
Reading about a decision model and being able to use one are different things. The questions below are sixty scenarios — situations an engineer would actually be in — with every option explained, including the ones you did not pick.
Jev practice tests on Udemy — 60 scenario questions, every answer explained
Two timed tests. The first covers the decision-or-generation split, the three primitives and confidence. The second covers the documented patterns, state shapes and the limits above.
There is no Jev certification, and anyone selling you one is inventing it. This is practice, which is a different and more honest thing.