Laya

Laya

Answers typed questions about a message, email, ticket or JSON record with calibrated probabilities in one pass of about 33 ms, in 100+ languages. For developers who route tickets and classify text.

Made by convaiinnovations on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Laya is a decision model that never writes text. You give it a piece of content, such as an email, ticket or JSON record, and typed questions. It returns an answer and a probability for each question in a single forward pass of about 33 ms, across more than 100 languages. It has 421M parameters.

Who it suits: It suits developers who need quick, checkable answers about incoming text, such as which team should handle it and how urgent it is.

Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route tickets and spot churn risk | A billing complaint sent to the billing team
Software | Backend developers | Classify messages and records inside a service | An API that tags each incoming email
Operations | IT teams | Rank requests by urgency | Mark an outage report as blocking
Global teams | Localization staff | Handle messages in many languages with one model | Triage Hindi and Spanish messages in one queue

If you need the model to write replies or summaries, you can skip it, because it only picks among the answers you define.

Where to use it:

• Python, through the laya package and its Router
• An HTTP server, through the laya serve extra
• An MCP server, through the laya mcp extra
• LangChain and LangGraph, through the laya langchain extra
• ONNX Runtime and a TileLang GPU fast path, through two more extras

Use case | Who | What they get back
Ticket routing | Support teams | A department choice with its probability
Urgency scoring | Operations | A placement on a scale such as not urgent, soon or blocking
Churn checks | Account teams | A probability that the customer threatens to leave

How to set it up: You need these first:

• Python 3.10 or newer
• Internet access on first use, because the Router downloads a checkpoint then
• About 843 MB of disk for the F16 weights, or about 211 MB for a 4-bit estimate

1. Install the laya package with pip.
2. Add an extra if you want a server, MCP, LangChain, ONNX or the fast GPU path.
3. Create a Router, which fetches a checkpoint the first time you use it.

pip install laya

How to use it: Write the text to judge and a set of typed questions, then call predict on the Router. Each question is a choice, a score or a yes or no question. The Router detects the language and sends non-English text to the multilingual checkpoint.

from laya import Router
router = Router()  # downloads a checkpoint on first use; Router(preload=True) loads all three up front
state = "Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan."
questions = {
    "department": {"type": "choice", "instructions": "Which department should handle this?",
                   "criteria": {"billing": "invoices, payments, refunds",
                                "technical": "bugs, outages, system errors",
                                "other": "everything else"}},
    "urgency": {"type": "score", "instructions": "How urgent is this?",
                "criteria": ["not urgent", "soon", "blocking"]},
    "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel or leave?"},
}
result = router.predict(state, questions)
print(result["answers"]["department"]["choice"])  # billing
print(result["answers"]["churn_risk"]["noul"])    # probability the answer is yes
print(result["routing"]["model"])                 # english

For long documents, name the multilingual checkpoint and raise the limit.

result = router.predict(long_document, questions, model="multilingual", max_len=8192)

Tool | What it does
choice | Picks one option from the criteria you list
score | Places the answer on an ordered scale
noul | Gives the probability that a yes or no answer is yes
Router | Detects the language and picks the English or multilingual checkpoint

Example: You pass an email saying the customer was billed twice and may cancel, with the three questions above. The result names billing as the department and gives a probability that the customer is a churn risk. Nothing is generated or parsed.

For newcomers and experts: Think of Laya as a fast sorting clerk. It reads text and answers fixed questions with numbers. A good first step is to run the quickstart above with your own short message.

It is non-autoregressive, so one forward pass gives all answers. Reinforcement learning against strictly proper scoring rules trained it, which makes honest probabilities the only way to earn reward.

You pass text and typed questions
The Router picks a checkpoint by language
One forward pass scores every option
You get answers with probabilities

Good to know: The default input limit of laya-multilingual is smaller than its maximum.

Title: Token limit of laya-multilingual
Default limit: 1,024 tokens
With max_len=8192: 8,192 tokens

• Long inputs: up to about 4,000 tokens, 16 to 18 of 20 requests were right, and beyond that 8 to 17 of 20, so test on your own data
• Speed: an input of 4,000 tokens needs roughly 1.7 s on an Apple GPU, while short inputs run as before
• Other versions: 91 quantized and 218 fine-tuned versions made by other people are listed
• License: Apache 2.0
• Cost to run: none named
• Data it reaches: the text you pass in, and a checkpoint it downloads on first use

On Hugging Face, 13 November 2026

• Task: text classification
• Library: transformers
• Parameters: 421M
• Weights: about 843 MB in F16; about 211 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 18,689
• Likes: 5,956
• License: apache-2.0
• Quantized versions: 92
• Fine-tunes: 221
• Tags: transformers, safetensors, laya, system-one, calibrated-decisions, rlcd, classification, routing, scoring, guardrails, moderation, reinforcement-learning

Links

• Model: https://huggingface.co/convaiinnovations/laya
• Files: https://huggingface.co/convaiinnovations/laya/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download convaiinnovations/laya

Then follow the usage in its model card. Nothing in this kit runs by itself.