Large language models have become the default engine for almost every AI task. Need to classify an email? Call an LLM. Need to route a support ticket? Call an LLM. Need to decide whether a message is phishing, urgent, or likely to cause customer churn? Again, call an LLM.
Laya AI challenges that assumption.
Built by ConvAI Innovations, Laya is an open-weight, non-autoregressive AI model designed specifically for decisions rather than text generation. Instead of writing sentences token by token, it takes a piece of state — such as an email, support ticket, document, or JSON object — and answers structured questions with probability scores.
The project belongs to an emerging category often described as System 1 AI: models optimized for fast, reflex-like judgments rather than lengthy reasoning or generation.
And that distinction may be more important than it first appears.
The Problem With Using LLMs for Every Decision
Generative models are extremely flexible, but flexibility comes with overhead.
Suppose a customer sends this message:
“I was charged twice for my subscription. Please refund the duplicate charge.”
An application may only need to know three things:
- Which department should handle it?
- How urgent is it?
- Is the customer likely to cancel?
A conventional LLM workflow might send the entire message to a model with a prompt asking it to return JSON. The model then generates tokens one after another, produces a structured-looking response, and the application parses and validates it.
That works, but it is a surprisingly elaborate way to obtain a few discrete values.
Laya approaches the problem differently.
You provide the state and define questions such as department, urgency, or churn risk. Laya scores the possible answers directly and returns structured values with associated probabilities.
There is no prose generation step and therefore no generated JSON that needs to be parsed back into machine-readable data.
The project's philosophy can be summarized in three words:
Decisions, not text.
A System 1 Model Rather Than a Chatbot
Laya is not intended to compete with ChatGPT, Claude, Gemini, or other general-purpose language models at writing, reasoning, coding, or conversation.
It does not generate text at all.
Instead, it works more like a programmable decision engine.
A typical input consists of two components:
- State — the information the model should evaluate.
- Questions — the decisions the application wants it to make.
Laya supports three primary question types.
Choice
A choice question selects one option from a set.
For example:
- Billing
- Technical Support
- Sales
This is useful for intent classification, routing, labeling, and categorization.
Score
A score question places an input on an ordered scale.
For example:
- 0: Not urgent
- 1: Needs attention
- 2: Blocking issue
This can be used for severity, priority, frustration, risk, or other ordinal measurements.
Noul
Laya also provides a boolean-style decision type that returns a probability for whether a condition is true.
Examples include:
- Is this phishing?
- Is this spam?
- Does this contain a prompt injection?
- Is the user likely to churn?
Instead of returning a sentence such as “This is probably phishing,” the model can return a probability that downstream software can act on.
That makes thresholds straightforward:
if phishing_probability > 0.90: block_message() elif phishing_probability > 0.60: send_for_review() else: allow_message()This is much closer to conventional decision infrastructure than chatbot behavior.
Why Laya Can Be Fast
Most modern generative LLMs are autoregressive. They produce an answer one token at a time, with every new token depending on the ones generated before it.
Laya does not use that process.
Its main English model uses ModernBERT-large, a bidirectional encoder capable of reading an input as a whole. A decision head then scores the requested options directly.
Multiple questions can also be processed together in a single forward pass.
The primary English checkpoint contains roughly 421 million parameters, including its ModernBERT backbone and decision layers. That is tiny compared with today's multi-billion-parameter generative models.
ConvAI Innovations reports latency of roughly 33 milliseconds for a single question on a Tesla T4, with batching providing additional efficiency when many decisions are evaluated together.
Those figures should be understood as project benchmarks rather than universal production guarantees, but they illustrate the architectural advantage: Laya does not need to generate dozens of tokens just to return a category or probability.
Dynamic Schemas Make It More Flexible Than a Traditional Classifier
Laya is not simply a conventional classifier with fixed labels.
Traditional classifiers are often trained around a predefined set of categories. If a model knows only:
- Billing
- Support
- Sales
adding a new category such as Legal may require retraining the classification layer.
Laya instead allows the answer space to be supplied at request time.
Its decision architecture places markers around candidate options and scores those options dynamically. As a result, an application can change its schema without necessarily training an entirely new classifier.
That places Laya somewhere between two familiar approaches.
A traditional classifier is extremely efficient but usually rigid.
A generative LLM is extremely flexible but comparatively expensive.
Laya attempts to combine much of the efficiency of classification with some of the schema flexibility developers expect from LLM-powered systems.
The Laya Model Family
Laya is actually a family of specialized checkpoints rather than a single model.
The main English model uses ModernBERT-large and contains approximately 421 million parameters. It targets workloads such as English-language classification, guardrails, and email triage.
A multilingual checkpoint uses an mmBERT-based architecture with roughly 322 million parameters and is designed to cover more than 100 languages.
There is also a specialized typed-decisions checkpoint optimized for structured decision workloads including customer service, security alerts, invoice processing, and agent observability.
Laya includes a router that examines incoming text and directs it toward the appropriate checkpoint. This matters because language mismatches can create dangerous failures.
For example, the project reports that the English-only model can perform extremely poorly on unsupported scripts while still producing high confidence scores. Confidence thresholds alone therefore cannot reliably detect every out-of-distribution input.
Routing the text before inference provides an additional safeguard.
Calibration Is One of Laya's Most Interesting Ideas
Speed is easy to market, but probability calibration may be the more important part of the project.
An LLM can generate something like:
{ "confidence": 0.95 }But that does not automatically mean the value is statistically meaningful. It may simply be another plausible sequence of generated tokens.
Laya is explicitly designed to produce decision probabilities.
Its training process uses an approach the project calls RLCD — Reinforcement Learning for Calibrated Decisions. The model is rewarded using proper scoring rules intended to encourage probabilities that correspond more closely to real-world frequencies.
Ideally, when a well-calibrated system assigns a probability near 80% to many comparable events, roughly 80% of those events should actually occur.
This matters enormously in production systems.
A company can treat high-confidence decisions automatically, route uncertain cases to humans, or apply different business rules at different probability thresholds.
For workflows involving fraud, safety, customer support, moderation, or security, knowing when a model is uncertain can be as valuable as maximizing raw accuracy.
Laya and Jev
Laya has attracted attention partly because of its relationship to another recent decision-model project: Jev from TypeSafe AI.
Both projects promote a similar idea: many AI workloads do not require autoregressive text generation at all. Structured decisions can instead be handled by models optimized specifically for probability estimation and classification.
The major difference is distribution.
Jev is positioned as a commercial model and API, while Laya releases open weights under the Apache 2.0 license and can be downloaded, self-hosted, inspected, and fine-tuned.
Laya's developers also publish benchmarks comparing the model with Jev, including claims of substantially lower latency and competitive or stronger accuracy on certain workloads.
Those comparisons require caution, however.
Some Jev numbers used in the comparison come from externally published results rather than identical tests performed in the same environment. They should therefore be treated as directional rather than as definitive head-to-head measurements.
The Most Important Limitation
Perhaps the biggest caveat around Laya is hidden behind some of its most impressive benchmark numbers.
The strongest reported typed-decision accuracy comes from the specialized, fine-tuned checkpoint.
The base Laya model performs much worse on that same workload.
That distinction changes how developers should think about the project.
Laya should not necessarily be viewed as a universal zero-shot decision oracle that can be downloaded and immediately outperform powerful commercial models on arbitrary business tasks.
A better description is:
Laya is a fast decision-model foundation that can become highly effective when specialized for a particular domain.
For teams with proprietary training data, fine-tuning infrastructure, and large volumes of repetitive decisions, that can still be extremely compelling.
For developers looking for a plug-and-play model that understands almost any new schema without customization, a general-purpose LLM may remain more convenient.
Where Laya Makes Sense
The most promising Laya workloads are those where an application repeatedly needs small, structured decisions rather than generated language.
Examples include:
- Support ticket routing
- Email classification
- AI agent routing
- Spam and phishing detection
- Prompt-injection detection
- Content moderation
- Fraud and risk scoring
- Customer churn estimation
- Document relevance filtering
- Workflow branching
- Security alert prioritization
- Agent observability
In an AI agent system, for example, Laya could make fast preliminary decisions while a larger model handles the tasks that genuinely require reasoning or generation.
A pipeline might look like this:
User Input → Laya → Routing / Risk / Intent Decisions → LLM or Tool → Final Response
Instead of replacing LLMs, Laya could reduce how often they need to be called.
A Different Vision for the AI Stack
That may ultimately be the most interesting idea behind Laya.
The first generation of modern AI applications often followed a simple architecture:
Everything → LLM
Classification, routing, extraction, moderation, reasoning, and writing were all handled by increasingly capable language models.
Projects like Laya suggest that the next generation may become more heterogeneous.
Fast decision models could handle repetitive judgments. Generative models could handle language and complex reasoning. Retrieval systems could provide knowledge. Tools could execute actions.
In other words:
Decision models decide.
Language models reason and communicate.
Tools execute.
Laya is still an early project, and its strong specialized performance should not be confused with universally strong zero-shot performance. Its comparisons with Jev also deserve careful interpretation.
But the underlying direction is worth watching.
As AI applications move from demos into high-volume production systems, developers will care increasingly about latency, cost, predictable output formats, calibrated uncertainty, and self-hosting — not just how intelligently a model can generate prose.
Laya is an interesting experiment in what happens when AI infrastructure stops asking every model to talk and starts building some models simply to decide.