Laya vs Jev
Laya is an open-weight "System One" decision model from Convai Innovations — a 421M-parameter ModernBERT model, Apache-2.0, that returns a typed choice, score or yes/no and runs on your own hardware. It's the closest open, self-hostable thing to Jev, so people searching "laya" and "laya jev" are usually weighing the two. Here's the honest comparison with hosted Jev: what Laya is, the catch its own model card is candid about, the speed numbers, and when an open local model beats a hosted calibrated one. (Laya is Convai's project, not a TypeSafe AI product.)
Laya and Jev both return a bounded, typed decision instead of prose — pick one of these, a score, a calibrated yes/no — and both are non-autoregressive, so neither decodes text token by token. The split that matters is everything around the model: Laya ships open weights you run and own, and Jev is a hosted, calibrated API you call. That — open-and-local vs hosted-and-calibrated — is the whole decision between them.
What Laya is
Laya is built and released by Convai Innovations under Apache-2.0. The English checkpoint pairs a ModernBERT-large encoder (395M, bidirectional, fully fine-tuned) with a small decision head trained from scratch, totalling ~421M parameters. The family has three checkpoints: an English-only build with a 512-token context, a multilingual build on mmBERT-base (322M, 1024-token context, 100+ languages), and a typed-decisions build fine-tuned on a JevBench-style training split. Weights are on Hugging Face and the training code and SDK are open (GitHub and PyPI). Because it's a single bidirectional encoder pass, the raw forward pass is genuinely quick.
The catch — read the model card
Convai is candid in Laya's own card: zero-shot, it's weak. On zero-shot typed decisions the card reports Laya at 0.362 and the multilingual variant at 0.352 — against a 0.318 random baseline and a 0.461 majority-class baseline. In other words, out of the box a one-line heuristic ("always guess the common answer") beats it. The card's own framing is that Laya is "a fast base to specialise, not a zero-shot decision engine": you're expected to fine-tune it on your task before it's useful. That's the real cost of the open route — you own the data, the training run, and the calibration. Jev is the opposite trade: hosted and RLCD-calibrated so a fresh key decides usefully on the first call, with no fine-tuning and a valid typed value every time.
Specs, side by side
The Laya column uses Convai's published figures; the Jev column uses TypeSafe's. Laya's numbers are vendor-reported and, where noted, zero-shot from its own card — read them as Convai's self-report, not an independent ranking.
| Laya | Jev | |
|---|---|---|
| Origin | Convai Innovations | TypeSafe AI |
| Size | ~421M (ModernBERT-large encoder + decision head) | Purpose-built System One |
| Design | Non-autoregressive bidirectional encoder + decision head | Non-autoregressive parallel sampler |
| Weights | Open · Apache-2.0 (on Hugging Face) | Hosted (not open) |
| How you run it | Locally / self-host | Hosted API, self-serve key |
| Checkpoints | English (512 tok), multilingual 322M (1024 tok, 100+ langs), typed-decisions | jev-latest + pinned versions (e.g. jev-1.14) |
| Output | typed choice / score / yes-no | choice / score / noul + confidence |
| Speed (vendor) | p50 32.8ms on a Tesla T4 (self-reported) | ~70–500ms hosted |
| Zero-shot typed decisions (card) | 0.362 (multilingual 0.352); majority baseline 0.461 | RLCD-calibrated out of the box |
| Calibration | Uncalibrated — fine-tune to specialise | RLCD-calibrated, pinned versions |
The speed claim, read carefully
Convai reports Laya at a p50 of 32.8ms on a Tesla T4, versus roughly 236–276ms cited for hosted Jev — an eye-catching gap, but two caveats. First, it's self-reported on Convai's own hardware, not an independent head-to-head. Second, it's the latency of the raw forward pass, which is a separate axis from the accuracy caveat above: a very fast pass that scores near a majority-class baseline zero-shot isn't a finished decision engine until you fine-tune it. The fast forward pass is real and useful once you've specialised the model; it doesn't by itself make Laya a drop-in replacement for a calibrated hosted call.
The real trade-off
Laya is a genuinely different tool from a hosted decision API: open weights, runs on your own hardware, Apache-2.0, multilingual, and near-free marginal cost per decision once it's deployed — excellent if you have the data and ops to fine-tune and calibrate it for your task, or need everything on-prem. The costs are that you run and maintain the model, you own the calibration (its zero-shot scores aren't something to threshold on blind), and you need a fine-tuning pipeline to get past the majority-class baseline. Jev is the hosted, calibrated side of the same shape: no model to run, an RLCD-calibrated yes/no you can threshold on, a valid typed value every call, and a free browser playground to try one decision before you write any code.
When to pick which
- Reach for Laya when you want open weights you can self-host and fine-tune, need the model fully on your own hardware or air-gapped, have labelled data and an ops pipeline to specialise and calibrate it, or want a tiny multilingual encoder you can run at near-zero marginal cost.
- Reach for Jev when you want a hosted, RLCD-calibrated decision that works on the first call with no fine-tuning, honest confidence you can threshold on, pinned versions so behaviour is stable, a valid typed value every time, and no model to operate — plus a free playground to try one call.
- They can compose: specialise Laya locally for your high-volume, well-labelled decisions, and escalate the low-confidence or long-tail cases to hosted Jev — both take a state plus a bounded answer space, so the handoff is a transport change, not a rewrite.
Make one real decision on Jev
The fastest way to judge any decision model is to run your own decision through it. Jev's playground does it in the browser with no signup, and a jv_live_ key points your code at the hosted endpoint:
// Hosted, calibrated decision — criteria in, a typed answer with confidence out.
const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
},
body: JSON.stringify({
state: { ticket: ticket.body },
questions: {
triage: { type: "choice", instructions: "First-pass triage.",
criteria: { resolve: "answerable now", escalate: "needs a human", spam: "not a real request" } },
urgent: { type: "noul", instructions: "Is it urgent?" },
},
}),
});
const { answers } = await res.json();
if (answers.triage.choice === "escalate") handoff(ticket, answers.urgent.noul);- Hugging Face — convaiinnovations/laya — Convai's open weights and model card: ModernBERT-large encoder, Apache-2.0, checkpoints, and the zero-shot calibration caveats (vendor-reported).
- AI Weekly — Convai ships Laya, a 421M ModernBERT decision model, Apache-2.0 — Secondary coverage of the release, size, checkpoints and the self-reported latency figures.
FAQ
What is Laya?
Laya is an open-weight "System One" decision model from Convai Innovations, released under Apache-2.0. The English checkpoint is a ~421M-parameter ModernBERT-large encoder plus a decision head, and it returns typed decisions — a choice, a score, a yes/no — rather than prose. There are also a 322M multilingual checkpoint (100+ languages) and a typed-decisions fine-tune. Weights are on Hugging Face and you run it on your own hardware. It's Convai's project, not a TypeSafe AI product.
Is Laya the same kind of model as Jev?
They're the same shape — both non-autoregressive decision models that return a bounded, typed value instead of text. The difference is everything around the model: Laya is open-weight and self-hosted, while Jev is a hosted, RLCD-calibrated API. Laya needs fine-tuning and your own calibration to be useful; Jev decides usefully on the first call.
Is Laya better than Jev?
It depends on what you can bring. Laya's own model card reports weak zero-shot numbers (0.362 on typed decisions, below the 0.461 majority-class baseline) and frames the model as 'a fast base to specialise, not a zero-shot decision engine' — so out of the box it needs fine-tuning. Its forward pass is very fast (Convai reports 32.8ms on a T4, self-reported). If you have labelled data and ops to specialise it, Laya is compelling and free to run; if you want a calibrated decision with no fine-tuning and no model to operate, Jev earns its keep.
Can I run Laya locally?
Yes — that's its main appeal. The weights are open under Apache-2.0 on Hugging Face, with open training code and an SDK, and the encoder is small enough to run on modest hardware (there are MLX and ONNX builds in the community). See our 'Run Laya locally' guide for install steps and the calibration caveats.
Can I use Laya and Jev together?
Yes. A common pattern is to fine-tune Laya locally for a high-volume, well-labelled decision and escalate the low-confidence or long-tail cases to hosted, calibrated Jev. Both take a state plus a bounded answer space, so the escalation path is a transport change, not a rewrite.
See also: Jev alternatives · Run Laya locally · CLM-8B vs Jev · JevBench · What is a decision model · Playground
Open local model, or hosted calibrated decision
Laya gives you open weights to fine-tune and self-host; Jev gives you a hosted, calibrated decision against your criteria in one call — no fine-tuning, no model to run. Try Jev free in the browser, then grab a jv_live_ key.