System One models return typed values instead of prose — one option from a list, a score on a scale, a probability. Malformed output is structurally impossible. Two arrived within weeks of each other: Jev, proprietary and hosted, and Laya, open-weights and local. We reviewed both against our own AI development platform, and neither is going in yet.
What is a System One model?
A System One model takes a state — a support ticket, an email, a JSON object — plus a set of typed questions about it, and returns answers a program can consume directly. Both models we looked at offer three shapes. Choice picks one option from a set you define. Score places the state on an ordinal scale, like a severity from 0 to 3. Noul returns the probability that something is true, from 0.0 to 1.0. You declare the schema before you ask, which is the whole trick: the model cannot return a value outside the shape you gave it, so there is no parsing step and no retry loop for malformed JSON. Both are non-autoregressive — they answer in a single forward pass rather than emitting one token at a time — and neither can write a sentence.
Jev is fast, typed, and priced against a bill we don’t pay
Jev comes from TypeSafe AI, founded in 2024, which released it in limited early access on 15 September 2026 alongside a $40 million seed round led by DCVC. It is a transformer trained exclusively on synthetic data using what the company calls Reinforcement Learning for Calibrated Decisions, a method it says optimises probabilities against outcomes rather than human rater preference. TypeSafe reports end-to-end response times of 70 to 500 milliseconds and claims Jev is 40 to 200 times faster and 40 to 400 times cheaper than frontier LLMs. Those figures come from the company’s own internal Workflow Evals benchmark, measured against GPT-6 Astra and Fable 5.1 averaged as a reference. TypeSafe says its own team built those workflows, acknowledges possible bias, and calls the gains likely to sit at the high end of real-world results. Published pricing is $0.042 per million input tokens, output free.
Here is the part that decided it. Our platform runs code generation through a subscription-billed CLI rather than a metered API, so the marginal cost of a token is already flat. A pitch built on being hundreds of times cheaper is measured against an invoice we never receive — adopting Jev would mean taking on our first pay-per-call dependency to save money we are not spending. No weights, no paper and a closed waitlist count against it too, but the economics alone settled it.
Laya runs on hardware you already own
Laya, from Convai Innovations, is the open counterpart, and the more interesting of the two for most teams. The weights are Apache 2.0 and published on Hugging Face. The English model is 421 million parameters on a ModernBERT-large backbone; a 322 million parameter variant on mmBERT-base covers 45-plus languages. It is a bidirectional encoder with a decision head, it installs with pip, and the project reports a median latency of 32.8 milliseconds on a Tesla T4 — a GPU several generations old and cheap to rent. For anyone already serving a small local model, and we do, Laya slots into the same pattern: weights baked into the image, no external call, no data leaving the building. That is a genuinely different proposition from a hosted endpoint, and the reason it earned a real evaluation rather than a glance.
Can a model really be incapable of hallucinating?
Yes, in a narrow and frequently misread sense. Because you declare the output schema up front, the model cannot invent a field, return a category you never defined, or emit text that fails to parse. Type errors are structurally impossible rather than merely unlikely, and that is a real guarantee worth having. What it does not mean is that the answer is correct. A System One model can select a perfectly valid option that happens to be the wrong one, and attach a confident probability to it. “Cannot hallucinate” is a claim about the shape of the output, not its truth. The useful number is calibration rather than accuracy: Laya reports an expected calibration error of 0.081 after a temperature refit, meaning its stated confidence roughly tracks how often it is right.
The blocker that isn’t in the launch post
Laya’s headline accuracy is 0.766 on its typed-decisions benchmark, as reported by the project itself; we found no independent third-party evaluation, which is unsurprising for something this new. The number that matters more sits next to it. That 0.766 is the fine-tuned figure. Base checkpoints score around 0.362, close to random. So the model is not a drop-in classifier you point at a problem — it is a starting point that needs a labelled corpus for every decision you want it to make, and building that corpus is the actual project. There are shape limits too: Choice questions degrade beyond roughly 20 options at the default token budget, and problems with 77 or more labels need architectural changes. Jev caps direct choice selection at 255 options.
When we went looking for our own training data, we found the real obstacle. Our platform had several hundred completed tasks on record, but only nine carried the detailed execution row we would need, and none carried a quality score — most work runs through a path that saves the outcome and discards the reasoning. Our blocker was never model availability; it was that we had not been keeping the labels. Two classifier ideas in our roadmap were parked behind the same gap. Laya is the third thing to hit that wall, and finding it a third time turned a vague intention into scheduled work.
What would we need before adopting one?
Three things, in order. First, a decision that genuinely lives inside the model’s competence — bounded, under about 20 options, and high enough in volume that latency is worth optimising. Plenty of decisions in a software delivery pipeline look like classification and are really judgement calls with open-ended answers; those are not candidates, and mistaking one for the other is the easiest way to waste a quarter. Second, a labelled corpus, which for us means capturing the traces we have been throwing away and waiting for them to accumulate. Third, a shadow comparison against the frontier-model judgement already doing that job, because replacing a capable general model with a 421M specialist is only an upgrade if the specialist wins on your data.
Our honest read: the category is real, and the open-weights half matters more than the speed. A model you can run locally, audit and fine-tune on your own labels is a durable asset in a way a metered endpoint is not. But both launches lead with latency and price, and for many teams — us included — neither is the binding constraint. If you are evaluating this class of model for your own stack, check your labels before you check the benchmarks.
Frequently asked questions
Is Laya free to use?
Yes. Laya’s weights are published under the Apache 2.0 licence on Hugging Face, it installs via pip, and it runs on ordinary CPUs or GPUs — the project reports results on a Tesla T4. There is no API key and no per-call charge; your only cost is hardware.
Can Jev or Laya replace a large language model?
No, and neither vendor claims otherwise. They handle bounded decisions — routing, classification, gating, scoring — while a general model keeps text generation and open-ended reasoning. The intended pattern puts the two side by side, with the decision model in front as a fast filter.
Do these models really never hallucinate?
They cannot produce output that breaks the schema you defined, so malformed or invented fields are impossible. They can still choose the wrong valid option, and report high confidence doing it. The guarantee covers the structure of the answer, not its correctness.
How accurate is Laya out of the box?
Not accurate enough to deploy untuned. The project reports roughly 0.362 on its typed-decisions benchmark for base checkpoints, near random, rising to 0.766 after fine-tuning. Using it means building a labelled dataset for each decision first. We found no independent third-party benchmark at the time of writing.
Get a free recommendation from a senior engineer.