Definition
A model that answers questions instead of writing
A System One model reads whatever you give it to look at, which TypeSafe calls the state, and answers questions about it whose permitted answers you have written down in advance. It tells you how much probability it puts on each of those answers. It writes nothing.
The name comes from Daniel Kahneman's Thinking, Fast and Slow, where System 1 is fast and intuitive and System 2 is slow and deliberate. TypeSafe, the lab that introduced the category, describes its models as making fast, focused judgments that software can use directly, and released Jev as the first one.
System One model is currently a vendor's category name, not an established model class with a published architecture you could reproduce. TypeSafe describes a new architecture, a parallel sampler and a training method it calls Reinforcement Learning for Calibrated Decisions, but has not released a paper, weights or implementation details. Treat the category the way you would treat any product term that is one release old.
The interface
Three question types, and what each one returns
Everything a System One model can be asked reduces to three shapes. The detail that matters, and that most coverage gets wrong, is that they do not all return the same thing.
| Question type | What you define | What comes back |
|---|---|---|
| Choice | An unordered set of named options, up to 255 | The highest-probability option, the probability of every option, and a confidence number |
| Score | An ordered set of described levels, between two and ten | A score, the legend you supplied, the probability of every level, and a confidence number. The score is the probability-weighted mean of the level indices, so it can be fractional |
| Noul | A yes or no proposition | One number: the probability that the answer is yes. There is no confidence field |
Questions in one request all read the same state and are evaluated independently, so one answer cannot see another. Because the state is sent once and each extra question adds only its own tokens, asking several at once is cheaper than asking separately. That independence is also why the answers are not guaranteed to agree with each other: TypeSafe documents that a yes-or-no question and its negation need not sum to one.
Two errors circulate widely here. The first is that every answer carries a confidence score; Noul does not have one. The second, which appears in several Chinese-language guides, is that Noul returns three values for true, false and unknown. It returns a single probability, and uncertainty shows up as a number near 0.5 rather than as a third outcome.
One real call
What actually comes back
Abstract descriptions of this interface are easy to misread, so here is a real one. Three questions were asked about a restaurant booking page in a single call on 2026-09-19: which action to take next, whether the goal had been reached, and how far along the task was.
| Question asked | What came back |
|---|---|
| next_action, a choice among five actions | set_party_size, holding 0.73 of the probability, with 0.27 on one rival and zero on the other three. Confidence 0.66 |
| goal_reached, a yes or no | 0.05, meaning it is fairly sure the goal is not yet reached. No confidence field |
| progress, a score over four described levels | 0.97, with 0.91 of the probability sitting on level 1 of 3. Confidence 0.91 |
The whole call read 543 input tokens, cost $0.0000228, and took 389 milliseconds end to end.
Three things in that response are worth pausing on. The chosen action holds 0.73 of the probability while its confidence is 0.66, which is the clearest demonstration that the two numbers are not the same: the distribution is split, and confidence reports the split. The yes-or-no answer has no confidence field at all, because that type does not carry one. And the score came back as 0.97 rather than a whole number, because a score is the probability-weighted average of the levels, which is why it is useful for comparing against a threshold and misleading if you read it as a level.
Reading the numbers
Probability and confidence are not the same number
For a choice or a score, the model returns both a probability for every option and a separate confidence value, and they answer different questions.
A probability is about one option: how much belief the model puts on that specific answer. Confidence is about the shape of the whole distribution: how concentrated it is. All the probability on one option gives a confidence of 1.0, and the more evenly it spreads, the lower the confidence falls. A choice can have a top option at 0.45 with the rest spread thinly, or at 0.45 with a single rival at 0.44, and those two situations mean very different things while sharing a top probability.
This matters the moment you use one of these numbers as a threshold, letting software act above it and stop below it. Thresholding on confidence and thresholding on the selected answer's probability are different policies, and they part company in exactly the cases you built the threshold for. TypeSafe exposes the full distribution precisely so that an application can compute whichever statistic fits its decision.
The central misconception
A guaranteed shape is not a guaranteed answer
The claim that travels furthest about this class of model is that it cannot hallucinate. The vendor was precise about what that means; most of the coverage has not been.
What is guaranteed is the shape of the answer. If you offer four options, you get one of those four. There is no free text, so there is no invented field, no malformed JSON, and no answer outside the set. That guarantee is structural, and it is real.
What is not guaranteed is that the option it picked is the right one. TypeSafe says so in its own launch post, in the fine print under the chart: the zero it plots for hallucinations is not a measured result but a consequence of the schema guarantee. Its own words are that the number is not empirical, and that schema matching is guaranteed, so it can confidently plot zero.
So the model can select a legal option, be wrong, and report a high probability while being wrong. The clearer formulation is that a System One model guarantees an in-schema response, not a true one. A Chinese explainer put the same point well: type safety is not the same as a correct judgment, because the guarantee is that the returned value lies inside the option set you defined, not that the chosen option is the right answer.
Documented limits
What the vendor says it is bad at
TypeSafe publishes a list of the model's weak spots. For the current version it documents these:
- It reads literally, and can miss implied intent or trip on negation.
- It is unreliable at counting and arithmetic. Numeric logic belongs in your code.
- It is unreliable at ordering dates and working out durations.
- Accuracy falls when answering takes several hops of indirection.
- Accuracy falls when a large state carries material the question does not need. TypeSafe calls this context rot.
- Text inside the state can mislead it, the way a prompt injection misleads a text model.
- It is confused when a question's instructions and its criteria disagree.
- A fractional score is for comparing against a threshold, not for reading off an exact quantity.
It accepts text only. It is strongest in English and less accurate in other languages. And it generates no text, code or explanation of its reasoning, so if you need to know why it answered as it did, that is not a question this kind of model can be asked.
Speed and price
How to read the headline multipliers
Jev is priced at $0.042 per million input tokens, with output currently free, and TypeSafe publishes end-to-end latency in the range of 70 to 500 milliseconds, measured, as it discloses, from company laptops on the same coast as the service. Those two facts are the reason anyone is interested: a decision at that price and that latency can sit inside a loop that runs constantly.
The larger numbers on the vendor's home page, 193.6 times faster and 444.6 times cheaper, come with conditions that almost never survive into secondary coverage. The workflows were written by its own model-capabilities team, and it says some bias could exist. The reference answers were not human ground truth but the average of two frontier models, which it says biases the comparison toward those vendors. The models it compared against ran through its own wrapper for extracting probabilistic decisions, which it describes as its most accurate option and also slower and dearer than asking those models for decisions without probabilities. It says outright that it expects the figures to sit at the higher end of real-world gains. On price it adds that it cannot prove the rate is unsubsidised.
None of that makes the numbers dishonest. It makes them vendor benchmarks with their conditions disclosed, which is more than most launches offer. The useful posture is to take the price and latency as things you can verify yourself in an afternoon, and to treat the multipliers as a claim awaiting independent replication.
Where it fits
The questions this shape answers well
The fit is decisions that are frequent, bounded and low-value individually: routing a ticket, judging whether a page changed materially, choosing which tool to call, scoring a lead, deciding whether a step is done. These are the places where a text model is asked to write a word that the calling code immediately matches back against a fixed list of permitted values, and where paying for generation buys nothing.
The misfit is anything that needs language out: writing, explaining, summarising, coding. It is also a poor fit where the answer set cannot be enumerated in advance, because enumerating it is the interface.
A useful test: if you can write down every answer your code is prepared to accept, this shape fits. If you cannot, it does not.
Next
A decision model needs a loop around it
One decision is not useful on its own. Something has to hold the state, work out which actions are possible right now, turn them into questions, decide whether the answer is confident enough to act on, run the action, and know when to stop. That surrounding loop is a harness, and a harness for this kind of model looks different from one built for a text model.
We wrote up what that loop has to do in what is a System One harness, and open-sourced our implementation of it, which is described in System One Harness is open source.
FAQ
Common questions
Is a System One model just a small LLM?
It is not a language model with a smaller parameter count. A language model generates text one token at a time, and a System One model returns typed answers with probabilities and generates nothing. TypeSafe describes a different architecture and a different training objective, although it has not published the details that would let anyone verify the internals.
Is a System One model just a classifier?
A classifier is the closest familiar thing, and for a single choice question the comparison is fair. It differs in four ways. The label set is defined per request rather than trained in. Several questions can be asked about one state at once. Scores over ordered levels and yes-or-no probabilities sit alongside choices as first-class answers. And TypeSafe says the model is trained specifically for calibrated decisions, which is a claim about its training objective rather than something classifiers cannot do.
Can a System One model hallucinate?
It cannot return an answer outside the set you defined, which is what the zero-hallucination claim refers to and is guaranteed by construction rather than measured. It can still choose the wrong option from that set, report a high probability while doing so, and be misled by text inside the state. A guaranteed shape is not a guaranteed answer.
Does a System One model confidence of 0.9 mean the answer is right ninety percent of the time?
No, and the two halves of that question come apart. A confidence of 0.9 says the distribution is highly concentrated on one option, which is a statement about shape, not about how often the model is right. The nine-in-ten reading belongs to a calibrated outcome probability: across many answers given a probability of 0.9, about nine in ten should turn out true. Even there it is a property of the population, not a promise about the answer in front of you, and TypeSafe documents that caveat directly. If what you want to gate on is how often the model is right, gate on the probability, not on confidence.
Is Jev open source?
No. The model is proprietary and hosted, and no weights or architecture details have been published. Reports that Jev was open-sourced refer to independent reimplementations by other people, not to the model TypeSafe serves.
Route every task to the configuration that finishes it
Run real tasks across harnesses through one contract, compare success, latency and recorded cost, and send each class of work to the measured winner.
Start building free