Laya uitgelegd: een beslissingsmodel dat antwoordt zonder ook maar één token te schrijven

Het meest interessante aan Laya is niet zijn snelheid. Het is dat elke optie die je het voorlegt, wordt gescoord op zijn eigen [MASK]-token, en de waarschijnlijkheden worden vervolgens softmaxed over de opties van die ene vraag. Convai Innovations publiceerde Laya's gewichten op Hugging Face op 18 september 2026, onder Apache 2.0 — drie checkpoints, één repository, 421M parameters voor het Engelse model. Er zijn geen outputtokens. Er is geen decoderingslus, geen JSON om te parsen, geen accolade om te vergeten te sluiten. Je geeft het een toestand en een reeks getypeerde vragen, en één forward pass later krijg je een keuze uit benoemde opties, een ordinale score met een verwacht niveau, of een waarschijnlijkheid dat een bewering waar is. Dat ontwerp heeft een gevolg dat mensen missen: omdat de antwoordruimte per verzoek wordt samengesteld in plaats van ingebakken in een vocabulary-head, heeft een schema dat je vanmiddag bedenkt geen hertraining nodig. Het heeft ook een beperking, en het project vermeldt die ronduit op zijn eigen modelkaart: de basischeckpoints scoren 0,362 op de typed-decisions-benchmark, tegenover 0,318 voor willekeurig gokken en 0,461 voor altijd de meerderheidsklasse antwoorden. De eigen zin van Convai is degene die je in je hoofd moet houden — "Laya is een snelle basis om te specialiseren, geen zero-shot beslissingsengine." Het voor de hand liggende vergelijkingspunt is Jev van TypeSafe AI, een gehost System One-model zonder gepubliceerde gewichten, zonder gepubliceerd parameteraantal en zonder gepubliceerd basismodel. Laya is het open-weights antwoord daarop. Of dat antwoord nuttig voor je is, hangt bijna volledig af van welke helft van de pipeline je probeert te vervangen.

Wat Laya werkelijk is, en wat het niet is

Begin met het negatieve, want daar gaat het in de meeste artikelen mis. Laya is geen LLM. Het is niet-autoregressief: één enkele forward pass produceert het antwoord, en het model zendt nooit tekst uit. De latentie ervan vergelijken met de tokens-per-seconde van een chatmodel is twee verschillende bewerkingen met elkaar vergelijken — de ene classificeert, de andere genereert. Als je een alinea, een samenvatting, een plan of een redeneerketen nodig hebt, kan Laya je die niet geven en probeert dat ook niet.

Wat het is: een bidirectionele encoder met een beslissingshead die er bovenop is geschroefd. De Engelse checkpoint is ModernBERT-large — 395M parameters, volledig fine-tuned — plus een vanaf nul getrainde head die bestaat uit twee transformerlagen, een option-marker-scorer en een act/escalate-head, goed voor 421M in totaal. De meertalige checkpoint vervangt de backbone door mmBERT-base, 22 lagen en een vocabulaire van 256k, goed voor 322M in totaal. Er worden drie checkpoints in de ene repository geleverd, en alleen degene die je aanvraagt, wordt gedownload:

• convaiinnovations/laya — ModernBERT-large, 421 miljoen parameters, context van 512 tokens, Engels, ongeveer 808 MB op schijf.

• convaiinnovations/laya-multilingual — mmBERT-base, 322M parameters, 1.024-tokencontext (de encoder ondersteunt tot 8.192 met RoPE), meer dan 100 talen, ongeveer 2,2x sneller, ongeveer 647 MB.

• convaiinnovations/laya-typed-decisions — ModernBERT-large, 421M parameters, 1.024-token context, en de enige van de drie die het cijfer 0,766 bevat dat je overal zult zien aangehaald.

Een Router zit vooraan en kiest per verzoek het checkpoint door script en taal in minder dan een halve milliseconde te detecteren, in pure Python, voordat er een forward pass plaatsvindt. Dat is geen gemaksfunctie. Het is een correctheidsfunctie, en het bewijs van het project zelf laat zien waarom: het Engelse checkpoint scoort 0,000 nauwkeurigheid op Khmer terwijl het een confidence van 0,952 rapporteert. Een model dat zelfverzekerd blijft terwijl het volledig fout zit, is precies het geval waarin confidence-gating je niet kan redden, dus de routeringsbeslissing moet worden genomen voordat het model de input ziet. Over een sweep van 51 talen maakte de router 45 van de 51 talen bruikbaar — gedefinieerd als drie keer beter dan random — tegenover 23 van de 51 voor het Engelse checkpoint alleen.

Het ontwerpfeit dat de moeite waard is om te begrijpen: één [MASK]-token per optie.

Als je één ding uit dit artikel meeneemt, laat het dit zijn. In een normale classificatiekop ligt de labelset vast tijdens de training: de laatste laag heeft één uitvoer per klasse, en een klasse toevoegen betekent opnieuw trainen. Laya doet dat niet. Het rendert elke optie als tekst met een markering, en de optie-markering-scorer leest een score af van de eigen [MASK]-positie van die optie. Daarna past het softmax toe over de opties die bij die vraag horen.

De antwoordruimte wordt dus op het moment van het verzoek gedefinieerd. Jij schrijft de opties, het model scoort ze. Een nieuw schema heeft geen hertraining en geen fine-tuning nodig, omdat er niets in de gewichten zit dat "facturering" of "technisch" als klasse codeert — alleen het mechanisme om de ene gerenderde optie met de andere te vergelijken in de context van de toestand.

Twee budgetten bepalen hoe goed dat werkt, en ze zijn gedeeld. Elke sequentie splitst zich in een budget voor optieprompts (head_max_len, 192 tokens op het Engelse checkpoint en 256 op de andere twee) en een documentbudget (wat overblijft van max_len). Elke vraag in een aanroep wordt in diezelfde enkele forward pass beantwoord, dus een aanroep met zes vragen is niet zes modelaanroepen. Maar opties delen het optiebudget, daarom kent een vraag met 77 opties zoals Banking77 ongeveer drie tot vier tokens per label toe en valt de nauwkeurigheid steil terug — 0,425 tegenover de door Jev gepubliceerde 0,870. De oplossing is gedocumenteerd in plaats van verborgen: verhoog head_max_len en max_len, of splits een grote set opties in een tweetrapskeuze van grof naar fijn.

De drie primitieven

Alles wat Laya doet, is een van drie vraagtypes, en elk daarvan retourneert een andere vorm:

• choice — een waarschijnlijkheid per benoemde optie, plus het beste label en een betrouwbaarheid. Dit is de primitieve voor routering en intentieclassificatie.

• score — een verdeling over een geordende rubric plus een verwacht niveau. Dit is het ordinale primitief: urgentie, frustratie, ernst.

• noul — een gekalibreerde waarschijnlijkheid dat een bewering waar is, van 0,0 tot 1,0. Phishing, churnrisico, promptinjectie.

De types zijn strikt op een manier die operationeel van belang is. Een keuzevraag kan geen optie retourneren die je niet hebt aangeleverd, omdat deze alleen de opties kan scoren die je hebt gerenderd. Dat verwijdert een hele klasse van productiefouten — de verzonnen enum-waarde, de afgekapte JSON, de retry-lus rond een parser. Het verwijdert semantische fouten niet. Een model dat dit retourneert: billing: 0.94 voor een ticket dat naar de technische ondersteuning had moeten gaan, is fout, en het is zelfverzekerd fout. Getypeerde uitvoer garandeert de vorm van het antwoord, nooit de juistheid ervan.

RLCD, of waarom de waarschijnlijkheden iets zouden moeten betekenen

De meeste classifiers worden getraind om correct te zijn. Laya wordt getraind om eerlijk te zijn over hoe correct het is, en dat komt voort uit het trainingsrecept.

De methode heet RLCD — Reinforcement Learning for Calibrated Decisions. Het beleid geeft een verdeling af in plaats van een argmax; exploratie voegt Gaussiaanse ruis met gemiddelde nul toe aan de logits; en de beloning is een strikt proper scoreregel — log plus sferisch, met een ranked probability score toegevoegd voor ordinale vragen. Dat woord "proper" doet het werk. Een strikt proper scoreregel wordt in verwachting alleen gemaximaliseerd door je werkelijke overtuigingen te rapporteren, dus hedgen of overdrijven kost beloning door de constructie zelf in plaats van door instructie. Updates verlopen via REINFORCE met een groepsgemiddelde baseline, in GRPO-stijl, en gesprekken met meerdere beurten gebruiken TD(λ=1.0) over prefixfragmenten.

De praktische consequentie is dat een betrouwbaarheidsdrempel iets zinvols is om applicatielogica op te bouwen — een bewering die je niet kunt maken over een softmax afkomstig van een op cross-entropie getrainde classifier. Het is ook een bewering met een voorbehoud waar het project open over is: de meegeleverde checkpoints zijn te zelfverzekerd, en je wordt geacht een temperatuur op je eigen data opnieuw te fitten voordat je de getallen vertrouwt. Het opnieuw fitten van één temperatuur per vraagtype en aantal opties bracht de gemiddelde ECE van 0,466 naar 0,081 op het Engelse checkpoint en van 0,314 naar 0,106 op het meertalige. De door het project voorgestelde startdrempel voor automatische goedkeuring versus menselijke beoordeling is ongeveer 0,85.

Wat het kost om te draaien

De latentiecijfers zijn van het project zelf, gemeten op een Tesla T4, waarbij elke checkpoint in dezelfde run byte-identieke vragen beantwoordt:

• Eén vraag — 39,5 ms op laya, 32,8 ms op laya-multilingual.

• Vijf vragen — 84,5 ms en 40,1 ms.

• Tien vragen in batch — 158,6 ms (15,9 ms per vraag) en 72,3 ms (7,2 ms per vraag).

• Vijftig vragen — 771 ms en 337 ms, ofwel 6,8 ms per vraag op de meertalige checkpoint.

• Doorvoer bij batchverwerking op één T4 — 103 tot 332 vragen per seconde.

Als je een circulerende bewering "50x sneller dan Jev" hebt gezien, is dat niet het getal van het project, en de eigen benchmark van het project ondersteunt die niet. De gepubliceerde vergelijking van Convai is 7,8x op p50-latentie voor één vraag: 32,8 ms tegen 236-276 ms. Die vergelijking is ook degene die je zorgvuldig moet lezen, omdat de kaart van Laya de Jev-kant bestempelt als door derden gepubliceerde cijfers die Convai nooit heeft gemeten — het heeft geen TypeSafe API-toegang — en omdat er een forward pass op een lokale GPU tegenover een gehoste API-aanroep wordt gezet die netwerkroundtrip en wachtrijvorming omvat. Het architecturale deel van die kloof is reëel. Het infrastructurele deel ervan is geen eigenschap van het model.

Wat geheugen betreft: de voetafdruk is een paar honderd megabytes per checkpoint, en de deploymenttabel is het waard om te kennen voordat je een host dimensioneert. De lazy standaard houdt twee checkpoints resident (Engels en meertalig, de enige twee waartussen de router automatisch kiest), dus na de eerste laadbeurt van elke taal kost een wissel alleen detectie. Router(max_loaded=1) op een machine met beperkt geheugen herlaadt bij elke taalwissel, gemeten op een mediaan van 7,4 seconden op CPU en 10,3 seconden op een T4. Router(preload=True) is de serverconfiguratie: er wordt niets herladen, en de latentie per verzoek is het GPU-cijfer van 32,8 ms of 193–464 ms op CPU.

De eerlijke helft

Dit is waar het stuk zijn nut bewijst, want het oppervlak rond Laya is luidruchtig en de beperkingen zijn specifiek.

Ten eerste: het kopcijfer is een cijfer na fine-tuning. De nauwkeurigheid van 0,766 hoort bij laya-typed-decisions, het checkpoint dat is fijn afgestemd op de eigen trainingssplit van die benchmark. De basis-checkpoints scoren 0,362 en 0,342 zero-shot tegen een willekeurige baseline van 0,318 en een meerderheidsklasse-baseline van 0,461 — met andere woorden: onder de triviale baseline. Het project geeft dit aan in zijn eigen lijst met beperkingen in plaats van het te verbergen, en het fijn afgestemde checkpoint doorbreekt het plafond van 0,735 voor teacher-self-agreement, wat een echt sterk resultaat is voor een 421M-encoder op vier smalle workflows (factuurverwerking 0,804, beveiligingsincidenten 0,766, klantenservice 0,764, agent-trace-observability 0,730). Maar het is een resultaat over specialisatie, niet over het basismodel, en iedereen die 0,766 citeert als een algemene capaciteit leest de modelkaart verkeerd.

Ten tweede zijn de primitieven niet even goed. Op basis van nauwkeurigheid op de fijn afgestemde checkpoint: noul 0.857, choice 0.733, score 0.723. Het project noemt de ordinale score "de zwakste primitieve" ronduit, met SST-5 op 0.372. Als je beslissingsoppervlak een ernstbeoordeling van 1 tot 5 is, is dat de primitieve die je het minst reden hebt om out of the box te vertrouwen.

Ten derde zijn twee gedragingen gedocumenteerd als bugs in de eigen issuetracker van het project, en beide zullen je in productie verbranden als je ze niet leest. action.act_probability bevat nog geen bruikbaar signaal — issue #185 — omdat de output van de decision head niet genormaliseerd is, ruwweg 300x de schaal van de encoder, waardoor de act head verzadigt en 1.0 aangeeft voor bijna elke input. De ruwe logits werken tegen correctheid in, met een AUROC van 0,30 op 396 gelabelde beslissingen. Gate in plaats daarvan op confidence, die een AUROC van 0,77 bereikt op dezelfde items. Afzonderlijk daarvan: noul kan zijn eigen optielabels volgen in plaats van de state — issue #156 — omdat render_options de labels van een noul hardcodeert naar false: / true:, en dat labelpaar kan het antwoord domineren, waardoor een zelfverzekerd "nee" wordt teruggegeven voor duidelijk positieve input. De gedocumenteerde workaround is om dezelfde vraag te stellen als een choice met twee opties met neutrale keys en je ja/nee-bewoording als de descriptions.

Ten vierde, een kalibratiedetail dat gemakkelijk te missen is en het waard is om precies te vermelden. De checkpoint levert een gefitte temperatuur van 0,1006 voor de choice:11+ bucket, en de loader begrenst elke temperatuur tot [0,5; 5,0]. Die begrenzing doet je een plezier. Een zo scherpe temperatuur zou een werkelijk gesplitste verdeling als bijna-zekerheid kunnen rapporteren; de begrenzing betekent dat het slechtste geval een zachter antwoord is dan de fit beoogde, en de loader geeft een waarschuwing weer waarin de getroffen bucket bij naam wordt genoemd en die je opdraagt dat vertrouwen als ongekalibreerd te behandelen. Lees de waarschuwingen bij het laden in plaats van ze te onderdrukken.

Ten vijfde, alleen Engels op de root van de repo, en de faalmodus buiten het Engels is niet elegant — vandaar de router, en vandaar de aanbeveling om laya-multilingual te gebruiken voor alles wat geen Engels proza is.

Het onafhankelijke beeld, voor zover dat bestaat, is beperkter dan het beeld van de leverancier en spreekt dat niet tegen. Een onafhankelijke rechtstreekse vergelijking — sysone-bench, 751 toestanden verdeeld over negen suites, gedateerd 2026-09-21, uitgevoerd op byte-identieke inputs, waarbij de vraag-hashes vóór de vergelijking als identiek zijn geverifieerd — laat Jev voorliggen bij triage, guardrails, moderatie, banking77 en meertalige intentie, en Laya bij AG News (0,940 vs. 0,910) en MNLI (0,983 vs. 0,867). Het resultaat van de confidence-gating is het resultaat waarop ik daadwerkelijk zou plannen: gating op 0,85 confidence behield 58% van het verkeer van Laya bij een nauwkeurigheid van 0,878, tegenover 78% van het verkeer van Jev bij 0,917. Dat is de vorm van de afweging — Laya automatiseert een kleiner deel van het verkeer, met een lagere nauwkeurigheid op het deel dat het behoudt, en de eigen router-run van Laya verhoogt de meertalige intentie van 0,360 naar 0,840.

Het oppervlak eromheen, dat ongewoon breed is

Voor een project waarvan de gewichten pas enkele dagen oud zijn, is het integratieoppervlak het onderdeel dat verrast. Dit alles staat in de upstream-repository op NandhaKishorM/laya, dat 19.871 sterren op GitHub had toen dit werd geschreven, en het is volledig Apache 2.0:

• laya-serve — een HTTP-server die de Router beschikbaar stelt op dezelfde POST /v1/systemone aanvraag- en antwoordvorm als TypeSafe's gehoste Jev API, zodat een bestaande TypeSafe-client verhuist door zijn basis-URL te wijzigen. Merk de standaardbeveiliging eerlijk op: hij bindt aan 0.0.0.0 zonder authenticatie, tenzij LAYA_API_KEY is ingesteld, in welk geval er een bearer-token vereist is. Er bestaat een geharde NixOS-modulevariant die draait onder een DynamicUser-systemd-unit en het token doorgeeft via LoadCredential in plaats van het in de store te zetten.

• Een volledige TypeScript-port in laya-ts/ voor Node en de browser, plus een ONNX-agentpad (laya.onnx_agent.ONNXAgent) voor het uitvoeren van een geëxporteerd model op ONNX Runtime zonder PyTorch tijdens runtime.

• Een MCP-server achter een optionele extra, die laya_predict, laya_route, laya_preset en laya_status als tools beschikbaar stelt.

• LangChain- en LangGraph-integraties — LayaRouter voor routing via voorwaardelijke edges met een betrouwbaarheidsdrempel en fallback, en LayaGuardrail.

• Een Nix-flake met nix run .#laya-serve en een services.laya-serve module, vier compose-bestanden, een Docker-imagepad met een gedocumenteerde quickstart, en een Kaggle-notebook dat de volledige RLCD-fine-tuninglus op gratis 2xT4 GPU's in vier tot vijf uur met ongeveer 30k vragen draait.

Apache 2.0 is het licentiegegeven dat bepaalt of je dit binnen een product kunt uitbrengen: het staat commercieel gebruik, wijziging en herdistributie toe, en het verplicht je niet om je wijzigingen of je fijngetunede gewichten te publiceren. De verplichting is de gebruikelijke naamsvermelding en het behoud van kennisgevingen, plus het uitdrukkelijk ontbreken van een octrooi- of handelsmerkverlening verder dan wat de licentie bepaalt. Voor een beslissingslaag die vóór klantverkeer staat, is dat een wezenlijk andere propositie dan een gehoste endpoint met vroege toegang waarvan de gewichten, architectuur en het trainingsrecept allemaal niet openbaar zijn — wat Jev vandaag is, tegen $0,042 per miljoen inputtokens, met gratis output en een invoeroppervlak voor uitsluitend tekst.

Waar dit eigenlijk past: vooraan een beslissingshoofd, achteraan een gerouteerde LLM

Het patroon dat de moeite waard is om te internaliseren is niet "beslissingsmodel in plaats van LLM." Het is een tweefasige pijplijn, en beide fasen bestaan omdat de andere ergens slecht in is.

Zet Laya vooraan voor de hoogvolume-, smalle, machineconsumeerbare beoordeling: routeer het ticket, classificeer de intentie, scoor de urgentie, bepaal of dit document relevant is voor de query, controleer of deze concepttekst een beleid schendt. Die aanroepen hebben een vaste antwoordenset, ze vinden duizenden keren per uur plaats, en een lokale forward pass van 33 milliseconden met nul outputtokens past beter bij hen dan een generatieve roundtrip. Zet daarna een generatief model erachter voor de aanroepen die echt proza, synthese of redeneren over een lange context nodig hebben — het opstellen, de uitleg, de escalatiesamenvatting.

Daar zit OrcaRouter, en het is de moeite waard om precies te zijn over de grens. Wij leveren Laya niet; het is een 421M-encoder die je zelf draait, en het hele punt ervan is dat hij draait waar je data al staat. We leveren Jev ook niet — het is het early-access-endpoint van TypeSafe. Wat wij dekken is de generatieve helft van diezelfde pijplijn: 200+ modellen achter één OpenAI-compatibele sleutel, tegen de lijstprijs van de provider, doorgegeven met 0% opslag, met automatische failover tussen providers. De praktische reden dat dit hier uitmaakt, is de naad tussen de twee helften. Op het moment dat je beslissingen begint te routeren naar een generatief model voor de gevallen die de decision head heeft afgewezen, heb je een tweede integratie, een tweede factuur en een tweede storingsmodus. Eén sleutel voor de generatiekant, met failover als een provider degradeert, betekent dat het escalatiepad van de beslissingslaag een configuratiewijziging is in plaats van een tweede leveranciersrelatie. Dat is een kleine bewering, en het is de ware.

Wie zou het moeten adopteren, en wie zou moeten wachten

Neem Laya nu in gebruik als je gelabelde data en een trainingsloop hebt, en een beslissingsoppervlak dat stabiel genoeg is om erop te specialiseren. De Kaggle-notebook bestaat precies zodat de fine-tuningstap geen onderzoeksproject is, de basischeckpoints in ongeveer twee seconden op CPU laden, en de licentie je in staat stelt het resultaat commercieel uit te brengen zonder je gewichten te publiceren. De workloads die het beste passen, zijn degenen die het project al heeft gebenchmarkt: ticket triage, factuurverwerking, classificatie van security-incidenten, guardrails en moderatie, en observability van agenttraces. Houd keuzevragen onder ongeveer 20 opties, calibreer een temperatuur op je eigen held-out data voordat je een drempel in productie zet, en stuur op confidence, nooit op act_probability.

Wacht als je beslissing meteen uit de doos goed moet zijn, zonder gelabelde data. Een basis-checkpoint dat onder de majority-class-baseline ligt op de benchmark waartegen het is gepubliceerd, is geen zero-shot-engine, en de eerlijke lezing van de cijfers van leverancier versus onafhankelijke partij is dat een goed beheerde gehoste beslissings-API momenteel de sterkere zero-shot-keuze is. Wacht ook als je optiesets groot zijn en je niet bereid bent het head-budget af te stemmen, als je ordinale scoring onmiddellijk betrouwbaar moet zijn, of als je beeld-, audio- of lange-documentinvoer nodig hebt — Laya is alleen tekst en het contextbudget is standaard 512 tot 1.024 tokens, wat een selectie van bewijs is in plaats van een heel document.

Wat deze categorie zal beslissen, zijn niet de latentiecijfers, die al goed genoeg zijn om niet langer het argument te zijn. Het is de vraag of een klein model dat eerlijke waarschijnlijkheden rapporteert op een door jou gedefinieerd beslissingsoppervlak, en dat je op je eigen labels kunt hertrainen, het wint van het aanroepen van een groot generatief model en het parsen van de uitvoer ervan. Laya is een geloofwaardige eerste serieuze poging tot de open-weightsversie van die vraag — en het is hoogstens een paar dagen oud, wat de juiste manier is om alles hierboven te lezen. De basis is het startpunt, niet het product.