Laya AI deep dive — open typed decisions, not a chat model

Board brief on Laya: what it actually is, how to run it, when it helps, and an invest note that is recommend-only (no capital moves). Companion piece: System One / Jev by TypeSafe AI.

What it is (verified)

Laya is an open-weight, non-autoregressive decision model from ConvAI Innovations (private limited company, Kasaragod, Kerala, India). You give it a state (text, email, ticket, or JSON) plus typed questions; it returns structured answers with probabilities in one forward pass. It does not generate free-form text, so there is nothing to parse and no chat-style hallucination path for the label itself.

Three decision primitives (same job shape as TypeSafe Jev):

• choice — pick one named option (e.g. billing vs technical) with a probability distribution
• score — place the input on an ordered rubric (e.g. urgency 0–3)
• noul — calibrated P(true) for a yes/no proposition (e.g. refund requested, churn risk)

Three published checkpoints (Apache 2.0) on Hugging Face under convaiinnovations/laya:

• laya — ModernBERT-large backbone, ~421M params, 512 context — English triage / guardrails
• laya-multilingual — mmBERT-base backbone, ~322M params, 1024 context (encoder up to 8k) — 100+ languages
• laya-typed-decisions — ModernBERT-large backbone, ~421M params, 1024 context — fine-tuned for typed-decision workflows (upstream reports 0.766 accuracy on their 2,000-decision bench)

Install surface (verified today): `pip install laya` — PyPI 0.3.20. Upstream quickstart: `from laya import Router`, then `router.predict(state, questions)`, with optional `Router(preload=True)`. Self-host HTTP via `laya[serve]` / `laya-serve` claims a Jev-compatible POST /v1/systemone shape (compatibility claim from upstream; not independently re-tested here).

Company (verified / public records): CONVAI INNOVATIONS PRIVATE LIMITED, CIN U72900KL2021PTC070857, incorporated 11 Sep 2021, ROC Ernakulam. Directors listed in MCA aggregators: Nandakishor Mukkunnoth, Anjali Mukkunnoth, Mukkunnoth Archana. Authorised / paid-up capital shown as ₹100,000 — small private company, not a public ticker. Company site positions broader products (Nadhi co-scientist / audit tooling, AI4Cardio) alongside Laya. Tracxn lists incubator / institutional ties (Kerala Startup Mission, IPTIF) and “funding raised” without a disclosed round size — treat amount as unverified.

Important: laya-ai.com is not the official product site

https://laya-ai.com is an independent community resource. Its own FAQ states it is not affiliated with ConvAI Innovations. Useful for orientation and demos; treat marketing copy there as secondary.

Prefer these primary sources:

• Official write-up: https://laya.convaiinnovations.com/
• Weights / model card: https://huggingface.co/convaiinnovations/laya
• Code: https://github.com/NandhaKishorM/laya
• Company about: https://convaiinnovations.com/about
• Live demo Space: https://huggingface.co/spaces/convaiinnovations/laya-demo

GitHub popularity (verified via GitHub API, Fri Sep 25 ET): NandhaKishorM/laya ≈ 24.5k stars, ≈ 2.1k forks, created 18 Sep 2026, license Apache-2.0. Star count is real and still moving fast; it is not by itself proof of production fitness.

How to use it

Typical path for an eng team:

• Install Python 3.10+ and `pip install laya` (add extras only if needed: serve / mcp / langchain / onnx).
• Build a small question schema with choice / score / noul for your workflow (keep choice sets under ~20 options at default settings — upstream documents degradation above that).
• Call `Router().predict(state, questions)` — or `Router(preload=True)` in a long-lived server so language switches do not pay multi-second cold loads.
• Gate automation on confidence and your own thresholds; escalate uncertain cases to a larger LLM or a human.
• For production quality: fine-tune on your labeled decisions and refit temperature calibration on held-out domain data. Upstream is explicit that base checkpoints are near chance on their typed-decisions bench zero-shot; the 0.766 figure belongs to the fine-tuned checkpoint.

Self-host options called out upstream: Python SDK, `laya-serve` HTTP, Docker / CLI notes in docs, community MLX / ONNX / JS ports (community ≠ official support).

When it is useful

Good fit

• High-volume routing / triage (support queues, email department, agent/model router)
• Guardrails before a generative model runs (jailbreak / policy / abuse flags) when you want structured probs, not another essay
• Risk / churn / phishing-style boolean scores you can threshold
• Air-gapped or cost-sensitive stacks where a ~300–400M encoder on your GPU beats metered frontier calls for reflex decisions
• Multilingual intake when Latin-script English models would quietly fail (upstream shows English checkpoint can be confidently wrong on non-Latin scripts — router exists for that reason)

Poor fit / caution

• Anything that must write text (summaries, replies, code) — pair with a generator; Laya is not a chatbot
• High-cardinality single-shot choice (>20–50 labels): upstream Banking77 stress shows sharp drop vs hosted Jev at default token budgets
• Blind trust of zero-shot base weights on your domain without labels or calibration
• Treating upstream vs-Jev tables as a controlled bake-off: Laya authors state they lacked TypeSafe API access and that sample sizes / prompts differ

Laya vs Jev (short)

Same product category (System One-style typed decisions). Jev is TypeSafe’s hosted closed model (API, early access / paid metering). Laya is ConvAI’s open-weight Apache 2.0 alternative you self-host. See the companion digest on System One / Jev for the TypeSafe side.

Claims vs evidence

Stronger / source-backed

• Open weights + Apache 2.0 code path exist (HF + GitHub + PyPI verified)
• Product category is real and competitive with TypeSafe Jev
• Upstream documents honest ceilings (cardinality, zero-shot weakness, calibration needs)

Weaker / treat as marketing or not independently verified here

• Exact latency / accuracy deltas vs Jev on identical prompts (directional only)
• Enterprise “commercial support / custom fine-tuning” pricing — mentioned on HF card; no public price sheet found
• Any customer logos, ARR, or production SLAs — not verified

Name collision risk: funding databases also mention unrelated “Laya Ai” entities (e.g. travel). For this product, stick to ConvAI Innovations / NandhaKishorM/laya / convaiinnovations/laya.

Invest angle (recommend-only — board decides capital)

Instrument: private Indian Pvt Ltd equity / optional commercial support contracts — no public stock ticker tied to Laya.

Recommend: powder-hold on equity. Watchlist only. Tiny disclosed share capital, undisclosed round size, product is days-to-weeks old in public form despite strong open-source velocity, category risk from well-funded closed peers (TypeSafe/Jev), no audited revenue disclosed in sources reviewed.

Soft risk-on for engineering adoption only: time-boxed spike (`pip install laya`, measure on your tickets, fine-tune if promising) if the hub needs cheap local routing / triage / guardrail gates. That is ops / R&D spend, not a fund transfer into ConvAI.

Never move or trade funds from this digest — board decides.

Bottom line

Laya is a real open System-1 decision stack for structured choice / score / probability gates, not a chat model and not the community mirror site. Use it when you need fast typed decisions you can branch on in code; fine-tune and calibrate before trusting it; keep equity capital in powder until there is a disclosed round, customers, or a liquid vehicle — none verified today.