Most production AI calls are not conversations. They are decisions: route this ticket, flag this message, pick one of six categories, decide whether to escalate. You reach for a language model because it is the tool you have, then you spend the next hour making it return something your code can use.
A different class of model is now being sold for exactly that job, and it does not generate text at all. TypeSafe calls its entry a System One model, and Convai Innovations has published an open-weights model of the same shape. The performance gap they claim over a chat model is large enough to be worth checking carefully, and the limits are large enough that most teams should not switch everything.
What Is a System One Model?
A System One model takes a state and a set of typed questions, then returns every answer at once with a probability attached to each. TypeSafe describes the category as "a new class of frontier models built to make fast, structured decisions that software can use directly" and says Jev "generates all outputs in a single query" rather than one token after another.
That single sentence is the whole architectural difference. A language model produces your JSON left to right, one token at a time, and a schema constraint works by forbidding tokens that would break the structure. A System One model is handed the structure first and fills it in, so the output is what TypeSafe calls a "type-safe structured value" by construction.
The consequence TypeSafe leans on is that type errors become, in its words, "mathematically impossible". Read that claim precisely. It guarantees the shape of the answer, not the truth of it. A decision can be perfectly typed, validate cleanly against your schema, and still be wrong, which is what the confidence number exists to surface.
Tech AI Wire reported that TypeSafe launched Jev on September 15, 2026, and access is still behind a waitlist as of September 20, 2026.
Why Constrained JSON Still Costs You Time
Schema-constrained decoding solved the parsing problem two years ago, and it solved it well. If your question is whether the response will match your schema, that is answered: our guide to LLM structured outputs covers how every major provider now guarantees it at the token level.
What constrained decoding does not remove is the generation itself. The model still walks your schema token by token, and you still pay for those tokens and wait for them. For a decision whose entire output is one enum value and a number, that is a lot of machinery to produce four bytes of meaning.
TypeSafe puts the end-to-end latency of frontier language models at 3 to 329 seconds for the tasks it benchmarked, against 70 to 500 milliseconds for Jev. Treat the upper figure as the vendor's own worst case for a slow agentic task rather than a typical chat completion, and the direction still holds: token generation dominates, and a decision does not need it.
The Four Options Compared
Four approaches cover almost every real decision call. Prices and versions below were read from each vendor's own page on September 20, 2026.
| Approach | Returns | Price per 1M input tokens | License | Self-host |
|---|---|---|---|---|
| TypeSafe Jev | Typed value plus calibrated probability, one pass | $0.042 | Closed, waitlist | No |
| Convai Laya | Typed answer plus probability, 421M parameters | Free to run | Apache 2.0 | Yes |
| ModernBERT-large fine-tuned | Whatever head you train, typically a label | Free to run | Apache 2.0 | Yes |
| gpt-5-nano with structured outputs | JSON matching your schema | $0.05 | Closed API | No |
Anthropic's smallest generally available model, Haiku 4.5, prices input at $1 per million tokens and output at $5 per million, which is roughly twenty times the input cost of gpt-5-nano and makes it the wrong default for high-volume classification even though it is the better writer.
The two open entries deserve attention because they remove the per-call bill entirely. Laya holds 421 million parameters, 395 million of which are the ModernBERT-large backbone, with a decision head trained on top. It reports a median latency of 32.8 milliseconds per question on a Tesla T4, which is an older and inexpensive data center card rather than current hardware.
What the Latency Difference Looks Like
The numbers only land when you see them against each other on one axis.
A logarithmic axis is the only honest way to draw this, because the slowest figure is roughly ten thousand times the fastest. The practical reading is simpler than the ratio: a typed decision model fits inside a request that a user is waiting on, and a frontier model with an agentic loop does not.
How to Tell If Your Call Is a Typed Decision
Work through four questions about one specific call in your stack, not about your application as a whole.
- Is the output space finite and known in advance? A category, a boolean, a priority level, a routing target. If the answer is free text, a summary or generated code, stop here: these models cannot produce it.
- Does anything downstream read the prose? If a human reads the model's explanation, you need a language model. If only your code reads the result, you do not.
- Can you label training data? This is the question that decides everything, and the next section explains why.
- Is the input short? Laya's English checkpoint reads 512 tokens and its multilingual checkpoint 1,024. That is about one email, not one support thread.
Point four hides a detail worth knowing. ModernBERT-large natively supports an 8,192 token context, so Laya's window is a property of how the checkpoints were trained rather than a limit of the underlying encoder. If your inputs are longer, that gap is where your own fine-tuning work would start.
Where These Models Break
The honest limits are published, and they are sharper than the marketing.
Laya's documentation states the position plainly: it is "a fast base to specialise, not a zero-shot decision engine". The numbers back that up. Fine-tuned on a typed-decisions benchmark of 2,000 decisions it reaches 0.766 accuracy, and evaluated zero-shot it scores 0.362 in English and 0.352 multilingual, which its own model card notes is below the majority-class baseline. A model that loses to always guessing the most common answer is not a drop-in anything.
So the real cost of the open option is not inference. It is labeling a few thousand examples of your specific decision and running a fine-tune, which is a week of work that a hosted API call does not ask of you.
Jev has a different limit that will decide some designs for you: a maximum choice cardinality of 255. Routing to one of a few dozen queues is fine. Assigning to one of 4,000 SKUs is not, and no amount of prompt work changes it.
Both models also give you a confidence number, and confidence numbers are only useful if they are calibrated to reality. Log the probability alongside the outcome for a week before you build a threshold on it, and check whether 0.7 really means seventy percent on your traffic.
Which One Fits Your Situation
Already paying for a frontier model and your volume is low: stay where you are. Structured outputs on gpt-5-nano at $0.05 per million input tokens is cheap enough that engineering time costs more than the API.
High volume, narrow decision, data you can label: fine-tune Laya or ModernBERT-large and self-host. Apache 2.0 on both, no per-call bill, and a median latency in the tens of milliseconds on a cheap card.
You need the latency inside a user-facing request: a typed decision model is the only option on this list that fits a real-time path, whether hosted or local.
Regulated data that cannot leave your network: the open-weights entries are the only candidates, because Jev is a hosted API with waitlist access and no self-host story.
You need an explanation a person will read: none of this applies. Use a language model with structured outputs and accept the latency.
Conclusion
"Call an LLM" became the default answer to problems that predate language models by a decade. Text classification with a fine-tuned encoder was solved in 2019. What is genuinely new in 2026 is the calibrated probability and the typed output arriving together, fast enough to sit in a request path.
The open end of the list is what actually changed. TypeSafe Jev is still a waitlist and a closed API, but Convai Laya put a typed decision model under Apache 2.0 with a published 32.8 millisecond median on a Tesla T4, so the architecture is no longer something you have to be granted access to.
Before you move a single call, answer the question that decides all of it: can you label two thousand examples of this specific decision? If you can, the open path costs a week of work and then nothing per call. If you cannot, you are choosing between a waitlist and the structured-output API you already pay for, and latency is the only variable left to compare.
Related DevToolLab Tools
- JSON Schema Validator - write the schema your decision must conform to and check it catches the missing fields and type errors before a model ever sees it.
- JSON Validator - paste a model response and get the line number when a constrained-decoding call still returns something your parser rejects.
- CSV to JSON Converter - turn a labeled spreadsheet of past decisions into the JSON your fine-tuning run expects, which is the first step of the Laya path.
- Diff Checker - compare the outputs of two approaches side by side when you shadow a typed decision model against your current LLM call.