What is Laya?

Who makes it

Convai Innovations publishes the weights on Hugging Face as convaiinnovations/laya ↗ and is the author of the laya package on PyPI ↗. The source lives at NandhaKishorM/laya ↗, the personal account of Nandakishor M, Convai's CEO according to that GitHub profile. There is no separate corporate repository.

“System 1” is Laya's own label, borrowed from the category TypeSafe named for Jev (see System One models). Sharing the vocabulary, and the Choice/Score/Noul format, tells you about the interface. It says nothing about shared internals.

What Router decides for you

The project recommends Router as the entry point. It picks a checkpoint per request, before the model runs, because the English checkpoint gives no warning when it can't read the input. On Khmer it scored 0.000 at 0.952 confidence, per the project's 51-language sweep.

Laya needs Python 3.10 or newer and installs PyTorch and Transformers as dependencies. It uses an NVIDIA GPU if present, then Apple-silicon GPU (MPS), then CPU.

python3 -m venv .venv
.venv/bin/python -m pip install laya    # Python 3.10+; pulls in torch and transformers

from laya import Router

router = Router()  # downloads and loads a checkpoint on first use

state = {"body": "We were billed twice for March. Refund the duplicate or we cancel."}
questions = {
    "team": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {"billing": "charges, invoices, refunds",
                     "technical": "bugs and outages",
                     "sales": "pricing and new contracts"},
    },
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this?",
        "criteria": ["not urgent", "soon", "blocking or deadline"],
    },
    "refund": {"type": "noul", "instructions": "The sender asks for money back."},
}

result = router.predict(state, questions)
a = result["answers"]
print(result["routing"]["model"])                     # english
print(a["team"]["choice"], a["team"]["confidence"])  # billing 0.9483
print(a["urgency"]["score"], a["refund"]["noul"])    # 1.7042 0.9115

We ran this exact script on a Mac against 0.3.7. The printed values are from that run and will differ slightly by hardware. Loading the English checkpoint prints a warning that one shipped temperature (for choices with 11+ options) was out of range and clamped, so confidence on those questions is uncalibrated. If laya.load() hangs, the project says to set USE_TF=0. The question format matches Jev's; see primitives for how Choice, Score, and Noul behave.

Self-host it behind Jev's API

The serve extra adds laya-serve, a FastAPI server for POST /v1/systemone that runs the Router. It is configured only by environment variables.

pip install "laya[serve]"
LAYA_HOST=127.0.0.1 LAYA_MODELS=english LAYA_API_KEY=change-me laya-serve
# POST http://127.0.0.1:8000/v1/systemone

That is SDK-level compatibility in the sense defined on open source. It is a wire contract, not equal behavior. Answers and probabilities come from Laya, so re-measure accuracy and thresholds when you switch.

Can I run Laya natively on my Mac? Yes, two ways. The official package runs on Apple silicon through PyTorch's MPS backend with no extra setup. For native MLX, there is an independent port.

laya-mlx reports 13.4 ms (English) and 7.4 ms (multilingual) median for one short question on an M3 Max with 40 GPU cores, excluding model load. Those are the project's own measurements on that machine. It says it matched upstream's selected answer on 63 of 63 validation questions per checkpoint. The same developer publishes a Core ML port, laya-coreml, which we haven't checked.

How Laya works

These details come from the model cards and the package source. Laya is a bidirectional encoder with a small decision head. It never generates tokens.

What this does and doesn't tell you about Jev. TypeSafe hasn't published Jev's architecture, parameter count, or training data. Laya isn't a reconstruction of Jev. It is one design that implements the same interface. Output that always parses isn't the same as a correct answer: Laya can be confidently wrong, as the English checkpoint is on non-English text.

Base checkpoints vs. the fine-tuned one

Laya's training method is called RLCD, the same name TypeSafe uses for Jev's (see RLCD). Laya's version is described in its model card: the model outputs a distribution, noise is added for exploration, and the reward is a proper scoring rule, with a policy-gradient update. Whether TypeSafe does the same thing isn't public.

What's published for your own training: a Kaggle notebook that fine-tunes on two free T4 GPUs (the project says 4–5 hours for about 30,000 questions), fits temperatures, and pushes to Hugging Face. The 0.3.7 notes say it now fits calibration on a held-out slice, though the README's fine-tuning section still says those samples come from training items. The data and script that produced the base checkpoints are not published; an open issue asking for them was answered with the fine-tuning notebook.

Calibration: fit it yourself

Laya's pages say “mathematically calibrated.” The project's own measurements are narrower than that, and they vary by checkpoint and task.

So the direction of the error depends on your task. Fit temperatures on held-out examples from your own workload, then pick thresholds on validation data. The README's 0.85 gating example is an illustration, not a recommended cutoff.

“Documented” means the project states it in its README or model cards. Issue numbers refer to the Laya repository ↗, checked September 23, 2026. We haven't measured these ourselves except where noted.

Laya vs. Jev

The stable differences first. These don't depend on a benchmark.

Independent head-to-heads

We found two public comparisons that ran both models on the same items. Neither is ours.

Dhruv Mehra (September 22) used the English checkpoint on an Apple-silicon Mac and Jev 1.13 through OpenRouter, with identical questions. AG News is in Laya's training mix, according to the project's benchmark script, so that lead is partly in-distribution. Anthus (September 21) used Jev 1.13.0 from TypeSafe and the English checkpoint through laya-mlx 0.1.0; its Brier scores were nearly equal (0.189 vs. 0.188). Latency isn't comparable in either study, because Laya ran locally and Jev over the network. Four results on four tasks don't pick a winner. They do agree with the project on one point: Laya falls well behind on many-label choices.

How to read Laya's own Jev table

Laya's README and model card lead with a “Laya vs TypeSafe Jev” table. The project states that it has no TypeSafe API access and never ran Jev. Every Jev figure is copied from someone else's study. Here is where each row comes from.

The project does disclose most of this in its notes, and its README lists where Jev leads. The headline table and chart don't carry those caveats, and several articles repeat them without the notes. Treat the table as a list of pointers to other studies, not as one controlled run. For Jev's own evidence, see benchmarks.

Laya, hosted Jev, or neither

Other open models and servers that copy Jev's interface, and what TypeSafe itself has open-sourced, are on Is Jev open source?