Jev vs Laya

Same job: typed System One decisions

Both models sit in the software branch, not in the chat window. You send application state — an email, a ticket, 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). Neither is trained to write prose.

That is why Laya showed up in the same search spike as Jev. TypeSafe launched Jev as a hosted System One API in mid-September 2026. Within days, Convai Innovations published Laya as an Apache-2.0 local alternative with a Jev-shaped interface. The GitHub repo NandhaKishorM/laya was created 18 September 2026 and crossed several thousand stars by 21 September.

Jev: TypeSafe’s hosted model

Jev is TypeSafe AI’s first System One model, currently published as jev-1.13.0 (aliases jev-latest and jev-preview). You call POST https://api.typesafe.ai/v1/systemone with a TypeSafe key, or go through Vercel AI Gateway as typesafe-ai/jev. Input is billed at $0.042 per million tokens; output is free.

You do not download Jev. There is no self-hosted binary and no Hugging Face weight drop. That is the product: a managed endpoint, version pins, and no GPU operations on your side. Independent notes on this site cover the API, pricing, and use cases; this page is not affiliated with TypeSafe.

• Closed weights, hosted API.
• choice / score / noul over HTTP.
• No local GPU required.
• Supports large option sets (TypeSafe documents up to 255 options).

Laya: open-weight local model

Laya is a non-autoregressive encoder plus a decision head. The English checkpoint is ModernBERT-large (421M, 512-token budget). A multilingual checkpoint uses mmBERT-base (322M, 1024 tokens, 100+ languages). A third checkpoint, laya-typed-decisions, is fine-tuned on four workflows: invoice processing, security incidents, customer service, and agent-trace observability. A fuller Laya intro, including install and related local heads, is on /what-is-laya.

Training is RLCD: reinforcement learning against strictly proper scoring rules, so the stated way to maximise reward is to report honest probabilities. Inference is one forward pass for every question in the call — authors measure about 33–40 ms for one question on a Tesla T4, and lower per-question cost when batched. Install with pip install laya. Weights: huggingface.co/convaiinnovations/laya. Code: github.com/NandhaKishorM/laya.

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

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 Banking77-style high-cardinality choice: published 0.870 (72 labels) vs Laya 0.425 (77 labels at default head budget).
• 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 English and multilingual base checkpoints score 0.362 and 0.342 on that same set — below the 0.461 majority-class baseline. The 0.766 number is the fine-tuned checkpoint.

When to use which

Pick Jev when you want a vendor API, no model ops, and option sets that can get large without retuning token budgets. Pick Laya when you need weights on disk, air-gapped inference, multilingual routing, or to avoid per-token API cost — and you are willing to GPU-host, fine-tune, and refit temperatures on your own labels.

A hybrid is reasonable: Laya on-prem for the cheap, high-volume 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, and do not promise Jev on-prem.

• Need hosted, billed, no GPU? Jev.
• Need Apache-2.0 weights and local inference? Laya.
• 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; Jev has no published language matrix.