Laya, Convai Innovations' non-autoregressive decision model, skips text generation entirely
Most language models write. Laya, released by Convai Innovations, does not — it decides. Given a question, it returns a typed answer with a probability attached, in one forward pass, without producing a single token of prose.
Most language models write. Laya, released by Convai Innovations, does not — it decides. Given a question, it returns a typed answer with a probability attached, in one forward pass, without producing a single token of prose.
A model built to answer, not to write
Laya is described by Convai as a multilingual, non-autoregressive System 1 decision model. That label matters: System 1 thinking, in the classic sense, is fast and reflexive rather than deliberative, and Laya is built around that same idea. It takes an input, runs it through the network once, and outputs a typed answer paired with a probability. There is no decoding loop, no next-token sampling, no generated paragraph to parse afterward. If your pipeline currently sends a question to a large generative model and then writes a regex or a second model to extract a label and a confidence score from the resulting text, Laya is aimed at replacing that whole detour with a single pass that returns the structured answer directly. The interesting design choice is not that it is small — plenty of models are small — but that it is trained specifically to not generate, which is what makes the rest of its architecture worth understanding.
Three checkpoints, three different jobs
The repository ships three separate checkpoints rather than one model tuned to do everything. The English checkpoint runs on ModernBERT-large, carries 421 million parameters, handles up to 512 tokens of context, and scored 0.783 on the English intent-classification split of the MASSIVE benchmark. The multilingual checkpoint runs on mmBERT-base instead, is smaller at 322 million parameters, but stretches to 1024 tokens of context with an encoder capable of handling up to 8192 tokens, and covers more than 100 languages. Its benchmark numbers are notably lower than English's: 0.451 on MASSIVE intent across 13 other languages, and 0.731 on XNLI across 14 other languages. That gap is worth sitting with rather than glossing over — a multilingual model that trails its English sibling by roughly 33 points on intent classification is not a drop-in replacement for English-only use cases, and anyone routing non-English traffic to it should budget for that accuracy difference rather than assume parity. The third checkpoint, tuned specifically for typed decisions, reports 0.766 accuracy on its own benchmark, a separate task from intent classification or entailment.
Choosing a checkpoint faster than you can read this sentence
Because there are three checkpoints instead of one, something has to decide which one handles a given input, and that is the Router's job. Convai describes it as script detection running in pure Python in under 0.5 milliseconds — fast enough that the dispatch step adds essentially nothing to end-to-end latency. What the Router returns is a checkpoint selection based on detected script; the facts published don't extend to a guarantee about task-appropriate routing beyond that, so mixed-script or edge-case inputs are still worth testing directly rather than assuming the router handles them correctly. On raw inference speed, the published T4 GPU numbers are close between checkpoints: 32.8 milliseconds per question on the multilingual model, 39.5 milliseconds on the English one. Both land comfortably inside single-digit-to-low-double-digit request budgets, which is the range that makes typed-decision inference usable as a synchronous step inside a larger request rather than a background job.
Where the probability numbers actually come from
Laya is trained with reinforcement learning using strictly proper scoring rules — a detail that explains why the model outputs a probability alongside its typed answer rather than just a label. Strictly proper scoring rules are a specific class of loss function used in forecasting and probabilistic classification because they reward a model for reporting an honest estimate rather than gaming the metric; that training mechanism is what produces the probability output, not a separate calibration layer bolted on afterward. Whether those probabilities end up well-calibrated on your particular data is a separate, empirical question that the published facts don't answer — something to check against your own held-out set before wiring the probability into a downstream threshold or routing decision.
Getting it running
Everything here is released under Apache 2.0, and the GitHub repository at github.com/NandhaKishorM/laya is the source for both the checkpoints and the benchmark numbers cited above. The project supports self-hosted deployment: you pull the checkpoint that matches your language and task — English, multilingual, or typed-decisions — clone the repository, load the weights locally or on your own infrastructure, and run inference through whatever serving stack you already use for transformer encoders. Deciding whether a fast, typed, non-generative decision layer belongs inside your own pipeline, and how its accuracy and latency numbers translate to your actual traffic, is exactly the kind of applied integration question worth working through with someone who has run these tradeoffs before — which is the space NextLUCA's agent-building and consulting work occupies.
Specs
- Vendor: Convai Innovations
- English checkpoint params: 421M (ModernBERT-large)
- Multilingual checkpoint params: 322M (mmBERT-base)
- English context length: 512 tokens
- Multilingual context length: 1024 tokens (up to 8192 via encoder capacity)
- License: Apache 2.0
- Deployment: Self-hosted
Sources
- Laya repository — GitHub / Convai Innovations