TypeSafe AI launched Jev in September 2026: a non-autoregressive decision primitive that returns typed answers with confidence scores instead of generated text. The catch is that it is a closed API with no public weights. Convai Innovations, led by Nandakishor Mukkunnoth, answered with Laya — the same System 1 decision idea, fully open-source under Apache 2.0.
I dug into the model card, the repo, and the benchmark report so you don’t have to: exact specs, vendor-claimed benchmarks vs Jev, a working quickstart, and the honest limits the authors themselves admit.
1. Spec Sheet: Three Checkpoints, One Hub
Laya is not one model but a family of three encoder-based checkpoints, bundled in a single Hugging Face hub (convaiinnovations/laya) so you download only the subfolder you need. Nothing is generated: you pass a state (text, email, ticket, JSON) plus typed questions (choice, score, noul), and every question is answered in a single forward pass.
laya (English)
ModernBERT-large · 421M params · 512 context
The base checkpoint. English text classification, guardrails, email triage. 395M of the params are the ModernBERT-large backbone, plus a decision head trained from scratch (2 transformer layers, option scorer, act/escalate head).
laya-multilingual
mmBERT-base · 322M params · 1024 context (up to 8k)
100+ languages with a 256k-token vocabulary. About 2x faster than the English checkpoint and the only one that survives non-Latin scripts. Weaker on English, so pick deliberately — or let the Router decide.
laya-typed-decisions
ModernBERT-large · 421M params · 1024 context
Fine-tuned specialist for four agent workflows (observability, customer service, invoices, security alerts). This is the checkpoint behind the 0.766 headline number — and behind most of the caveats in section 4.
Facts I verified (Sep 2026)
- • License: Apache 2.0 — weights, code, and data lineage are public.
- • Install: pip install laya (PyPI v0.3.5, requires Python ≥ 3.10).
- • Repo: github.com/NandhaKishorM/laya — ~14.9k stars and ~1.2k forks at the time of writing, growing fast (it was ~2.5k on Sep 20).
- • Live demo: huggingface.co/spaces/convaiinnovations/laya-demo.
- • Training signal: RLCD — reinforcement learning against strictly proper scoring rules, so honest probabilities are the only way to maximize reward.
2. Laya vs Jev: Benchmarks (Vendor Claims)
The table below pits the routed Laya system against Jev 1.13.0. Read the warning first: every Laya number was measured by Convai on their own harness, while every Jev number is third-party published (independent studies and TypeSafe’s own figures) — never measured side by side by the vendor. Treat this as a vendor claim with an unusually transparent methodology, not as an independent audit.
⚠️ How to read this table
Laya figures: measured by Convai on a T4, reproducible via notebooks/laya_benchmark_colab.ipynb. Jev figures: published by third parties (AbdelStark, nibzard) and TypeSafe AI — sample sizes and prompts differ. The 0.766 belongs to the checkpoint fine-tuned on that benchmark’s own training split, not to zero-shot Laya.
| Benchmark | Jev 1.13.0 (published) | Laya routed (measured) |
|---|---|---|
| typed-decisions (2,000 decisions) | 0.727 | 0.766 (+0.039) |
| AG News (4 labels) | 0.910 | 0.950 (+0.040) |
| DAIR Emotion (6 labels) | 0.480 | 0.595 (+0.115) |
| ECE calibration (lower is better) | 0.246 | 0.081 (after temperature fit) |
| Latency p50, 1 question (T4 GPU) | 236–276 ms | 32.8 ms (~7–8x faster) |
| Banking77 (77 options) | 0.870 | 0.425 — Jev leads |
| Cost / weights | $0.042 per 1M tokens, closed API | $0 self-hosted, Apache 2.0 |
Two details deserve credit: on DAIR Emotion, Jev assigned zero probability to the true label on 16% of examples — a hard failure for anything branching on confidence. And Laya’s 0.766 clears the 0.735 teacher self-agreement ceiling with 2.4x better Brier score, winning all four workflows (invoices 0.804, security 0.766, support 0.764, observability 0.730).
3. Quickstart: Router Mode in 5 Minutes
The Router is the recommended entry point: it detects script and language in under a millisecond and dispatches to the right checkpoint in one forward pass. Code below is taken from the official README — install, preload, define typed questions, predict, and gate on confidence.
Install
pip install laya>=0.3.3
Route mode (recommended)
import laya
from laya import Router
# Preload checkpoints: avoids 7-10 s reloads on language switches
router = Router(preload=True)
state = {
"from": "user@acme.com",
"subject": "Duplicate charge on invoice #4411",
"body": "We were billed twice for March. Refund the duplicate or we cancel.",
}
questions = {
"department": {
"type": "choice",
"instructions": "Which department should handle this request?",
"criteria": {
"billing": "invoices, payments, refunds",
"technical": "bugs, outages, system errors",
"sales": "pricing, new contracts",
"other": "everything else",
},
},
"urgency": {
"type": "score",
"instructions": "How urgent is this request?",
"criteria": ["not urgent", "soon", "critical deadline or blocking issue"],
},
"churn_risk": {
"type": "noul",
"instructions": "Does the user threaten to cancel or leave?",
},
}
res = router.predict(state, questions)
print(res["answers"]["department"]["choice"]) # billing (confidence: 0.94)
print(res["routing"]["model"]) # englishBranch on calibrated confidence
dept = res["answers"]["department"]["choice"]
conf = res["answers"]["department"]["confidence"]
if conf >= 0.85:
route_automatically(dept) # no human in the loop
else:
escalate_to_human(dept) # fail closedSingle-checkpoint mode (dedicated pipelines)
import laya
agent = laya.load("convaiinnovations/laya") # English root (~808 MB)
agent_ml = laya.load("convaiinnovations/laya", subfolder="multilingual")
agent_td = laya.load("convaiinnovations/laya", subfolder="typed-decisions")
result = agent.predict(state, questions) # one forward pass, ~33-40 ms on GPUProduction tip: always preload
With the default Router() (lazy, max_loaded=1), traffic that alternates languages rebuilds a checkpoint per request — measured at 7.4 s median reload on CPU. In a server, use Router(preload=True) or router.preload([“english”, “multilingual”]) so language flips cost under 1 ms of detection only.
4. Honest Limits (Straight From the Model Card)
This is the section that made me trust the project: the authors document exactly where Laya breaks. The headline 0.766 is real, but it belongs to a fine-tune — the base you download behaves very differently out of the box.
⚠️ Zero-shot base is near chance
Base checkpoints score 0.362 and 0.342 on typed-decisions against a 0.318 random baseline and a 0.461 majority-class baseline. The card says it plainly: “Laya is a fast base to specialise, not a zero-shot decision engine.” Budget for labeling a few thousand examples and fine-tuning (there is a free Kaggle 2xT4 notebook, ~4–5 hours).
⚠️ Banking77: 77 options crush it (0.425 vs Jev 0.870)
Options share a fixed head budget (192 tokens EN, 256 multilingual), so 77 labels get ~3–4 tokens each and become indistinguishable. Fixes: raise agent.cfg[“head_max_len”], shortlist with embeddings first (laya.predict_shortlist), or split coarse → fine questions. Jev handles 50+ options out of the box.
⚠️ Temperature calibration is mandatory, not optional
Raw checkpoints ship over-confident (mean ECE 0.466). Refitting one temperature per question type on held-out data moves ECE to 0.081 — and the multilingual checkpoint ships with no fitted temperatures at all. Fit them before branching production traffic on confidence.
⚠️ English checkpoint collapses outside English
Macro average 0.227 across 51 languages; Khmer scores 0.000 accuracy at 95.2% confidence. Confidence gating cannot save you because the model stays confident while wrong — routing must happen before the forward pass. That is literally why the Router exists.
⚠️ Ordinal scores are the weakest primitive
SST-5 ordinal accuracy is 0.372, and on typed-decisions Jev wins soft accuracy (0.580 vs 0.471): Laya’s argmax is better but its full distributions match the teacher less well. Use choice/noul where you can.
Golden rule
If you cannot label a few thousand examples of your own decision, the zero-shot figure (~0.35) is the one that predicts your results — not the 0.766. Laya replaces a 70B LLM router brilliantly after fine-tuning; it does not replace it on day zero.
5. Verdict: Who Should Adopt Laya This Week
Laya is the rare open-source release that is both genuinely useful and unusually honest about its boundaries. For high-volume classification, guardrails, routing, and triage — where a 70B autoregressive LLM is an expensive overkill — a sub-35 ms bidirectional decision model with auditable weights is exactly the right tool, provided you fine-tune it.
My take: prototype the Router against your own tickets this week, measure zero-shot vs a 500-example fine-tune, and only then decide. The weights are free, the harness is reproducible, and the failure modes are documented — that is more than you get from any closed decision API.
Adopt it for
High volume + labeled data
Support triage, email routing, moderation guardrails, invoice processing, agent observability — anywhere you have thousands of examples, need single-digit-ms batch latency, and must run air-gapped or on-premise under Apache 2.0.
Skip it for
Zero-shot or huge label spaces
Drop-in zero-shot decisions with no fine-tuning budget, single prompts with 50+ options (Jev leads there), or ordinal scoring as your core primitive. Also skip lazy Router() in production — preload or pay 7–10 s per language switch.
Verdict
A fast, open, well-documented base to specialise — not a zero-shot decision engine. If you fine-tune and calibrate, Laya is the best open answer to Jev available in September 2026. If you won’t, Jev’s API (or a small LLM) will serve you better.
Conclusion
The System 1 decision layer is splitting into two paths: closed, metered APIs like Jev, and open, self-hosted weights like Laya. After reading the full benchmark report — including the parts where Laya loses — I consider Laya the most credible open option in the space right now.
Clone the repo, run the Router on your own data, and let your own fine-tune numbers decide. And if you calibrate temperatures before trusting the confidence scores, you’ll already be ahead of most teams shipping LLM routers today.
