Laya vs Jev: The Open-Source System 1 Decision Model Head-to-Head

Laya is an open-source, 421M-parameter System 1 decision model that answers typed questions in 32.8 milliseconds on a T4 GPU and costs nothing to host. Fine-tuned on a shared benchmark, it edges TypeSafe's closed Jev API (0.766 against 0.727 accuracy) while running roughly eight times faster, and Jev still wins where context length and option-set width matter.

Both models come from the same training family, RLCD (Reinforcement Learning for Calibrated Decisions). The difference is what happens after the weights: Jev ships as a managed API from TypeSafe AI, the startup founded by Diogo Almeida, a co-inventor of ChatGPT, while Laya ships as Apache 2.0 checkpoints you run on your own hardware. Released six days apart in September 2026, the two define the same new model class from opposite sides of the licensing line.

I verified the numbers directly against Laya repository on GitHub and cross-referenced them with AI Model Report's read of the shared typed-decisions benchmark. The figures hold up: 32.8 ms p50 on a T4, 0.766 fine-tuned accuracy, and 24.5k GitHub stars within a week of the repo going public.

Key Takeaways

• Laya is Apache 2.0 with a 421M English checkpoint and a 322M multilingual one; Jev is a closed API priced at $0.042 per million input tokens.
• Laya answers in 32.8 ms p50 on a T4 GPU; Jev's published third-party latency is 236 to 276 ms.
• On the shared 2,000-decision benchmark, fine-tuned Laya scores 0.766 against Jev's 0.727, while Laya's zero-shot score is 0.362.
• Jev still leads on wide option sets: 0.870 on Banking77's 77 labels against Laya's 0.425, with 64k-token context versus 512 to 1024.

What is a System 1 decision engine?

A System 1 decision engine is a small model trained to emit one structured, calibrated answer to a typed question, not a stream of generated tokens. The name borrows Daniel Kahneman's framework: System 1 thinking is the fast, reflexive kind, the gut call, while System 2 is slow and deliberative. The two model releases translate that distinction into a product category: machines that answer fast and stop.

Non-autoregressive architecture makes the distinction mechanical. Instead of sampling one token at a time, the model reads the whole input and writes a typed output in a single pass: a chosen option, an ordinal score, or a calibrated probability. "Because nothing is generated token by token, a schema violation is structurally impossible; the model outputs a choice, a score, or a probability, and that is the entire answer."

That is the pitch on both sides of the licensing line. TypeSafe's launch post explains the RLCD training loop, claims 70 to 500 ms end-to-end latency, and sets the price at $0.042 per million input tokens with free outputs. Laya arrived four days later with the same RLCD recipe, open weights, and a router that auto-detects language and script. The skeptical read is fair: KDnuggets' analysis argues the underlying problems are familiar, and what changed is the architecture, calibration, and developer experience around them.

Inside Laya's architecture: backbone, training, and three primitives

Laya runs on a ModernBERT-large encoder at 421M parameters for English, with a 322M mmBERT-base checkpoint covering 100+ languages behind a router that auto-detects the input script. The context window is 512 tokens for English and 1,024 for multilingual input, expandable to 8,192 with a max_len setting. Training uses the same RLCD objective as Jev, which is where the calibrated probabilities come from: the model is rewarded for saying "70% sure" when it is actually right 70% of the time.

The model exposes three primitives that map onto everyday decision tasks:

• choice: pick one label from a set of options. This is classification and intent detection in one call.
• score: assign a position on an ordinal rubric, like severity from 1 to 5.
• noul: return a boolean with a calibrated probability. This is the yes-or-no gate for high-volume filtering.

Single-question latency is 32.8 ms p50 on a T4. Batch ten questions and the average drops to 7.2 ms per question, 72.3 ms for the full batch. The repository now sits at 24.5k stars with 413 commits and 23 tags in its first week. It ships a Kaggle fine-tuning notebook for 2xT4, Docker builds for ARM64 and DGX Spark, and a browser-agent decision head example for running the model inside a web app.

Laya vs Jev: head-to-head comparison

The two models share benchmarks, and the numbers split by task shape. On narrow, high-signal decisions Laya leads. On long-context and wide-option tasks, Jev keeps the edge.

Metric	Laya	Jev 1.13.0
License	Apache 2.0, self-hosted	Closed API, waitlist access
Parameters	421M English / 322M multilingual	Undisclosed
Latency, one question	32.8 ms p50 on T4	236 to 276 ms published, 70 to 500 ms vendor claim
Context	512 to 1,024 tokens (up to 8,192)	Up to 64,000 tokens
Typed-decisions accuracy	0.766 fine-tuned / 0.362 zero-shot	0.727
Banking77, 77 options	0.425	0.870
Languages	45 of 51 usable	English only
Cost	$0 in tokens (hardware only)	$0.042 per M input tokens, output free

One caveat sits under the headline number: the shared typed-decisions score favors Laya, but Laya was fine-tuned on that benchmark's own training split, an asymmetry AI Model Report flagged in its analysis. Jev's 0.727 is a published out-of-box figure. On the broader JevBench comparison, a Hugging Face blog post benchmarking five System 1 models found Jev at 74.1% on the hard tier against Laya's 34.1%, with an overall intelligence score of 85.7 to 45.8. The hard tier is exactly where context length and option width do the work.

Where Laya wins

The wins line up around cost, speed, and keeping data at home:

• Cost: $0 in token billing. One billion input tokens would cost $42 on Jev's pricing; on Laya the bill is your hardware, amortized.
• Speed: 7.8x faster than Jev's published third-party latency, with batching that takes the per-question cost to 7.2 ms.
• Openness: full weights under Apache 2.0, no vendor lock-in, and air-gapped deployment because no request ever leaves your network.
• Multilingual: 45 of 51 benchmarked languages clear a 3x-random usability bar, and Jev has no multilingual benchmark at all.
• Narrow high-volume decisions: 0.993 on Enron spam and 0.980 on phishing detection, with jailbreak guardrail scores of 0.755 to 0.762 in Flowtivity's independent testing.

If data residency is the constraint, the self-hosted route extends naturally. The same logic runs through the local AI toolchain, down to secret redaction that keeps coding-tool traffic off external servers.

Where Jev still leads

Jev's advantages are the mirror image of Laya's: it is the managed, long-context, out-of-the-box option.

• Context: up to 64,000 tokens per request, against Laya's 512 to 1,024 default window. Whole-document decisions stay out of Laya's reach without chunking.
• Wide option sets: 0.870 on Banking77's 77 intent labels, where Laya sits at 0.425. Narrow choice is Laya's game; broad taxonomy is Jev's.
• Zero-shot quality: Jev's 0.727 on the shared benchmark requires no local fine-tuning. Laya's 0.362 zero-shot means production use demands a training step.
• Operations: no GPU to buy, no temperature refit, and enterprise support behind the API: SLAs, a sandbox, and concierge onboarding.

The production evidence is already moving. TechCrunch reported that Vercel engineers measured Jev at 5 to 18x faster than GPT-5.6 Terra for command safety classification, and Bryo AI's CTO called Gemini 10 to 20x more expensive for email classification at the same job.

Honest limitations of Laya

The open route carries its own to-do list, and the GitHub issues plus independent tests document it.

Zero-shot is the headline problem: 0.362 on the shared typed-decisions benchmark means the model ships as a base, not a finished tool. The model card says as much, calling Laya "a fast base to specialise, not a zero-shot decision engine." Flowtivity's independent benchmark put the gap plainly: the distance from 0.362 zero-shot to 0.766 fine-tuned comes almost entirely from training on one benchmark's own split.

Second, CPU inference is unusable for interactive work. The same 4-vCPU VPS test logged a 49.4 s median warm prediction, against 193 to 464 ms on healthy GPU hardware, so a GPU is effectively a hard requirement. Third, calibration needs a refit: the out-of-box model is overconfident, with an expected calibration error of 0.466 that drops to 0.081 after a temperature refit. Smaller items on the list: the noul primitive can follow option labels instead of the underlying state (GitHub issue #156), and ordinal scoring is the weakest primitive at 0.372 on SST-5.

Real-world use cases

Where the two fit in a stack is a routing decision:

• Email gates: spam and phishing classification at 0.993 and 0.980, the classic high-volume binary that suits Laya's noul primitive.
• Agent guardrails: jailbreak and prompt-injection detection at 0.755 to 0.762, run before a frontier model ever sees the input.
• Model routing: a cheap typed gate that sends easy decisions to the 421M model and hard ones to a larger LLM. This is the cost argument in workflow form.
• Support triage: narrow intent sets like refund, outage, and account access. Keep option width small, and leave 77-label taxonomies to Jev.

Teams running agents on their own infrastructure will recognize the setup. The same self-hosted logic that drives keeping cloud AI coding agents on local execution applies to decision models: the workload runs where the data sits. Even a browser tab is a target, with a community demo running Laya through ONNX Runtime Web at 0.8 to 1.3 s per call on desktop CPUs, matching PyTorch's top answer on 14 of 14 test questions.

Conclusion

The choice reduces to task shape: narrow, high-volume, air-gapped, and multilingual work goes to Laya, while long-context, wide-taxonomy, and zero-ops work stays on Jev. "Laya is the cheaper first gate in a decision stack, and Jev is the safer choice when a wrong call costs more than a GPU hour. Most teams end up running both: Laya on the 90% of volume that is narrow, Jev on the 10% that is not."

Which one would you wire into your stack? Leave your take in the comments, and share this breakdown with whoever is running the next benchmark.

{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Is Laya faster than Jev?","acceptedAnswer":{"@type":"Answer","text":"Yes. Laya answers in 32.8 ms p50 on a T4 GPU, against Jev's published third-party latency of 236 to 276 ms, roughly 7.8x faster. Batched ten questions, Laya drops to 7.2 ms per question."}},{"@type":"Question","name":"Can I run Laya without a GPU?","acceptedAnswer":{"@type":"Answer","text":"You can, but it is slow. On a 4-vCPU VPS, warm prediction took about 49 seconds in independent testing, so interactive use needs a GPU. A browser-based ONNX WebAssembly port runs at 0.8 to 1.3 seconds per call on desktop CPUs."}},{"@type":"Question","name":"Does Laya replace LLMs?","acceptedAnswer":{"@type":"Answer","text":"No. Laya handles typed decisions: classification, ordinal scoring, and calibrated yes-or-no gates. It generates no free text, so teams pair it with larger LLMs, using Laya as the cheap first gate that routes the hard cases up."}},{"@type":"Question","name":"How much does Laya cost?","acceptedAnswer":{"@type":"Answer","text":"The model itself is free under the Apache 2.0 license; you pay only for the hardware running it. For scale comparison, one billion input tokens on Jev's API costs $42."}},{"@type":"Question","name":"Is Jev open source?","acceptedAnswer":{"@type":"Answer","text":"No. Jev is a closed API from TypeSafe AI, accessed through a waitlist, priced at $0.042 per million input tokens with free outputs. It accepts up to 64,000 tokens per request."}}]}

Frequently asked questions

Is Laya faster than Jev?

Yes. Laya answers in 32.8 ms p50 on a T4 GPU, against Jev's published third-party latency of 236 to 276 ms, roughly 7.8x faster. Batched ten questions, Laya drops to 7.2 ms per question.

Can I run Laya without a GPU?

You can, but it is slow. On a 4-vCPU VPS, warm prediction took about 49 seconds in independent testing, so interactive use needs a GPU. A browser-based ONNX WebAssembly port runs at 0.8 to 1.3 seconds per call on desktop CPUs.

Does Laya replace LLMs?

No. Laya handles typed decisions: classification, ordinal scoring, and calibrated yes-or-no gates. It generates no free text, so teams pair it with larger LLMs, using Laya as the cheap first gate that routes the hard cases up.

How much does Laya cost?

The model itself is free under the Apache 2.0 license; you pay only for the hardware running it. For scale comparison, one billion input tokens on Jev's API costs $42.

Is Jev open source?

No. Jev is a closed API from TypeSafe AI, accessed through a waitlist, priced at $0.042 per million input tokens with free outputs. It accepts up to 64,000 tokens per request.

References

1. Laya repository on GitHub (Sep 19, 2026)
2. NandhaKishorM/laya on GitHub (Sep 19, 2026)
3. Introducing System One Models & Jev, TypeSafe AI blog (Sep 15, 2026)
4. A new kind of AI model from a ChatGPT inventor, TechCrunch (Sep 18, 2026)
5. Jev and Laya define a new model class, AI Model Report (Sep 21, 2026)
6. Laya: The Open-Source Jev Alternative, Benchmarked Honestly, Flowtivity AI (Sep 21, 2026)
7. Jev AI vs Djev vs Laya vs OpenJev vs SemIf, Hugging Face blog (Sep 21, 2026)
8. What Everyone Is Getting Wrong About TypeSafe AI's Jev, KDnuggets (Sep 19, 2026)