← Use cases

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.

your decide call state + questions Jev — available now OpenAI Luna — preview local / open — Laya
One decide call, two providers: an open local model like Laya and a hosted model like Jev both turn a state plus a bounded answer space into a typed decision — the difference is where the model runs and who owns the calibration.

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.

LayaJev
OriginConvai InnovationsTypeSafe AI
Size~421M (ModernBERT-large encoder + decision head)Purpose-built System One
DesignNon-autoregressive bidirectional encoder + decision headNon-autoregressive parallel sampler
WeightsOpen · Apache-2.0 (on Hugging Face)Hosted (not open)
How you run itLocally / self-hostHosted API, self-serve key
CheckpointsEnglish (512 tok), multilingual 322M (1024 tok, 100+ langs), typed-decisionsjev-latest + pinned versions (e.g. jev-1.14)
Outputtyped choice / score / yes-nochoice / 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.461RLCD-calibrated out of the box
CalibrationUncalibrated — fine-tune to specialiseRLCD-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

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);

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.

▶ Try Jev freeGet an API key →
Laya vs Jev — Convai's open decision model, honestly compared (2026) · Jev by TypeSafe AI