Laya Multilingual

Laya Multilingual

Reads text such as emails and tickets in 100+ languages and answers typed questions with probabilities in one pass. A 322M model, with no text generation, for teams routing multilingual messages.

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 Multilingual is a decision model for text. You hand it a message, such as an email, a ticket or a JSON record, together with typed questions. One forward pass later, it gives back typed answers that each carry a probability. It does not write text, so there is nothing to parse. It has 322M parameters and covers 100+ languages.

Who it suits: Developers and support teams who sort messages in many languages and want fixed answers, not free text. The card points text in any other language to this checkpoint. The English checkpoint is a separate model in the same family.

Title: Who uses it, and how
Industry | Who uses it | How they use it | Example
Customer support | Support teams | Route tickets to the right team | Send a refund complaint in Hindi to billing
Operations | Back-office teams | Tag incoming mail by topic or urgency | Mark which emails ask for money back
Software | Developers | Add a small classifier to an app | Call the model once per message and read the label
Localization | Global companies | Handle many languages with one model | Sort mixed Spanish and Japanese tickets together

Skip it if you need the model to write replies or summaries, because it only returns labels and probabilities.

Where to use it:

• Python, with the laya package
• Servers that sort a stream of messages
• Windows, macOS or Linux for downloading the files, with Python

Use case | Who | What they get back
Ticket routing | Support teams | A chosen team name and its probability
Yes or no checks | Operations | A typed answer, such as whether the sender wants a refund
Long documents | Developers | Answers for text up to 8,192 tokens when you raise the limit

How to set it up: You need Python and pip. Install the laya package, which loads the model by its Hugging Face name. You can also download the files by hand.

• Python and pip
• The laya package
• About 644 MB of disk space for the F16 weights, per Hugging Face

1. Install the laya package.
2. Load the multilingual checkpoint by name.
3. Pass your text and typed questions to predict.

pip install laya
pip install -U huggingface_hub
hf download convaiinnovations/laya-multilingual

If loading hangs, the card says transformers may probe for TensorFlow and deadlock, and running with USE_TF=0 avoids it.

How to use it: Pass the text and a set of typed questions to predict. A choice question lists the options and what each means. For long documents, set max_len to 8192, because the default limit of 1,024 tokens cuts them off.

import laya
agent = laya.load("convaiinnovations/laya-multilingual")
result = agent.predict(long_document, questions, max_len=8192)

The card also describes a Router helper. It looks at the script the input is written in, before the model runs, and picks the English or multilingual checkpoint. You can preload both at startup so the first request is quick.

from laya import Router
router = Router()
router.preload(["english", "multilingual"])

Tool | What it does
laya.load | Loads a checkpoint by its Hugging Face name
predict | Takes text and typed questions, returns answers with probabilities
max_len | Raises the input limit from 1,024 to 8,192 tokens
Router | Sends each message to the English or multilingual checkpoint

Example: You pass a billing complaint in Hindi, plus a choice question with billing, technical and sales as options. The model returns billing with a probability, in one pass. You read the label and route the ticket.

For newcomers and experts: If you are new, start with one choice question on a handful of messages and read the probabilities. Check them against answers you know before you automate anything.

For people in the field, the encoder is mmBERT-base, with a 1,024-token context that extends to 8,192. The card says short inputs give identical answers with the larger limit. Its long-document test shows 16 to 18 of 20 correct up to about 4,000 tokens and 8 to 17 of 20 beyond that.

Text arrives
Router checks the script
Laya reads text and questions
One pass returns typed answers
Your code uses the label

Good to know:

Title: Macro accuracy across 51 languages
Random guess: 0.05 accuracy
English checkpoint: 0.227 accuracy
Multilingual checkpoint: 0.366 accuracy

• License: Apache 2.0
• Cost to run: none named, you use your own computer
• Data it reaches: it downloads files from Hugging Face, and the card names nothing else it touches
• Not for: writing text, or English-only work, where the English checkpoint is the one the card suggests
• Test long-document accuracy on your own data, because the card reports uneven results past roughly 4,000 tokens

On Hugging Face, 13 November 2026

• Task: text classification
• Library: transformers
• Parameters: 322M
• Weights: about 644 MB in F16; about 161 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 9,698
• Likes: 422
• License: apache-2.0
• Languages: en, de, fr, es, pt, it, nl, sv
• Quantized versions: 48
• Fine-tunes: 94
• Tags: transformers, safetensors, laya, multilingual, mmbert, system-one, calibrated-decisions, rlcd, classification, routing, guardrails, moderation

Links

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

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download convaiinnovations/laya-multilingual

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