Laya

A non-autoregressive "System 1" decision model by Convai Innovations (nandha-kishor-m), read from the Hugging Face model card and cross-checked against the GitHub repo and PyPI listing. Curator-sent, "ingest this," 2026-09-24. It takes free text plus a set of typed questions and returns typed answers with calibrated probabilities in one forward pass — no generated text, no parsing, no hallucinated output by construction.

What it is

Three routable checkpoints, all fully fine-tuned bidirectional transformers with a decision head trained from scratch on top:

The decision head is two transformer layers plus an option-marker scorer and an act/escalate head. Each candidate option gets its own [MASK] token; the head scores each token and softmaxes over the question's options. The answer space (which options exist) is declared at request time, not baked in by fine-tuning, so one model serves many question sets. Three question types: choice (pick one of N), score (ordinal), noul (binary yes/no with a calibrated P(true)) — all answered in a single pass, however many questions are asked at once.

Training: RLCD

Laya is trained with what the card calls RLCD — Reinforcement Learning for Calibrated Decisions: the policy reports a probability distribution, exploration comes from zero-mean Gaussian noise added to the logits, and the reward is a strictly proper scoring rule (log loss, spherical score, or ranked probability score for ordinal questions). Under a proper scoring rule, expected reward is maximised only by reporting the model's true belief — miscalibration costs reward directly. Updates use REINFORCE with a group-mean baseline (GRPO-flavoured); multi-turn conversations use TD(λ=1.0).

Same acronym, same shape, unrelated vendor. system-one-models-and-jev (llm-providers-wiki) already holds TypeSafe AI's Jev — also pitched as a "System 1" decision function, also trained with something its own launch post calls RLCD, also scoring choice/score/noul questions ("Noul" spelled the same unusual way on both cards) in one forward pass. Laya's card compares itself to Jev directly and by name; nothing on either card credits the other. Whether this is convergent naming around an idea that predates both products (proper scoring rules are decades old) or one team building an explicit clone of the other, neither card says, and this page does not resolve it.

A second reproduction, and it does say. open-jev-9b (Zefan Cai, ingested the same day) is a separate, unrelated attempt at the same target, and its README states outright what Laya's card leaves open: "an independent implementation inspired by TypeSafe's Jev. It does not reproduce proprietary RLCD, private weights or training data." Three projects now share the choice/score/noul vocabulary. Jev coined it; Open-Jev cites it; Laya uses it without comment.

Architecture and numbers don't match either. open-jev-9b answers the same three question types on a completely different backbone: a LoRA adapter (rank 8, alpha 16) plus a scalar decision head over Qwen3.5-9B, a 9B autoregressive chat model repurposed to stop generating text — not a 421M encoder trained for the job from scratch. Its own card doesn't confirm using RL at all (the decision head is "trained jointly with LoRA," no REINFORCE or RLCD named), which would make it a supervised route to the same calibrated-typed-decision interface rather than a third RLCD implementation. Its headline numbers — 97.54% test / 91.97% OOD hard accuracy — are not comparable to Laya's 0.766 above: different eval sets, and Open-Jev-9B is scored on held-out rows from its own mostly-synthetic training generator, an easier bar than Laya's benchmark against a competitor's eval set. Full comparison on open-jev-9b's own page.

Benchmarks, all vendor-measured

Laya's card reports head-to-head numbers against Jev — its own measurements of both models, not an independent comparison:

Batched throughput reaches 103–332 questions/sec on a T4; batching 10 questions costs 72.3–158.6 ms total. Multilingual coverage: the English checkpoint is usable (>3× a random baseline) on 23 of 51 tested languages, the multilingual checkpoint on 45 of 51; a router auto-detects script in under 0.5 ms and dispatches to the right checkpoint.

Read this table as one vendor's numbers about a competitor's product, not a neutral benchmark — this spoke's growth edge 2 already tracks that every speed/VRAM figure in the corpus is a first-party snapshot; Laya vs. Jev is a second instance of exactly that pattern, now vendor-vs-vendor rather than vendor-vs-nothing.

Limitations, stated on the card

Unusually complete for a six-day-old release:

• Base checkpoints score near chance zero-shot on typed-decisions (0.362 vs. a 0.461 majority-class baseline) — the fine-tuned checkpoint is required for real accuracy.
• High-cardinality choice questions break it: at default settings a 77-option question gets ~3–4 tokens per label and accuracy drops to 0.425 (the Banking77 result above). The card recommends raising head_max_len or going hierarchical past ~50 options.
• Ordinal score questions are the weakest primitive: SST-5 five-way sentiment lands at 0.372.
• noul (yes/no) can anchor on its own option labels instead of the input, most on the English checkpoint — a confident "no" regardless of what the text says.
• action.act_probability "carries no usable signal yet" — it reads 1.0 for nearly all inputs (AUROC 0.30); the card recommends gating on the separate confidence score (AUROC 0.77) instead.
• Ships over-confident: mean ECE improves 0.466 → 0.081 (and 0.314 → 0.106 with domain refitting) only after temperature scaling is applied — raw outputs are not calibrated out of the box.
• English-only on the root checkpoint; non-English text needs the multilingual checkpoint.

Deployment

pip install laya, Python 3.10+, GPU/CPU/MPS. A Router class auto-detects language and picks a checkpoint; a laya-serve HTTP mode exposes a wire-compatible endpoint against Jev's own API shape. Optional extras: MCP server, LangChain/LangGraph integration, a TypeScript client (laya-ts), a TileLang GPU fast path, ONNX Runtime and torch.compile support. Apache-2.0, weights included, no metered cost for self-hosting.

A growth number this page can't explain

GitHub's own API puts the repo's creation at 2026-09-18T04:46 UTC and, as of this ingest six days later, 20,551 stars and 1,750 forks. PyPI's first release (0.1.0) landed the same day; 0.3.11 shipped the day before this ingest. That is a very fast climb for a week-old, single-maintainer project with no paper and no venue. It isn't evidence of anything specific — no claim here rests on star count — but it's the kind of number this spoke has learned to write down rather than silently fold into "popular."

Cross-spoke context

Runner-up spoke: llm-providers-wiki, where system-one-models-and-jev already owns the market side of this category (Jev's pricing, availability, and TypeSafe as a vendor). This page routes here because the substance is the model itself — architecture, training method, an open weight release — not a price list.

Also relevant to agentic-tooling-wiki's model-routing pages, cache-aware-model-routing and claude-code-model-router: a fast, cheap, calibrated typed-decision model is close to the primitive a prompt router needs (should this request escalate to a bigger model, yes/no, with a confidence attached), and Laya's own act/escalate head is that exact shape wearing model-card vocabulary. Noted here as context; not integrated into that spoke.

There is also an already-held, previously unfiled raw source on this exact subject — laya-doom-medium, a hobbyist's account of teaching Laya to play Doom — folded in as part of this ingest.

Tier T3: the architecture, licence and checkpoint facts are artifact-level and checkable; the load-bearing content of the card — every accuracy, calibration and latency number, including the Jev comparison — is the maker's own measurement of its own product against a competitor's, which is what T3 has always meant.

Related

convai-innovations · nandha-kishor-m · system-one-models-and-jev · fine-tuning · laya-doom-medium · open-jev-9b · cache-aware-model-routing · claude-code-model-router