⏱️ Lectura: 11 min
ConvAI Innovations launched Laya, a decision engine that responds in 32.8 milliseconds per query on a single GPU, and in 7.2 milliseconds per question when traffic arrives in batches. The company, led by Nandakishor Mukkunnoth, released the complete model under the Apache 2.0 license weeks after TypeSafe AI introduced Jev, a closed commercial product with a non-autoregressive architecture nearly identical to the one Mukkunnoth had already described in a March 2025 paper.
📑 En este artículo
TL;DR
- ConvAI Innovations released Laya, an AI decision engine that responds in 32.8 milliseconds per query on a single GPU.
- Processed in batches, Laya resolves a question in 7.2 milliseconds, 6 to 8 times faster than TypeSafe AI’s Jev.
- TypeSafe AI, founded by Diogo Almeida (co-creator of ChatGPT), launched Jev in September 2026 without papers or open weights.
- Nandakishor Mukkunnoth, founder of ConvAI, had already published this idea in March 2025 in the paper arXiv:2503.23303.
- Jev charges $0.042 per million input tokens and responds in about 150 milliseconds, according to the original announcement.
- Laya’s three checkpoints (laya, laya-multilingual, and laya-typed-decisions) are unified in a single Hugging Face repository.
- Laya supports over 100 languages and is released under the Apache 2.0 license, with no API subscription cost.
- The laya-typed-decisions checkpoint reaches 0.766 accuracy in agent observability and invoice processing.
Introduction
Every current AI pipeline carries the same problem: using a giant generative model to make a binary decision. When a support ticket, a suspicious email, or a user prompt arrives, the real question is almost always simple. Which department should handle it? Is it phishing or spam? How urgent is it on a scale of 0 to 3? Calling on a model with 8, 70, or hundreds of billions of parameters to answer that means waiting between 500 and 2,000 milliseconds, paying for every generated token, and then writing a regex or JSON parser to extract a clean label from free text.
Laya attacks that problem from a different angle. Instead of generating text, it directly produces a calibrated probability over a schema you define in advance. The company describes it as a System 1 type decision system, the fast, instinctive reaction, as opposed to the slow System 2 reasoning that large generative models actually need.
What happened
On September 19, 2026, ConvAI Innovations published the full Laya announcement on its site laya.convaiinnovations.com, along with the weights, code, and technical documentation. The launch carries a particular tone. Mukkunnoth writes that he spent months working on this, published a paper on arXiv, released the weights on Hugging Face, and built a PyPI package back in March 2025, and that he now sees an almost identical idea presented as a breakthrough by a lab with large-scale funding.
That lab is TypeSafe AI, founded by Diogo Almeida, who worked as a co-creator of ChatGPT at OpenAI. In September 2026, TypeSafe launched a product called Jev that offers the same core idea, non-autoregressive probability predictions over structured schemas, but as a closed service: no technical papers, no open weights, and no public datasets, at $0.042 per million input tokens and with response times close to 150 milliseconds.
ConvAI’s response was to release a complete, open family. Laya runs in 32.8 milliseconds on a single GPU, according to the benchmark the company published alongside the launch, 6 to 8 times faster than Jev, with support for over 100 languages, no API subscription cost, and Apache 2.0 weights downloadable as of today.
Context and history
This idea’s first version didn’t start in 2026. In March 2025, Mukkunnoth published the paper arXiv:2503.23303, in which he trained a non-autoregressive model with PPO (Proximal Policy Optimization) over sequence representations to predict turn-by-turn conversion trajectories in SaaS sales conversations, with outputs between 0.0 and 1.0. Along with the paper, he released the sales-conversion-model-reinf-learning model on Hugging Face, the open saas-sales-conversations dataset, a PyPI package, and a public discussion on r/LocalLLaMA.
In September 2025, a second paper arrived, arXiv:2510.01237, which formalized the general framework for schema-based decisions guided by reinforcement learning. In both papers, the core of the system was always reinforcement learning, not an embeddings model or an autoregressive LLM disguised as a classifier.
A year later, Jev arrived. According to Mukkunnoth, TypeSafe generalized the same non-autoregressive parallel sampling concept, called it RLCD (Reinforcement Learning for Calibrated Decisions), and packaged it as a commercial service. Laya adopts that same acronym to describe its own training, which suggests both teams converged on a similar name for an idea with a public lineage dating back to 2025.
Technical details and decision engine performance
Laya evaluates typed questions about any state (free text, an email, a ticket, a JSON document) in a single forward pass, without generating a single text token. The entire output space is reduced to three primitives:
- choice: picks an option from a dictionary of criteria and returns the selected key, the probability distribution over all options, and a calibrated confidence score.
- score: places the state on an ordinal rubric (levels 0, 1, 2…) and returns the expected level along with the distribution over those ranges.
- noul: answers a direct boolean question with the calibrated probability P(true), where P(false) = 1 – P(true) by construction.
The full flow, from input to calibrated probability, is straightforward:
flowchart TD
A["Input text (ticket, email, prompt)"] --> B["Laya (bidirectional encoder)"]
B --> C{"Primitive"}
C --> D["choice: select option"]
C --> E["score: rubric level"]
C --> F["noul: probability P(true)"]
D --> G["Calibrated output, no free text"]
E --> G
F --> GSince the output space is purely numeric, Laya cannot hallucinate a text string or return malformed JSON, structurally there is no way for that to happen. That’s different from asking a generative LLM to return "confidence: 0.95", a number that in that case is just the most likely next token, with no mathematical calibration guarantee behind it.
The family is split into three specialized checkpoints, now unified in a single Hugging Face repository:
| Checkpoint | Backbone | Parameters | Context | Main strength |
|---|---|---|---|---|
| convaiinnovations/laya | ModernBERT-large | 421M | 512 tokens | English text classification, guardrails, email triage |
| convaiinnovations/laya-multilingual | mmBERT-base (256k vocab) | 322M | 1024 (up to 8k) | 100+ languages, cross-lingual NLI, 2.2x faster |
| convaiinnovations/laya-typed-decisions | ModernBERT-large | 421M | 1024 tokens | Agent observability, customer support, invoices (0.766 accuracy) |
The paper accompanying the launch includes a benchmark dashboard with accuracy across shared datasets, nine different application flows, a sweep across 51 languages, latency measured on a T4, plus a calibration repair test. Previously, each checkpoint lived in a separate repository and added up to 2.5 GB combined if someone wanted all three; now, a single repository groups them with separately downloadable subfolders.
Getting started
All three checkpoints can be downloaded from the same Hugging Face repository using huggingface_hub. The installation process is identical on Windows, macOS, and Linux since it runs on Python; the only thing that changes is how you activate the virtual environment.
# Linux / macOS
python3 -m venv .venv
source .venv/bin/activate
pip install transformers torch huggingface_hub
# Windows (PowerShell)
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install transformers torch huggingface_hubOnce the environment is ready, you can download just the checkpoint you need instead of pulling the combined 2.5 GB. Using allow_patterns from huggingface_hub, you can point directly to the multilingual subfolder:
from huggingface_hub import snapshot_download
local_path = snapshot_download(
repo_id="convaiinnovations/laya",
allow_patterns=["laya-multilingual/*"],
local_dir="./laya-multilingual"
)
print("Checkpoint downloaded to:", local_path)To confirm you only downloaded what you asked for, and not all three complete checkpoints, check the folder size before loading the model into memory:
# Linux / macOS
du -sh ./laya-multilingual
# Windows (PowerShell)
Get-ChildItem -Recurse .\laya-multilingual | Measure-Object -Property Length -SumIf the size is in the hundreds of megabytes rather than gigabytes, the subfolder filter worked. From there, loading the model and running a choice primitive is just a matter of instantiating the tokenizer and encoder with the standard transformers API, and mapping the output to your schema’s keys.
💡 Tip: if your use case is routing support tickets in Spanish, start with laya-multilingual: it’s the only one of the three checkpoints with explicit cross-lingual NLI evaluation and extended context up to 8k tokens.
Impact and analysis
The Laya case exposes a tension that keeps recurring in AI research. A small team publishes a decision engine idea with an open paper, weights, and dataset; years or months later, a better-funded lab presents a closed variant of the same idea with better packaging, without citing the prior work. Mukkunnoth documents the timeline with verifiable dates and links, which turns this into a case with public evidence, not just a subjective complaint.
For anyone building agents or production pipelines, the practical point matters more than the priority dispute. Laya doesn’t replace a generative LLM: it removes from the pipeline the trivial decisions (routing, classifying, scoring) that many teams today still solve with a model that has hundreds of billions of parameters. That lowers critical-path latency and eliminates the per-token cost of every micro-decision.
The cost difference between Laya and Jev is also concrete. Jev charges $0.042 per million input tokens with responses around 150 milliseconds; Laya runs locally, with no calls to an external API, under the Apache 2.0 license and no usage limit beyond available hardware.
That said, Laya has real limits. The laya-typed-decisions checkpoint reports 0.766 accuracy in agent observability and invoice processing, a number far from perfect for high-stakes decisions. And since it’s a discriminative model, you need to define the full schema in advance (the choice options, the score levels) before running it: it doesn’t work for open-ended tasks where even you don’t yet know what the possible categories are.
⚠️ Careful: with 0.766 accuracy on the typed-decisions checkpoint, it’s best to keep human review in place for high-stakes decisions, rather than delegating directly to Laya without any further oversight.
What’s next
ConvAI says that with Laya it fixed the architectural limitations of its first 2025 model: it went from a vertical output specialized in sales conversion to a horizontal family that covers any decision schema, with real multilingual support via mmBERT-base. The unified Hugging Face repository and the Apache 2.0 license open the door for third parties to replicate or audit the figures the company published alongside the launch, something that isn’t currently possible with Jev since it has no papers or public weights.
What remains to be seen is whether TypeSafe AI responds with its own technical documentation, or whether the System 1-style decision market ends up split between a closed, paid offering and an open alternative with a public academic lineage dating back to 2025. For teams currently handling triage, moderation, or routing with a generative LLM, the comparison between the two is already on the table: 32.8 milliseconds and your own weights versus 150 milliseconds and a closed API.
Try it yourself: run pip install huggingface_hub and download the laya-multilingual checkpoint with the snippet above to see the real latency on your own hardware today.
📖 Summary on Telegram: View summary
Frequently Asked Questions
What is a System 1-style decision engine?
It’s a model that answers simple, structured questions (picking an option, scoring on a scale, answering yes or no) in a single forward pass, without generating free text, inspired by Kahneman’s distinction between fast thinking (System 1) and slow, deliberate thinking (System 2).
How does Laya differ from a generative LLM?
A generative LLM produces text token by token and requires you to parse the response to extract a label. Laya directly returns a calibrated probability or a key from a closed dictionary of options, in 32.8 milliseconds per query according to ConvAI’s benchmark, with no possibility of returning a malformed output.
Does Laya work in Spanish?
Yes, through the convaiinnovations/laya-multilingual checkpoint, built on mmBERT-base with a 256,000-token vocabulary and declared support for over 100 languages.
Does Laya use the same RLCD as Jev?
ConvAI describes Laya as an engine trained with reinforcement learning and calibrated distribution, the same RLCD acronym that TypeSafe AI later adopted for Jev. The difference, according to Mukkunnoth, isn’t in the name but in the fact that Laya’s path can be audited: public papers since March 2025, downloadable weights, and an open dataset.
How much does it cost to use Laya versus Jev?
Laya runs locally under the Apache 2.0 license at no API cost. Jev, on the other hand, charges $0.042 per million input tokens with response times close to 150 milliseconds, according to TypeSafe AI’s launch announcement as cited by ConvAI.
Where can you download Laya’s weights?
All three checkpoints are unified in a single Hugging Face repository under the convaiinnovations account, with separately downloadable subfolders using allow_patterns from huggingface_hub.
References
- laya.convaiinnovations.com: official Laya announcement, with the full benchmark dashboard.
- arXiv:2503.23303: original March 2025 paper on conversion trajectories with non-autoregressive RL.
- arXiv:2510.01237: second paper, from September 2025, formalizing the RL-guided schema decision framework.
- huggingface.co/convaiinnovations: repository with all three Laya checkpoints.
- r/LocalLLaMA: community where ConvAI first discussed the approach in 2025.
📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
0 Comments