What is Laya?

A local System One model, not a chatbot

Laya is an Apache-2.0, non-autoregressive decision model from Convai Innovations. You send application state — a ticket, an email, a JSON document — plus questions whose answers are already typed: pick one label (choice), place it on a scale (score), or return a yes/no probability (noul). One forward pass returns structured answers with probabilities. It is not trained to write prose.

The GitHub repo NandhaKishorM/laya was created 18 September 2026, days after TypeSafe launched hosted Jev. By 21 September it had about 7.9k stars and 667 forks. Weights ship as convaiinnovations/laya on Hugging Face. Install from PyPI with pip install laya. There is a public demo Space at convaiinnovations/laya-demo.

• License: Apache 2.0. Run on your GPU or CPU.
• Same three primitives as Jev: choice, score, noul.
• Authors publish a Jev-compatible system_one(state, questions) helper.
• Router can pick English vs multilingual vs typed-decisions per request.

Same job as Jev, different product

Laya is not Jev. Jev is TypeSafe AI’s closed hosted System One API. Laya is an independent open-weight model you download and run yourself. Matching the choice / score / noul interface does not make it a TypeSafe release, a weight drop, or on-prem Jev.

If you need a managed endpoint with no GPU ops, Jev is still the hosted path. If you need weights on disk, air-gapped inference, or to avoid per-token API cost, Laya is the current open-source option in this category. Keep the names honest in docs and sales copy.

Three public checkpoints

The English checkpoint is ModernBERT-large (421M parameters, 512-token context). A multilingual checkpoint uses mmBERT-base (322M, 1024 tokens, 100+ languages). A third checkpoint, laya-typed-decisions (421M, 1024 tokens), is fine-tuned on four workflows: invoice processing, security incidents, customer service, and agent-trace observability.

Training is RLCD: reinforcement learning against strictly proper scoring rules, so the stated way to maximise reward is to report honest probabilities. The English and multilingual base checkpoints score about 0.362 and 0.342 on the authors’ typed-decisions set — near chance, below the 0.461 majority-class baseline. The ~0.766 accuracy figure is the fine-tuned typed-decisions checkpoint, not the base model.

• English: ModernBERT-large, 421M, 512 context.
• Multilingual: mmBERT-base, 322M, 1024 context.
• typed-decisions: 421M, 1024 context, ~0.766 accuracy on the authors’ set.
• Do not ship the base checkpoint as a production classifier without a fine-tune.

Install and run Laya

The package name on PyPI is laya. After install you can load a checkpoint with laya.load("convaiinnovations/laya") or let Router pick a head per request. Inference is one forward pass for every question in the call — authors measure about 33–40 ms for one question on a Tesla T4, with lower per-question cost when batched.

pip install laya

from laya import Router
router = Router(preload=True)

state = {"subject": "Charged twice", "body": "Refund the duplicate today."}
questions = {
  "topic": {
    "type": "choice",
    "instructions": "Which queue?",
    "criteria": {"billing": "invoices, refunds", "bug": "crashes", "other": "else"},
  },
  "escalate": {"type": "noul", "instructions": "Should a human take this?"},
}
result = router.predict(state, questions)

Published numbers — and the caveats

Laya’s README compares Router().predict against third-party published Jev 1.13.0 figures. The authors state they did not have TypeSafe API access, and that sample sizes and prompts differ. Treat the table as directional, not as a bake-off on identical inputs.

On their 2,000-decision typed-decisions set, laya-typed-decisions reports 0.766 accuracy versus published Jev 0.727 (teacher self-agreement ceiling 0.735). They also report better Brier (0.062 vs 0.148) and score MAE (0.242 vs 0.391), and faster p50 latency on a T4 (about 33 ms vs independently measured Jev 236–276 ms). On AG News they report 0.950 vs 0.910; on DAIR Emotion 0.595 vs 0.480.

• Jev still leads high-cardinality choice: published Banking77-style 0.870 (72 labels) vs Laya 0.425 (77 labels at default head budget). Option sets above about 20 labels currently favor hosted Jev.
• Jev’s soft accuracy on typed-decisions is higher (0.580 vs 0.471): better match to a teacher’s full distribution even when Laya’s argmax wins.
• The 0.766 number is the fine-tuned checkpoint. Base English/multilingual heads are near chance until you train on your labels.

Related local heads

Around the same search spike, cklxx/laya-browser showed up as a local Jev-compatible head. It is a community runtime in the same interface family, not a TypeSafe product and not Laya’s training code. If you are assembling an air-gapped stack, read both repos before you pick a process boundary.

When Laya is the right tool

Pick Laya when you need Apache-2.0 weights on disk, air-gapped inference, multilingual routing, or to keep high-volume branches off a hosted API — and you are willing to GPU-host, fine-tune, and refit temperatures on your own labels.

Pick hosted Jev when you want a vendor API, no model ops, and option sets that can get large without retuning token budgets. A hybrid is reasonable: Laya on-prem for the cheap branch; Jev or a larger LLM when Laya’s confidence is low, the option set is huge, or you do not yet have a fine-tune. Do not advertise Laya as Jev.

• Need weights and local inference? Laya.
• Need hosted, billed, no GPU? Jev.
• Need 50+ options in one choice question without tuning? Jev is currently the safer default.
• Need non-English state? Laya’s multilingual checkpoint and Router are built for that.