Laya: Een meertalige "System 1"-beslissingsengine van 33 ms met gekalibreerde waarschijnlijkheden

Ik bouwde een jaar geleden niet-autoregressieve beslissingsmodellen met RL (Reinforcement Learning). Kort daarna noemde een vooraanstaand laboratorium dit een "doorbraak".

Van ons arXiv-onderzoek uit maart 2025 over sequentieconversie-trajecten naar Laya: een open-weight "System 1"-beslissingsengine met een reactietijd van minder dan 35 ms, uitgerust met RLCD, meertalige routing voor meer dan 100 talen en state-of-the-art kalibratie.

De context: Van innovatie naar concurrentie

Momenteel is er in de AI-wereld veel aandacht voor een nieuw type model: een architectuur die niet-autoregressief is, geen tekst genereert, maar razendsnel waarschijnlijkheidsvoorspellingen geeft over gestructureerde schema's.

Ik werkte hier letterlijk een jaar geleden, in maart 2025, al aan. Na maanden van intensief werk publiceerde ik een arXiv-paper (arXiv:2503.23303), stelde ik de modelweights beschikbaar op Hugging Face (sales-conversion-model-reinf-learning), publiceerde ik de open dataset (saas-sales-conversations), bouwde ik een PyPI-pakket en deelde ik de aanpak op Reddit (r/LocalLLaMA).

In september 2025 publiceerde ik een tweede paper (arXiv:2510.01237) waarin ik het raamwerk voor schema-gebaseerde beslissingen gestuurd door reinforcement learning formaliseerde. De sturende kracht in mijn systeem was altijd RL, en niet enkel een embedding-model of een autoregressieve LLM.

In september 2026 lanceerde TypeSafe AI (opgericht door Diogo Almeida, mede-uitvinder van ChatGPT bij OpenAI) vervolgens "Jev". Zij presenteerden exact hetzelfde concept van niet-autoregressieve beslissingen alsof het een gloednieuwe wetenschappelijke doorbraak was, maar dan zonder technische papers, open weights of open trainingsdatasets.

Mijn eerdere model gebruikte PPO over sequentie-representaties om turn-by-turn conversietrajecten (waarschijnlijkheden van 0.0 tot 1.0) in verticale verkoopgesprekken uit te voeren. Jev generaliseerde parallelle sampling via RLCD (Reinforcement Learning for Calibrated Decisions) om betrouwbaarheidsdistributies en schema-keuzes horizontaal uit te voeren, met kosten van $0,042 per miljoen input-tokens en gemiddelde responstijden van ongeveer 150 ms.

In plaats van bitter te blijven, besloot ik alles wat ik had geleerd te gebruiken om de architecturale beperkingen van de oude aanpak op te lossen en een volledig open, horizontaal System 1-beslissingsmodel te bouwen: Laya.

Omdat Laya is gebouwd op bidirectionele encoders, draaien onze modellen in 32,8 milliseconden op een enkele GPU (7,2 ms per vraag bij batching). Dit maakt Laya 6 tot 8 keer sneller dan Jev. Daarnaast biedt het volledige ondersteuning voor meer dan 100 talen, heeft het geen API-abonnementskosten en zijn de weights 100% open-source onder de Apache 2.0-licentie.

---

1. De kernrealisatie: System 1 versus System 2

Elke moderne AI-pipeline heeft een enorme bottleneck: we gebruiken generatieve LLM's voor eenvoudige reflexbeslissingen.

Wanneer er een supportticket binnenkomt, een e-mail in de inbox landt of een gebruiker een prompt naar een API stuurt, hoef je vaak alleen eenvoudige, gestructureerde vragen te beantwoorden:

  • Naar welke afdeling moet dit ticket worden gerouteerd?
  • Is deze inkomende e-mail een phishing-aanval of spam?
  • Probeert deze prompt een jailbreak of instructie-injectie uit te voeren?
  • Hoe urgent is dit probleem op een ordinale schaal (0 tot 3)?
  • Vereist deze query code-uitvoering of een simpel feitelijk antwoord?

Het aanroepen van een 8B, 70B of frontier generatieve LLM hiervoor is complete overkill. Je wacht 500 ms tot 2.000 ms tot tokens worden gestreamd, betaalt voor de inferentie en moet vervolgens regex- of JSON-parsers schrijven om een schoon label uit de vrije tekst te extraheren. Bovendien neigen LLM's naar hallucinaties en genereren ze valse betrouwbaarheid. Als een LLM "confidence: 0.95" uitspuugt, voorspelt het simpelweg tokens die zelfverzekerd klinken; er zit geen wiskundige kalibratie achter.

We hadden een model nodig dat werkt als "System 1" van het menselijk brein: instant reflexbeslissingen met eerlijke, gekalibreerde waarschijnlijkheden, die slechts 30 tot 35 milliseconden in beslag nemen op standaard hardware.

---

2. De drie beslissingsprimitieven

Laya evalueert getypeerde vragen over elke willekeurige status (platte tekst, e-mail, ticket of JSON-document) in één enkele forward pass. Het systeem vertrouwt op drie primitieven:

  • choice: Kiest één optie uit een dictionary van criteria. Geeft de geselecteerde sleutel, de waarschijnlijkheidsdistributie over alle opties en een gekalibreerde betrouwbaarheidsscore terug.
  • score: Plaatst de status op een ordinale schaal (niveaus 0, 1, 2, ...). Geeft het verwachte niveau, de distributie over de rangschikking en de betrouwbaarheid terug.
  • noul: Een directe booleaanse vraag die een gekalibreerde waarschijnlijkheid $P(\text{true})$ teruggeeft van 0.0 tot 1.0 (waarbij $P(\text{false}) = 1 - P(\text{true})$).

Omdat de outputruimte puur uit waarschijnlijkheden en getallen bestaat, genereert het model nooit tekst, kan het niet hallucineren en zijn schema-schendingen of foutieve JSON-outputs fysiek onmogelijk.

---

3. De drie checkpoints en Bundled Hub-architectuur

Eén enkel model kan niet optimaal zijn voor elke taak en taal. Daarom hebben we drie gespecialiseerde checkpoints uitgebracht, die nu zijn samengevoegd in één repository op Hugging Face:

CheckpointBackbone EncoderParamsContextPrimaire Sterkte
convaiinnovations/layaModernBERT-large421M512Engelse tekstclassificatie, guardrails, e-mail triage
convaiinnovations/laya-multilingualmmBERT-base (256k vocab)322M1024 (tot 8k)100+ talen, 2.2x sneller, cross-lingual NLI
convaiinnovations/laya-typed-decisionsModernBERT-large421M1024Agent-observabiliteit, klantenservice, factuurverwerking, beveiligingsmeldingen (0.766 acc)

Selectieve downloads van submappen

Om te voorkomen dat gebruikers drie aparte repositories moeten beheren of 2,5 GB aan weights moeten downloaden, bundelt de hoofdrepository convaiinnovations/laya alle drie de modellen. Via de allow_patterns van Hugging Face downloadt de SDK van Laya alleen de specifieke submap die wordt opgevraagd:

# Downloadt het Engelse model (~808 MB)
agent_en = laya.load("convaiinnovations/laya")

# Downloadt ALleen de meertalige submap (~647 MB), niet de volledige bundel van 2,5 GB
agent_ml = laya.load("convaiinnovations/laya", subfolder="multilingual")

---

4. Waarom routing essentieel is: De realiteit van meerdere scripts

Een van de meest onthullende bevindingen uit onze test met 51 talen op de MASSIVE-benchmark (20 opties, random baseline = 0.050) was hoe Engelse modellen falen buiten het Latijnse schrift.

De Engelse BPE-vocabulaire van 50.000 tokens van ModernBERT-large fragmenteert niet-Latijnse alfabetten volledig:

  • Khmer: 0.000 nauwkeurigheid bij 0.952 gemiddelde betrouwbaarheid. Geen enkel correct besluit in 100 vragen, terwijl er ~95% betrouwbaarheid werd gerapporteerd.
  • Armeens: 0.050 nauwkeurigheid (exact gelijk aan een muntworp) bij 0.885 betrouwbaarheid.
  • Hebreeuws: 0.060 nauwkeurigheid bij 0.964 betrouwbaarheid.
  • Bengali: 0.080 nauwkeurigheid bij 0.945 betrouwbaarheid.
  • Hindi: 0.100 nauwkeurigheid bij 0.941 betrouwbaarheid.

De cruciale les is dat de eigen betrouwbaarheid van het model geen waarschuwing geeft wanneer het het input-script niet kan lezen. Over 51 talen zakte de gemiddelde betrouwbaarheid van het Engelse checkpoint nooit onder de 0.885, ongeacht of de nauwkeurigheid 82% of 0% was.

Daarom kan "confidence gating" je niet beschermen. De beslissing over welk model te gebruiken moet worden genomen vóór de forward pass.

Sub-milliseconde routing in pure Python

Laya bevat een ingebouwde Router die de Unicode-scripts van binnenkomende tekst over 22 alfabetten (Devanagari, CJK Han, Cyrillisch, Arabisch, Hebreeuws, Tamil, Thai, etc.) inspecteert en de distributie van Latijnse stopwoorden analyseert:

  • Standaard Engelse tekst: 0,09 ms overhead voor detectie.
  • Devanagari / Indic-tekst: 0,54 ms overhead voor detectie.
  • Grote geneste JSON-documenten (200 rijen): 0,73 ms overhead voor detectie.

Vergeleken met een forward pass van 33 ms is de routing-overhead verwaarloosbaar (<2%). Met Router(preload=True) blijven alle benodigde modellen in het VRAM/RAM aanwezig, waardoor de cold-swap penalty van 7 tot 10 seconden volledig wordt geëlimineerd wanneer het verkeer wisselt tussen talen.

from laya import Router

# Preload checkpoints in het geheugen voor instant routing onder de 35ms
router = Router(preload=True)

# Engels -> automatisch gerouteerd naar ModernBERT-large
res_en = router.predict({"body": "I was charged twice, please refund."}, questions)

# Hindi -> automatisch gerouteerd naar mmBERT-base (100+ talen)
res_hi = router.predict({"body": "मुझसे दो बार शुल्क लिया गया, कृपया पैसे वापस करें।"}, questions)

# Expliciete override wanneer het domein al bekend is
res_spec = router.predict(state, questions, model="typed-decisions")

---

5. Head-to-Head: Laya (met Routing) versus TypeSafe Jev

We hebben Laya direct gebenchmarkt tegen TypeSafe Jev met behulp van publieke datasets en standaard benchmarks. De cijfers voor Laya zijn gemeten; de cijfers voor Jev zijn afkomstig uit onafhankelijke studies (AbdelStark, nibzard) en TypeSafe AI.

Benchmark / MetriekTypeSafe Jev 1.13.0Laya (Routed)Voordeel / Delta
typed-decisions (2.000 beslissingen)0.7270.766+3,9% (verslaat 0.735 teacher ceiling)
AG News (4 labels)0.9100.950+4,0% hogere nauwkeurigheid
DAIR Emotion (6 labels)0.480 (Brier 0.846)0.595+11,5% hoger (Jev had 16% nul-prob)
Calibration Error (ECE)0.2460.0813x betere waarschijnlijkheidskalibratie
Latency P50 (1 vraag)236 – 276 ms32,8 ms7,8x snellere uitvoering
Latency P50 (10 vragen gebatcht)~1.500 ms (serieel)72,3 ms (7,2 ms/q)20x sneller bij batched calls
Bruikbare talen (> 3x random)Geen gepubliceerde benchmark45 van de 51 talenMondiale taaldekking
Kosten per 1M tokens$0.042 (gemeten API)$0.00 (self-hosted)100% gratis Apache 2.0
Model Weights & CodeGesloten proprietary APIOpen-source safetensorsAir-gapped & on-premise mogelijk

Real-world applicatie-workflows

Over 9 geëvalueerde enterprise-workflows toont Laya productie-waardige beslissingskwaliteit:

  • E-mail Spam Filtering (Enron): 0.993 nauwkeurigheid, 0.993 F1, 0.013 ECE.
  • Phishing Detectie: 0.980 nauwkeurigheid, 0.979 F1, 0.012 ECE.
  • LLM Guardrails & Jailbreaking (ToxicChat): 0.755 – 0.762 nauwkeurigheid. Bij 50% selectieve dekking stijgt de nauwkeurigheid naar 0.931.
  • RAG Passage Relevance Filtering: 0.657 nauwkeurigheid in één enkele forward pass.
  • Support Ticket Queue Routing (10-way): 0.522 nauwkeurigheid.

---

6. Eerlijke beperkingen: Waar Laya tegen grenzen aanloopt

Veel AI-aankondigingen verbergen hun zwakheden. Wij geloven in engineering-eerlijkheid:

  • 'Choice'-vragen verslechteren bij >20 opties: In onze stresstest op Banking77 (77 labels) scoorde Laya 0.425 tegenover 0.870 van Jev. Dit is een architecturale beperking: opties delen een headmaxlen budget van 192-256 tokens, wat bij 77 opties slechts ~3-4 tokens per kandidaat overlaat. Aanbeveling: Houd choice-schema's onder de 20 opties of gebruik een twee-staps hiërarchie (grof-naar-fijn).
  • Zero-shot versus Fine-tuning: De basismodellen scoren "out-of-the-box" ongeveer 0.35 op de typed-decisions benchmark (nabij random). De score van 0.766 is behaald door fine-tuning op de train-split van de benchmark. Beschouw Laya als een snel basismodel om te specialiseren, niet als een alwetend zero-shot orakel.
  • Temperatuurkalibratie: De basis-weights worden geleverd met ruwe temperatuur-logits. Het fitten van een enkele scalaire temperatuur per vraagtype op jouw domein-distributie verlaagt de verwachte kalibratiefout van 0.466 naar 0.081.

---

7. Quickstart: Laya draaien in 30 seconden

pip install laya>=0.3.3

Hier is een compleet voorbeeld van multi-schema beslissingen met automatische taalrouting:

import laya
from laya import Router

# Initialiseer router met preloading (voorkomt swap-vertraging)
router = Router(preload=True)

# Definieer een complexe status
ticket = {
    "ticket_id": "TCK-8821",
    "customer": "enterprise_user",
    "subject": "System downtime and billing dispute",
    "body": "Our production API has been failing since 6 AM. We lost critical transactions. We demand an immediate SLA refund."
}

# Definieer meerdere vragen met verschillende primitieven
questions = {
    "queue": {
        "type": "choice",
        "instructions": "Which engineering queue owns this ticket?",
        "criteria": {
            "infrastructure": "server outages, network downtime, database failures",
            "billing": "refunds, SLA credits, invoice disputes",
            "security": "breaches, vulnerability reports",
            "support": "general customer inquiries"
        }
    },
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this ticket?",
        "criteria": ["low priority", "medium", "high priority", "critical blocker"]
    },
    "churn_risk": {
        "type": "noul",
        "instructions": "Does the customer threaten to cancel or express severe churn intent?"
    }
}

# Eén enkele forward pass: evalueert alle vragen gelijktijdig
res = router.predict(ticket, questions)

print("Routing Decision :", res["routing"]["model"])
# -> english
print("Assigned Queue   :", res["answers"]["queue"]["choice"])
# -> infrastructure (confidence: 0.96)
print("Urgency Score    :", res["answers"]["urgency"]["score"])
# -> 2.87 / 3.0
print("Churn Risk       :", f"{res['answers']['churn_risk']['noul']:.1%}")
# -> 91.4%

---

8. Bronnen & Community

  • Hugging Face Model Hub: convaiinnovations/laya (bevat alle 3 de checkpoints)
  • Live Interactive Space: convaiinnovations/laya-demo (test 8 workflows & meertalige routing live op ZeroGPU)
  • GitHub Repository: github.com/NandhaKishorM/laya (code, router en reproduceerbare benchmark-harnesses op de research branch)
  • PyPI Package: pip install laya
  • Kaggle 2xT4 Fine-Tuning Notebook: layafinetunetypeddecisions2xT4_kaggle.ipynb (train je eigen custom System 1-model in ~4 uur op gratis Kaggle GPU's)

Conclusie

Het kostte een jaar onderzoek, van onze arXiv-paper in maart 2025 tot nu, maar de kernrealisatie blijft: niet elk AI-probleem vereist een autoregressieve chatbot.

Voor high-volume classificatie, guardrails, routing en triage levert een bidirectioneel beslissingsmodel van minder dan 35 ms, getraind met RLCD, een 7,8x snellere uitvoering op dan propriëtaire alternatieven. Het biedt nul hallucinaties, mondiale taalrouting en eerlijke betrouwbaarheidsscores waarop je daadwerkelijk kunt sturen in productiecode.

En het belangrijkste: het is 100% open-source voor de gehele community.