What Is Laya AI?
Laya is an open-weight, non-autoregressive decision model built by Convai Innovations. Like TypeSafe AI's Jev, it belongs to a new category of "System One" models: instead of generating text, it takes a piece of state (a support ticket, an email, a JSON payload) plus a set of typed questions, and returns typed answers with calibrated confidence scores — typically in around 33 milliseconds. Unlike Jev, Laya's weights are fully public on Hugging Face under an Apache 2.0 license, and it runs entirely on infrastructure you control.
Who Built Laya, and Why?
Laya's architecture traces back to foundational research on non-autoregressive decision models published by its creator in March 2025 — well before TypeSafe AI launched Jev in September 2026. When TypeSafe's launch didn't include open weights or published code, Convai Innovations released Laya as a fully open-source response built on the same underlying idea: fast, structured, typed decisions instead of generated text.
How Does Laya Work?
Laya uses a bidirectional encoder — a ModernBERT-large checkpoint at 421 million parameters for English, and an mmBERT-based multilingual checkpoint covering 100+ languages — trained with the same category of technique TypeSafe uses, Reinforcement Learning for Calibrated Decisions (RLCD). It reads the entire input at once rather than generating token by token, and answers a predefined question by scoring the available options, not by writing an answer out. Because there's no text output, there's nothing to hallucinate and no JSON to parse — the schema is enforced by construction.
Like Jev, Laya exposes three primitives: Choice (pick one option from a dictionary), Score (place input on an ordinal rubric), and Noul (a calibrated yes/no probability).
How Fast Is Laya, Really?
On a single Tesla T4 GPU, Laya's multilingual checkpoint answers a single question in about 32.8ms; the English checkpoint runs closer to 39.5ms. Batch ten questions together and that drops to roughly 7.2ms per question. Independent comparisons put Laya somewhere between 6x and 20x faster than a round trip to Jev's hosted API, which makes sense — Laya runs locally with no network hop, while Jev is a remote API call.
What Does It Cost to Run?
Nothing, in API terms — Laya has zero subscription or per-call fees. The real cost is GPU infrastructure: you're self-hosting, so you pay for compute instead of tokens. For teams already running GPU infrastructure, or those with strict data-residency requirements that rule out sending data to a third-party API, that trade genuinely favors Laya. For everyone else, it's a build-vs-buy decision like any other self-hosted model.
Where Laya Falls Short
Laya isn't a strictly-better free Jev — it has real limitations worth knowing before you commit to it. Its accuracy drops sharply on Choice questions with a large number of options: on the 77-category Banking77 benchmark, Laya scored around 0.425 accuracy versus a much stronger 0.870 for Jev. There's a sharper failure mode too — Laya's multilingual checkpoint can report high confidence on a language or script it genuinely cannot read, in one documented case scoring 0.080 accuracy on Bengali text while reporting 0.945 confidence. If your deployment spans many languages or a large number of choice categories, both of those are worth testing against your own data before you rely on it in production.
Getting Laya Running
Installation is a single pip command:
pip install layaThe simplest way to use it is the Router, which auto-detects the input's language and dispatches to the right checkpoint:
from laya import Router
router = Router(preload=True)
result = router.predict(state, questions)
print(result["answers"])For a fixed, single-language deployment, you can skip the router overhead and load a specific checkpoint directly with laya.load("convaiinnovations/laya"). Convai also publishes a free Kaggle notebook for fine-tuning Laya on your own labeled data in around four hours on a free GPU — useful if your out-of-the-box accuracy on a narrow domain isn't where you need it.
Vantaverse's Take
Open weights change the calculus for anyone building agent-native software with strict data-residency or air-gapped deployment requirements — a self-hosted decision layer that never sends data off-premise is a real architectural option a hosted API can't offer, whatever its latency numbers look like. The trade-off is operational: you now own the GPU infrastructure, the checkpoint selection, and the fine-tuning, instead of a vendor owning it for you. We'd default to Laya for privacy-constrained or cost-sensitive high-volume deployments, and to Jev for teams that want a working decision layer today without standing up any infrastructure. For the full side-by-side, see our Jev vs Laya comparison.