Jev vs Laya: The Same AI Idea, One Closed and One Open

A new category of AI model landed this month, and it arrived twice at once. First came Jev, a hosted product from TypeSafe AI. Weeks later, an open-source model called Laya appeared, doing the same job and claiming to be faster. If you route support tickets, filter spam, or score risk with a large language model today, this comparison matters to your bill.

Both models come from the same observation: most production AI pipelines do not need text generation. They need a label. Your LLM burns 500 milliseconds to 2 seconds streaming tokens like "The correct category is: billing" so your code can parse the label back out. A decision model skips all of that. State goes in, a typed answer with a probability comes out. No prose, no parsing, no hallucinated sentences.

TypeSafe calls this a System One model, after the fast, instinctive half of the brain. The name fits. Here is how the two contenders actually compare.

What they share

The interfaces are nearly identical. Both models accept three types of questions:

• Choice: pick one option from a closed list, like billing, technical, or other, with a probability over every option.
• Score: place the input on an ordered scale, like relevance from 0 to 5.
• Noul: return the probability that a statement is true.

Neither model generates text, so neither can produce a malformed answer. That is what "zero hallucinations" means here: the output always matches your schema. A wrong classification is still possible, which is why both vendors recommend escalating to a human when confidence drops below roughly 0.3 to 0.5.

You also feed both models a batch of questions at once, and each question is evaluated independently. This is not a nicety. Batching is the intended usage pattern.

Where Jev has the edge

Jev launched September 15, 2026, from TypeSafe AI, founded by Diogo Almeida, a co-creator of ChatGPT. You call it over an API at $0.042 per million input tokens (output tokens are free), with typical responses around 150 milliseconds.

Its clearest win is option count. On the Banking77 benchmark, which requires picking from 77 intent labels, Jev scored 0.870 while Laya managed 0.425. The gap is architectural, not a matter of tuning: Laya shares a fixed token budget of roughly 192 to 256 tokens across all candidate options, so past about 20 choices each option gets only a few tokens of representation. Keep your choice schemas small and this never bites you. Need 50 categories? Jev handles it today; with Laya you would need a coarse-to-fine hierarchy.

Jev is also calibrated out of the box. On the typed-decisions benchmark its expected calibration error is 0.144 versus Laya's 0.213, meaning its probabilities can be trusted as probabilities sooner. And there is nothing to host: no GPU, no model files, no cold starts.

Where Laya has the edge

Laya, from Convai Innovations, is Apache 2.0 licensed with weights on Hugging Face. It is a 421M-parameter encoder (ModernBERT-large, with a 322M multilingual variant covering 100+ languages) that runs on your own hardware.

• Latency: about 33 milliseconds per query on a single GPU, dropping to 7 milliseconds per question when batched. That is roughly 6 to 8 times faster than Jev's network round trip.
• Cost: no API fee at all. You pay for the GPU you already own.
• Privacy: state never leaves your server. Air-gapped deployment works.
• Customization: you can fine-tune it. Jev's weights are closed, so this is not an option there. ConvAI ships a Kaggle notebook that fine-tunes Laya on free GPUs in about 4 hours.

There is also a story behind Laya. Its creator published a reinforcement-learning approach to probability prediction in March 2025 (arXiv:2503.23303) and argues Jev arrived at the same idea later and closed. TypeSafe has not responded publicly. The documented facts are that his early work is real and predates Jev, while the Laya model page itself was created after Jev's launch. Simultaneous invention is plausible; copying is an accusation, not a proven fact. For your purchase decision it matters less than the practical differences below.

The honest benchmark picture

Almost every number in public circulation is self-reported, and the two sides' claims cut against each other. Read them carefully:

• Laya's fine-tuned typed-decisions checkpoint reports 0.766 accuracy versus Jev's published 0.727. But its own model card admits Jev's figures are third-party published, sample sizes and prompts differ, and the checkpoint was fine-tuned on that benchmark's training split. That measures specialization, not superiority.
• The speed comparison (33 ms vs 150 ms) pits local warmed-up GPU inference against hosted API calls including network time. Fair for your cost math, less fair as a pure model comparison.
• The vendor "ceiling" numbers (Jev claims around 400x faster than frontier LLMs; Laya claims 7.8x) are best cases. Realistic independent gains for decision-in-a-pipeline workloads land around 7x to 25x versus a frontier LLM.
• One independent test (Mike Taylor's) found Jev caught 6 of 7 planted defects where a frontier LLM caught 7, but 25 times slower.
• A separate zero-shot RAG routing benchmark from LargitData is the sharpest warning: their untuned Laya 322M base model got 0% of full multi-turn routing decisions right, while hosted Jev hit 61.4%. Fast and free is worthless if the untuned base model cannot do your task.

The honest summary: Laya wins when the task matches its training or after you fine-tune it. Jev wins out of the box, on wide option sets, and on calibration.

One trap that deserves its own section

Laya's English checkpoint scores 0.080 accuracy on Bengali script while reporting 0.945 confidence. The model cannot read the script, and it has no idea it cannot read it. Confidence gating will not save you, because the confidence itself is wrong. Laya ships a Router that detects the Unicode script and dispatches to the right checkpoint, including a multilingual one. Use it, or route by script yourself before inference. Any decision model tuned on Latin-script data will have some version of this failure mode.

How to choose

• Pick Jev if you want zero ops, need more than 20 choice options, trust its calibration, or want to try the category without owning infrastructure. It is self-serve through the Vercel AI Gateway if the official waitlist is slow, and the API cost is negligible at decision volumes: $0.042 per million input tokens means millions of decisions for pocket change.
• Pick Laya if data cannot leave your environment, latency budgets are in tens of milliseconds, volume makes even small API fees add up, or you want to fine-tune on your own labeled decisions.
• Pick neither if your task is open-ended generation. These models only answer questions you can define in advance. If you cannot enumerate the categories today, you need a language model, not a decision model.

Whichever you pick, start with a high-volume but reversible task. Keep your current process in shadow mode, log the model version, the full probability distribution, and the actual outcomes, then tune thresholds from real data before you let the model decide anything on its own.

The System One category is real, and both implementations prove the thesis: a huge share of "AI pipeline" work is classification wearing a generative model as a costume. Now there are two serious ways to take the costume off.