Laya vs Jev: Pick the Right Typed Decision Model

If you need a model to classify an email into "billing" or "technical," score a support ticket's urgency, or flag a chargeback risk — you don't need an LLM generating prose. You need a typed decision.

Two options now compete for that job. TypeSafe's Jev was the first System One model and remains the most established. Laya, released in September 2026 by Convai Innovations, is a fully open-source alternative that runs 7-8x faster on the same hardware — but makes different trade-offs that matter in production.

This post breaks down where each one wins so you can stop guessing and start choosing.

TL;DR: Laya is faster, cheaper, and multilingual out of the box. Jev still leads on high-cardinality choices (50+ options) and soft-distribution accuracy. Match the tool to your decision type, not the hype.

What Is Laya?

Laya is a non-autoregressive System 1 decision engine — it evaluates typed questions (choice, score, noul) over structured state in a single forward pass. No text generation, nothing to parse, nothing to hallucinate.

The project ships three checkpoints under Apache 2.0:

• laya (421M params, ModernBERT-large) — English, 39.5 ms for one question

• laya-multilingual (322M params, mmBERT-base) — 100+ languages, 32.8 ms for one question

• laya-typed-decisions (421M params, ModernBERT-large) — fine-tuned for the typed-decisions benchmark, 0.766 accuracy

A built-in Router detects the language and script in sub-milliseconds, then dispatches to the right checkpoint — all in one call.

# Initialize Laya router with all checkpoints preloaded
from laya import Router
router = Router(preload=True)  # sub-35ms routing, all models in memory
result = router.predict(state, questions)

Laya reached 6,700+ stars on GitHub within three days of release — a strong signal of developer interest in a fast, self-hosted decision layer.

How Laya Compares to Jev on Speed

Speed is Laya's headline advantage. On identical questions measured on a T4 GPU:

Laya answers one question roughly 7-8x faster than Jev, based on independently published Jev benchmarks (AbdelStark/jev-benchmarks, nibzard/decision-model-benchmark).

Pro tip: The speed gap matters most in high-throughput pipelines — triaging thousands of support tickets per hour, routing API requests in real-time, or running moderation on every incoming message. For occasional one-off decisions, the difference is unnoticeable.

Accuracy: Where Laya Wins, Where Jev Wins

Benchmarks are only useful when you know which side of the comparison you're on. On a shared test set (17,416 questions, one T4 GPU):

Laya's strongest case: Typed decisions and intent classification tasks where you have moderate option counts (under ~25). It also achieves significantly better calibration — 0.081 ECE vs Jev's 0.246 — meaning their confidence scores are more trustworthy when you act on them.

Where Jev holds the lead: On Banking77 (77 options), Jev scores 0.870 while Laya collapses to 0.425 at default settings. The reason is architectural: Laya's head_max_len token budget allocates only ~3-4 tokens per option for 77 labels. You can raise head_max_len to 512 and recover accuracy, but Jev supports up to 255 options out of the box with no tuning.

Analogy: Think of it like two delivery services. Laya is the faster motorcycle that can carry packages across town in half the time — unless the package is too large, in which case the truck (Jev) handles it better without modifications.

One striking failure: on DAIR Emotion, Jev assigned zero probability to the correct label on 16% of examples — a hard failure for anything branching on confidence. Laya made this mistake far less often.

Multilingual: Laya's Biggest Differentiator

If your decisions span multiple languages, the comparison tilts decisively toward Laya.

Jev has no published multilingual benchmark. Laya routes between checkpoints based on script detection (under 0.5 ms in pure Python):

• English state → laya checkpoint (ModernBERT-large)

• Non-Latin scripts (Devanagari, Khmer, Arabic, etc.) → laya-multilingual (mmBERT-base)

Results across 51 languages (MASSIVE intent benchmark, random baseline = 0.050):

Laya-multilingual covers 45 of 51 languages at meaningful accuracy. The English checkpoint alone misses 22 of them entirely — including a near-zero score on Khmer (0.000 at 95.2% confidence). The Router catches this before the forward pass so you never get a confidently wrong answer from a mismatched checkpoint.

Cost and Deployment

The cost story is Laya's strongest non-speed argument:

Self-hosting Laya eliminates per-request API costs entirely. At 1 million decisions per month, that's roughly $42 saved over Jev's API pricing — with latency as a side benefit.

The trade-off is operational: you manage the model, GPU infrastructure, and monitoring. Jev handles that for you as a managed service.

Important caveat: Laya's base checkpoints are near chance zero-shot on typed-decisions (0.362 and 0.342 vs a 0.318 random baseline). The 0.766 accuracy comes from fine-tuning on the benchmark's own training split. Plan for a fine-tuning step before production — the included Kaggle notebook runs on free 2xT4 GPUs in about 4-5 hours for 4 epochs over ~30k questions.

When to Pick Each

Choose Laya when:

• You need sub-50ms latency per decision (chatbots, real-time routing, moderation)

• Your decisions span 2-50 options across multiple languages

• You want self-hosted, zero-cost inference with no per-token billing

• You need calibrated confidence scores for automated gating

• You can invest a few hours in fine-tuning on your domain data

Choose Jev when:

• You have high-cardinality choice questions (50-255 options) with default settings

• You need the best soft-distribution accuracy (matching teacher probability distributions)

• You don't want to manage GPU infrastructure or run fine-tuning

• Your workload is low-volume enough that 236-276ms latency is acceptable

The Bottom Line

Laya and Jev aren't the same product serving the same audience. Jev is the polished, managed decision API. Laya is the fast, cheap, self-hosted base model that rewards fine-tuning. For most builders exploring typed decisions in 2026, Laya is the more practical starting point — faster, free, and increasingly well-documented. But keep Jev in your back pocket when the problem gets bigger than 50 options or when you need soft accuracy over argmax correctness.

Both models prove the same thing: the future of AI infrastructure isn't bigger text generation — it's faster, typed decisions your code can actually use.