Laya vs Decider: Een 421M-encoder tegen een 35B-mix

Laya en Decider zijn beide open-weight, niet-autoregressieve beslissingsmodellen die getypeerde vragen beantwoorden — een keuze uit een aangeleverde lijst, een score op een geordende rubric, een ja/nee-kans — in één enkele forward pass, en ze bevinden zich aan tegenovergestelde uiteinden van het grootte-spectrum. Convai Innovations bracht Laya op 18 september 2026 uit onder Apache 2.0: een 421M ModernBERT-large encoder voor Engels met een contextvenster van 512 tokens, een 322M mmBERT-base meertalig checkpoint met een venster van 1.024 tokens dat 100+ talen bestrijkt, en een router die het schrift detecteert en naar de juiste doorstuurt. Mapika's Decider-familie loopt van decider-0.8b en decider-2b op kleine generatieve basissen tot decider-35b-a3b, een 35B mixture-of-experts met ongeveer 3B actieve parameters. Beide zijn gratis te downloaden en beide geven kansen terug in plaats van tekst. De reden dat ze niet uitwisselbaar zijn, is niet het nauwkeurigheidscijfer waarmee de meeste artikelen beginnen.

Twee families, één architecturale gok

De gedeelde gok is dat een beslissing geen decodeerlus nodig heeft. Een generatief model dat wordt gevraagd "is dit ticket een terugbetalingsverzoek?" moet tokens uitzenden, en op het moment dat het tokens uitzendt, ben je verantwoordelijk voor parsing, schemavalidatie en een retry-pad voor de ene keer op de tweehonderd dat het een accolade vergeet. Laya en Decider slaan dat beide over door het antwoord rechtstreeks uit één forward pass te lezen — Laya uit een bidirectionele encoder, Decider uit de logits van met letters aangeduide optietokens op een speciaal antwoordslot in de prompt.

Daar houdt de gelijkenis op. Laya bestaat uit twee kleine encoders achter een taalrouter, waardoor het een Engels venster van 512 tokens en een meertalig venster van 1.024 tokens krijgt, bij een omvang van 421M en 322M parameters. Decider behoudt een generatieve backbone en voegt daarbovenop een readout toe: decider-2b is een gesuperviseerde fine-tune van Qwen3.5-2B-Base, gevolgd door een calibratiebewuste reinforcement-ronde op live browsertaken en exacte games, terwijl decider-35b-a3b de gerouteerde experts bevriest en blokmatrices traint met Muon. De praktische consequentie is dat Decider de wereldkennis van een taalmodel erft en Laya niet. De andere consequentie is dat Decider de voetafdruk van een taalmodel erft.

Mapika's eigen documentatie plaatst decider-2b op 18 ms mediaan per beslissing op een B300 in bf16, batch van één, zonder CUDA-graphs of compilatie, en decider-35b-a3b op 41 ms in dezelfde opstelling. Op een GH200 met supportticket-contexten van ongeveer 230 tokens en drie tot vijf getypte vragen rapporteert hetzelfde project 49 ms eager, 4,0 ms met CUDA-graphs en torch.compile, en ongeveer 1.370 beslissingen per seconde bij batch 32. Dat zijn door de leverancier gepubliceerde cijfers uit de eigen beschrijving van het project, geen onafhankelijke meting. Laya's kopcijfer is eveneens door de leverancier gepubliceerd: 32,8 ms p50 per beslissing op een Tesla T4, en 7,2 ms per vraag bij batchgrootte 10.

De kalibratievraag, die de twee projecten op verschillende schalen beantwoorden

Calibratie is het cijfer dat er het meest toe doet voor een beslissingsmodel, want het hele punt van het teruggeven van een waarschijnlijkheid is dat iemand stroomafwaarts er een drempel op zal zetten. Dit is ook waar een directe vergelijking van Laya en Decider je op het verkeerde been zal zetten.

Laya wordt geleverd met een verwachte kalibratiefout van 0,466 op zijn eigen modelkaart, en de kaart vermeldt ronduit dat het opnieuw fitten van een temperatuur per vraagtype dat naar 0,081 brengt. Dat is een ongewoon eerlijke onthulling, en het betekent ook dat de meegeleverde checkpoint niet het gekalibreerde artefact is. Het getal dat je out of the box krijgt, is 0,466.

Decider rapporteert over een volledig ander instrument. De Decision Index — een open leaderboard dat elke open reproductie van Jev draaide over 132.422 verzoeken — plaatst decider-35b-a3b vierde overall met 54,3, achter de 59,5 van Jev, en rapporteert het als de best gekalibreerde van de 32 inzendingen met een kalibratiefout van 3,1 punten en 0,4% foute antwoorden bij een opgegeven confidence van 95%+. decider-2b rapporteert 8,8 punten en 0,9%. Dat zijn cijfers die door het leaderboard zijn gepubliceerd, en 3,1 punten op de tien-bins-ECE van de Index is niet dezelfde meting als Laya's 0,466 op zijn eigen evaluatie. Ze naast elkaar in een tabel zetten zou een appels-met-peren-fout zijn, vermomd als nauwgezetheid. Wat je kunt zeggen, is dat de auteur van Decider ervoor koos om gemeten te worden op een leaderboard van een derde partij, en dat de auteur van Laya ervoor koos om zelf het zwakste kalibratiecijfer te publiceren; geen van beide is geauditeerd door de harness van de ander.

Waar elk van beide wint, dimensie voor dimensie

• Backbone — Laya: ModernBERT-large 421M-encoder, bidirectioneel. Decider: Qwen3.5 generatieve basismodellen, 0,8B tot 35B-A3B.

• Talen — Laya: 100+ via een meertalig checkpoint van 322M achter een router. Decider: alleen Engels, als beperking vermeld.

• Contextvenster — Laya: 512 tokens voor Engels, 1.024 voor meertalig. Decider: invoer tot 32k geaccepteerd, getraind tot 16k op de v6-generatie, getest tot 30k.

• Plafond van de optieset — Laya: degradeert sterk voorbij ongeveer 20 opties, 0,425 op Banking77 tegenover 0,870 van Jev. Beslisser: Choice voor 2 tot 255 benoemde opties, Score voor 2 tot 10 beschreven niveaus.

• Zero-shot-nauwkeurigheid — Laya: 0,362 op de typed-decisions-benchmark, onder de majority-class-baseline van 0,461. Decider: niet gepubliceerd als een zero-shot-getal; in plaats daarvan rapporteert het project taakspecifieke resultaten.

• Calibratie — Laya: ECE 0,466 zoals geleverd, 0,081 na temperatuurherfitting per vraagtype. Decider: 3,1 punten op de Decision Index voor de 35B, beste van 32 inzendingen.

• Redenering — Laya: geen, per constructie. Beslisser: geen, expliciet vermeld — het is een patroonherkenningsuitlezing, geen redeneerder.

• Licentie — Apache 2.0 voor beide.

Nog een detail over Decider dat de moeite waard is om te weten voordat je het kiest: het project waarschuwt dat het op positie selecteren van één record uit een lange JSON-array een zwakke use case is, en raadt aan om records via een sleutel aan te spreken. Dat is het soort beperking dat je alleen leert kennen door het te draaien.

Wat het je kost om een van beide te draaien

Laya's kostenprofiel is een fine-tuningproject. Het model is klein genoeg om op een laptop-CPU te draaien voor werk met lage doorvoer, maar de zero-shotscore van het meegeleverde Engelse checkpoint ligt onder de triviale baseline, wat betekent dat het adopteren van Laya neerkomt op het bouwen van een gelabelde set, fine-tunen en het per vraagtype opnieuw afstellen van de temperatuur. De beloning is dat zodra je dat hebt gedaan, het artefact 421M parameters heeft en binnen tientallen milliseconden antwoordt op een T4. Convai's eigen fine-getunede laya-typed-decisions checkpoint bereikt 0,766 op de trainingssplit van de benchmark — een getal dat meer zegt over fine-tuning dan over het basismodel, en dat zegt de kaart ook.

Het kostenprofiel van Decider is een beslissing over serving. Je kiest hoeveel GPU je huurt, en de familie geeft je een echte knop om aan te draaien: 18 ms op een 2B tegenover 41 ms op een 35B-A3B, waarbij het grotere model kennis en redeneerruimte levert op GPQA, GSM8K, CRUXEval en MMLU die de kleine modellen niet hebben. Als je taak beperkt is en je labels vastliggen, is decider-2b de goedkopere machine. Als je taak vereist dat het model dingen weet, betaal je voor het mengsel.

Waar OrcaRouter past — en waar het niet past.

Noch Laya, noch Decider is een gehost model op OrcaRouter. Je downloadt de gewichten en draait ze zelf, en niets hier verandert dat. Wat wel verandert, is de andere helft van het patroon. Een getypeerd beslissingsmodel is bijna nooit de hele applicatie: iets moet het ticket lezen, de thread samenvatten of het antwoord opstellen dat de beslissing doorlaat. Die helft is een generatieve aanroep, en dat is de helft waarvoor OrcaRouter is gebouwd — meer dan 200 modellen achter één OpenAI-compatibele sleutel tegen de adviesprijs van de provider, doorgegeven met 0% opslag, zodat een prijsverlaging van een leverancier dezelfde dag op je factuur terechtkomt in plaats van bij de volgende contractverlenging. Als je een Laya-checkpoint fine-tunet op de outputs van een frontier-model, of routeert tussen decider-2b voor triage en een groot model voor de moeilijke 4%, betekent het houden van de generatieve kant op één endpoint dat de beslissingskant en de generatiekant geen twee contracten en twee SDK's nodig hebben. Automatische failover dekt het geval waarin het grote model het onderdeel is dat uitvalt.

Welke moet je kiezen?

Kies Laya als je invoer meertalig is, je weinig labels hebt, je latencybudget tientallen milliseconden op bescheiden hardware bedraagt, en je bereid bent om te fine-tunen — want dat zul je moeten. Kies Decider als je invoer Engels is, je wilt dat het model wat wereldkennis in de beslissing meeneemt, en je liever een modelgrootte kiest dan een trainingspipeline draait. Als je optiesets meer dan twintig labels bevatten, lees dan het Banking77-cijfer van Laya voordat je je vastlegt; als je invoer lange JSON-documenten zijn die je per positie adresseert, lees dan de vermelde beperking van Decider voordat je je vastlegt.

De vergelijking die dit daadwerkelijk zou beslechten — beide modellen op byte-identieke inputs, dezelfde prompts, dezelfde optievolgorde, dezelfde threshold-sweep — bestaat nog niet. Tot die er is, is de eerlijke positie dat Laya de betere kostencurve heeft en Decider het betere kalibratiebewijs, en dat beide vroeg genoeg zijn dat de eval die je op je eigen data bouwt meer waard zal zijn dan de gepubliceerde cijfers van welk van de twee projecten dan ook.