The short answer
Pick a System One model when the next thing that happens is an if statement. Pick an LLM when the next thing that happens is a person reading something.
Most real systems want both. A support pipeline might use Jev to decide which queue a ticket belongs in and how urgent it is, then hand the ticket to an LLM to draft the reply. The models are not substitutes for each other.
Side by side
| System One model | LLM | |
|---|---|---|
| Output | Typed value: a chosen option, a number on a scale, or a probability from 0 to 1 | A string, which you parse and validate |
| Probabilities | A full distribution over your options, returned as the primary output | A token log-probability, if the API exposes one at all |
| Latency | 70ms to 500ms, per TypeSafe’s own figures for Jev | Seconds, and it grows with output length |
| Cost model | Input only. Jev charges $0.042 per million input tokens, output free | Input and output, with output usually priced higher |
| Free-text hallucination | Impossible. No prose is generated | Possible on any call that writes text |
| Explanation | None. The model does not justify itself | On request, though the explanation may not match the real cause |
| Generation | None. Jev 1.13 “is not trained to generate text” | The main capability |
Output is the difference that matters
An LLM gives you a string. Even with JSON mode or a schema, you still receive text that happened to be shaped like JSON, and your code still parses it, still validates the enum, still handles the case where the model returned "Billing" when your switch expects "billing".
A System One model gives you a value drawn from the option set you defined. There is no parse step, because there is nothing to parse. TypeSafe’s own docs call these “typed answers and probabilities rather than generated text.”
The probability distribution matters as much as the answer. Jev returns a probability for every option you supplied, and for Choice and Score questions a confidence value derived from the shape of that distribution. That number is what makes confidence-gated actions possible: act automatically above one threshold, ask a human below another. Getting the equivalent out of an LLM means scraping token log-probabilities, which are about the token, not about the decision.
Latency and why the gap exists
An LLM generates one token at a time, each conditioned on the last. To emit the word “billing” it runs a decode loop. A reasoning model runs a longer one, spending extra tokens on intermediate steps first.
TypeSafe says Jev “generates all outputs in a single query” instead. Sean Goedecke, writing about the launch, made the same point about the general technique: “If you want fast, parallelized structured output against limited choices, you don’t strictly need to do autoregressive generation at all… Since LLMs ingest all input tokens in parallel, this is way faster than generating the entire structured output.”
Goedecke is describing the shape of the computation rather than Jev’s design, which TypeSafe has not published. What is known about the architecture stays short on purpose.
One practical consequence: with Jev, asking more questions about the same state is close to free in latency terms, since they run in parallel within a single call. With an LLM, more output is more time.
Cost
Jev bills input only, at $0.042 per million tokens, with output free. Your bill is the state you send plus the text of your questions.
Input-only billing changes which designs are affordable. Re-ranking fifty retrieved passages by running a separate scoring question over each one is a cost decision with an LLM and mostly a latency decision with a System One model. Semantic reranking is the obvious case.
The comparison is not clean, though. Both of TypeSafe’s speed and cost multiples come from its own evaluations, and the frontier-model baselines are not published in detail. Jev speed and pricing goes through what those numbers do and do not cover.
Hallucination, carefully
A System One model cannot invent a case number or a citation, because it never writes a sentence. The guarantee is real and it is narrow.
Being unable to make things up in prose is not the same as being right. Jev can pick the wrong option at high confidence. It can return a probability that does not match how often it is actually correct. TypeSafe’s own jaggedness page for version 1.13 lists nine weakness areas, including arithmetic, counting, and date handling: the model “reads dates as text, not as ordered quantities.” It also gives no guarantee that a question and its negation return probabilities summing to 1.
An LLM with a validated JSON schema has a similar guarantee about its output shape and none about its content. The System One advantage here is smaller than the launch coverage suggested, and it lives in the probabilities rather than in the types.
What about reasoning models?
Reasoning models sit at the far end from System One models. They spend more compute per answer, not less, working through intermediate steps before committing. That buys accuracy on problems with many dependent steps and costs seconds per call.
Goedecke’s caution is worth keeping: “I doubt Jev is ever going to be as smart as frontier LLMs. Not being able to use test-time compute at all is a big disadvantage.” A model that cannot think longer about a hard case has no gear to shift into. The jaggedness list is full of multi-step tasks for the same reason.
There is no product on the market branded a “System Two model.” The phrase describes the deliberate half of Kahneman’s split, which in practice means a reasoning LLM.
Choosing, per decision
Reach for a System One model when the answer is one of a known set, the decision happens inside code, you want a number you can threshold on, and the call sits in a latency budget measured in milliseconds.
Reach for an LLM when the output is prose or code, the task needs several dependent steps, the option set is not known in advance, or the input is images or audio. Jev takes text only.
Reach for both when a decision gates a generation, which is most agent and workflow code. Intent and model routing is the canonical version: a cheap typed decision picks which expensive model runs next.
FAQ
Is a System One model faster than an LLM?
For classification and scoring, TypeSafe claims Jev runs in 70ms to 500ms against 3 to 329 seconds for frontier models, a 40x to 200x gap. Those are vendor figures from TypeSafe’s own evaluations, with no independent benchmark published as of 18 September 2026. Measure on your own state sizes.
Can I replace my classifier LLM calls with Jev?
Often yes, if the task is picking from a known option set of 255 or fewer and the input is text. You lose the ability to fall back to free-text output for odd cases, and you gain a calibrated probability distribution plus a confidence value your code can threshold on.
Do System One models hallucinate less?
They cannot hallucinate free text at all, since they generate none. They can still return a wrong option or a poorly calibrated probability. TypeSafe documents nine weakness areas for Jev 1.13, including counting, arithmetic and date comparison, so the guarantee covers output shape rather than output correctness.
Is this just structured outputs with extra steps?
Structured outputs constrain an LLM’s token generation to match a schema. A System One model never runs that generation loop and is trained specifically for calibrated probabilities. Whether that difference is worth a new category name was the main argument on Hacker News after the launch.
Which is cheaper?
Jev charges $0.042 per million input tokens and nothing for output, so a classification call costs roughly the price of the text you send. LLM pricing bills output too, usually at a higher rate. The gap widens on designs that run many small judgments over the same content.