Laya: a decision model that speaks a hundred languages

TLDR

Laya is an open decision model in the Jev mold: you hand it a question with a fixed set of answers, it hands back one answer and how sure it is. No prose in between. It differs from every other entry in the category on two axes. It answers in about 33 milliseconds on a Tesla T4, roughly seven times faster than Jev’s measured latency. And it handles 45 of 51 tested languages, where Jev has published no multilingual benchmark at all. Weights are Apache 2.0, three checkpoints, one pip install. Laya’s model page tracks the specs alongside every other model on this site. The catch you will hit first: 512 to 1024 tokens of context, against Jev’s 32k to 64k. Laya reads a ticket, not a codebase. And its author published the underlying RL research eighteen months before Jev launched.

*The same churn question through three machines: a chat LLM pays for prose at every stage, Jev pays for one pass, Laya pays for half of one.*

What Laya is

Say you run a support inbox and you want every ticket sorted the same way you’d sort it: billing, technical, or sales; how angry the customer is; whether they’re about to cancel. With a chat model you send the ticket plus your instructions, it writes a few sentences, and your code digs the answer out of the text. It works. It also costs you a full paragraph of thinking every single time, takes seconds, and sometimes the essay hedges instead of answering.

Laya is a model trained to skip the essay. You hand it the ticket and your three questions. It hands back: “billing, 0.94. Angry: somewhat. About to cancel: 12 percent.” Nothing else. No paragraph, no hedging, no parsing step in your code. You get the answer and the model’s confidence, and you decide what to do with both.

Two properties fall out of how it’s built, and both are practical:

New questions cost nothing. Yesterday you sorted tickets. Today you also want lead scoring. You write the new question and its possible answers, and Laya handles it - the model wasn’t retrained, because the scoring mechanism works on whatever options you hand it at the moment you ask. (Under the hood it’s a 421-million-parameter ModernBERT encoder that scores each answer choice directly; the architecture detail only matters because it means no retraining when your questions change.)

It can’t talk, so it can’t make things up. There is no essay to fact-check. The model either knows enough to answer or it doesn’t, and the confidence number tells you which is which - route anything under 80 percent to a human instead of guessing.

The training method is RLCD - reinforcement learning where the reward only goes up when the model reports probabilities that match reality. Fudge the confidence and the reward drops. TypeSafe describes the same training approach for Jev: different team, no shared code, same conclusion.

Three checkpoints, one router

The pip package ships three checkpoints and routes between them automatically (model page):

checkpoint	encoder	params	context	use
laya	ModernBERT-large	421M	512	English
laya-multilingual	mmBERT-base	322M	1024	100+ languages
laya-typed-decisions	ModernBERT-large	421M	1024	typed workflows

A Router object picks the checkpoint per request and can preload all three for server use. On mixed workloads the authors measure up to 4.8x throughput gains at 50 percent non-English traffic.

The benchmark claims, with the caveat

Every Laya figure below is the authors’ own measurement. Jev’s figures are third-party published numbers; the Laya team had no TypeSafe API access. Different prompts, different samples. Treat this table as a directional claim, not a verdict.

	Jev 1.13.0 (published)	Laya routed (self-measured)
typed decisions, 2,000 cases	0.727	0.766
AG News, 4 labels	0.910	0.950
DAIR Emotion, 6 labels	0.480	0.595
calibration error (ECE)	0.246	0.081
p50 latency, one question	236 to 276ms	33ms
languages tested	none published	45 of 51 usable
weights	closed API	Apache 2.0
cost	$0.042 / 1M input	free self-hosted

Two details stand out beyond the headline. On DAIR Emotion, Jev assigned zero probability to the true label on 16 percent of examples - that is a calibration failure, not an accuracy miss. And Laya’s fine-tuned checkpoint clears its own teacher ceiling (0.766 against 0.735), which suggests the RLCD recipe has headroom.

The trade: context

Laya reads 512 to 1024 tokens per question. Jev reads tens of thousands. That difference defines each one’s job.

Laya classifies states: an email, a ticket, a log line, a JSON payload. Jev reads documents - a codebase policy question, a long contract clause, an agent’s full working context. If your input fits in a few paragraphs, Laya is faster, free, and multilingual. If your input is a book? Laya cannot see it at all.

For the agent patterns now forming - branch pruning, reversibility scoring, confidence-based human queues - the inputs are usually short. That is why this trade matters less than it looks on paper.

What you can build with it today

Laya classifies states: anything that fits in a few paragraphs, answered with a label and a level of certainty in 33ms. Concrete jobs it handles out of the box:

job	what you ask it	why it fits Laya
Support triage	department (choice), urgency (score), churn risk (yes/no)	a ticket is a short state; runs on every incoming message
Email routing	team (choice), action needed (choice), sentiment (score)	the multilingual checkpoint reads Hindi, Arabic, Spanish natively
Refund desk	approve / reject / review (choice), fraud signal (score)	order history summarized into the state, decision in one pass
Feed or inbox filtering	genuine / promo / rage bait / troll (choice)	33ms per item means filtering at scroll speed
Log-line triage	severity (score), rollback now (yes/no)	cheap enough to run on every error line, not just alerts
Lead scoring	qualification (yes/no), priority (score)	multilingual: score leads in their own language

The multilingual angle is the differentiator most teams will feel first. The typed-decisions checkpoint answers in 45 of 51 tested languages, while Jev has no published multilingual benchmark and OpenJev is English-first. If your users write tickets in Norwegian, your support flow does not need an English translation layer anymore.

The prior art question

On September 19 Laya hit the Hacker News front page, and the discussion went somewhere the model card does not: who thought of this first.

Laya’s author, Nandakishor M, published SalesRLAgent in March 2025: reinforcement learning against strictly proper scoring rules for conversion-probability prediction. That is the same training family Laya uses, eighteen months before TypeSafe launched Jev. The comment thread split on what follows. Some read Laya as the open implementation of research that predates Jev. Others point out, correctly, that SalesRLAgent was a specialized sales-conversion predictor, not a general typed-decision model, so the lineage is idea-level, not code-level. A Hacker News Community Note on an earlier thread reached the same middle ground.

Zoom out and the roots go deeper still. GLiNER’s paper landed in November 2023, and GLiNER2 does schema-driven extraction today. An independent developer shipped OpenDecision with 8k context days after Jev.

*Four days, four models: closed API, browser reproduction, multilingual encoder, single-job specialist. Each one verified: weights or published evals on the table.*

The honest summary is not “X copied Y” - it is that the idea of small RL-trained models that report how sure they are was converging from several directions at once, and TypeSafe’s packaging (“System One”, a typed interface, the right token-price moment) is what turned a research thread into a category. That is a real contribution. It is just not where the idea originated.

Does it run on CPU?

At 421M parameters with a q4_k_m quantization at 250MB, yes, comfortably. A T4 delivers the headline 33ms; on a modern laptop CPU expect roughly 100 to 300ms per question - slower than GPU but still an order of magnitude under a chat LLM round-trip, and it runs without any GPU at all. For the state-classification jobs described above, CPU-only deployment is a legitimate choice, not a compromise.

What it means

Four days after Jev launched, you can already pick how you want the same answers delivered: rent them (TypeSafe), run them in a browser tab (OpenJev), or host them yourself in a hundred languages (Laya). Different teams, same deal. When three ways to get one thing exist within a week, that is a layer forming, not a hype cycle.

Here is the part that matters if you have a spare GPU: Laya runs on a T4 or anything with a few gigabytes of VRAM. 843MB per checkpoint, pip install laya, and the decision layer is something you host yourself, in a hundred languages, for free.

Sources: Laya model card (benchmarks, architecture, training), BENCHMARKS.md, SalesRLAgent, March 2025, the Hacker News discussion, AbdelStark’s Jev benchmarks, nibzard’s decision-model benchmarks, the TypeSafe Jev launch coverage in our Jev guide.