Laya vs Nimble: contrastieve data versus een snellere encoder

Laya en Nimble zijn de twee open-weight beslissingsmodellen waarvan de auteurs het meest hebben gedaan om uit te leggen hoe ze zijn gebouwd, en hun uitleg is het niet eens over waar de moeilijkheid ligt. Convai Innovations bracht Laya op 18 september 2026 uit onder Apache 2.0 — een Engelstalig ModernBERT-large-checkpoint van 421M, een meertalig mmBERT-base-checkpoint van 322M dat meer dan 100 talen dekt, een submilliseconde-router tussen beide, en een gepubliceerde p50 van 32,8 ms per beslissing op een Tesla T4. Bespoke Labs bouwde Nimble als een LoRA-finetune op Qwen3.5-9B, onder Apache 2.0, en beschrijft het als "de open-source Jev" — geïnspireerd door Jev van TypeSafe AI, maar zonder de gewichten, de architectuur of een distillatie van de outputs ervan te gebruiken. Convai's antwoord op het nauwkeurigheidsprobleem is snelheid en een fine-tunbare basis. Bespoke's antwoord is de trainingsdata. Dat verschil is meer aandacht waard dan de nauwkeurigheidskloof van drie punten die in de hoofdtabellen opduikt.

De claim die elk project eigenlijk maakt

De claim van Laya is architectonisch. Het model is niet-autoregressief in strikte zin — een bidirectionele encoder, geen decoderingslus, geen JSON om te parsen, geen ruimte om tekst buiten het gedeclareerde type te genereren. Die structurele garantie is dezelfde die Jev biedt, maar vanuit een andere richting bereikt, en ze is echt waardevol voor iedereen die retry-logica heeft geschreven rond een model dat af en toe vergeet een accolade te sluiten. De keerzijde is dat een encoder van 421M met een venster van 512 tokens en zonder generatieve pretraining erachter niet erg veel weet. Convai zegt dat op de modelkaart: "Laya is een snelle basis om te specialiseren, geen zero-shot beslissingsengine."

De claim van Nimble gaat over de data. De methode van Bespoke is contrastieve curatie, aangepast van het eerdere Bespoke-MiniCheck-werk van het team: schrijf twee bijna identieke voorbeelden die verschillen in één "focusfeit", zodat het juiste label omklapt. De pipeline heeft vier genoemde stappen — controleer of de beslissingsregels echt tot verschillende antwoorden zouden kunnen leiden, bouw het paar door maximaal acht woorden te veranderen, verifieer beide voorbeelden met aparte modelaanroepen plus een verwijder-elke-zin-controle, en genereer labels in code terwijl alleen de paren behouden blijven waarvan de labels daadwerkelijk verschillen. Het doel is niet meer voorbeelden maar scherpere: dwing het model te leren welk bewijs de beslissing zou moeten veranderen. Dat is een andere theorie over waarom kleine beslissingsmodellen falen, en het is een interessantere dan nog een accuratessecijfer.

Wat de gepubliceerde cijfers daadwerkelijk ondersteunen

Nimble rapporteert 90,12% overeenstemming met referentielabels op 324 achtergehouden samples, tegenover 93,21% voor Jev, 66,36% voor de niet-afgestemde Qwen3.5-9B-basis, en 84,88% voor een niet-afgestemde 27B Qwen3.8. Het rapporteert ongeveer 106 ms mediaan op een H100 en 444 ms mediaan op een M5 Pro met 64 GB. Dat zijn Bespoke's eigen harness-cijfers. De evaluatieset van 324 samples is het onderdeel dat je zorgvuldig moet wegen, en het project zegt zelf waarom: de samples bestrijken zes van de tien trainingsbronfamilies, ze zijn gegenereerd en gevalideerd door modellen zonder menselijke beoordeling, en generalisatie naar ongeziene categorieën is daarom onbewezen. Wanneer een model wordt getraind met een datacuratatiemethode en vervolgens wordt geëvalueerd op een achtergehouden split van diezelfde gecureerde distributie, is het nauwkeurigheidscijfer een uitspraak over de interne consistentie van de methode, niet over jouw verkeer.

De cijfers van Laya komen van de andere kant. Op de typed-decisions-benchmark van TypeSafe scoort het 0,362 zero-shot — willekeurig is 0,318, de baseline voor de meerderheidsklasse is 0,461 — en 0,766 wanneer het wordt gefinetuned op de eigen trainingssplit van de benchmark. Op Banking77, met 77 labels, scoort het 0,425 tegenover de 0,870 van Jev, wat de scherpste illustratie is van zijn plafond bij veel opties. Op AG News met vier labels scoort het 0,950 tegenover de 0,910 van Jev; op DAIR Emotion met zes labels 0,595 tegenover 0,480. De kalibratiefout is bij aflevering 0,466 en daalt naar 0,081 na het opnieuw fitten van de temperatuur per vraagtype. Een test door een derde partij van 100 urgentieberichten uit Mars-base kwam voor Jev uit op 100/100 en voor Laya op 53/100. En in een onafhankelijke evaluatie van agent-tool-calls behaalde Laya 100% weigeringsrecall bij gevaarlijke calls, maar alleen door alles te markeren, wat een precisiefout is die zich voordoet als een veiligheidswinst.

Zet de twee sets getallen naast elkaar, en de eerlijke interpretatie is dat ze op verschillende zaken zijn gemeten. Nimble's 90,12% is overeenstemming met zijn eigen gecureerde referentielabels. Laya's 0,362 is een benchmark die het niet zelf heeft gebouwd. Geen van beide getallen is overdraagbaar.

Calibratie: het enige punt waarop beide projecten ongebruikelijk openhartig zijn

Dit is waar de twee projecten qua geest het dichtst bij elkaar staan en qua resultaat het verst van elkaar verwijderd zijn.

Bespoke's README waarschuwt expliciet dat de waarschijnlijkheden van Nimble softmax-genormaliseerde logits over de aangeleverde kandidaten zijn, geen gekalibreerde correctheidspercentages — een 0,9 betekent niet 90% correct. Het raadt aan een optie "geen van bovenstaande" toe te voegen, want als het juiste antwoord niet onder de kandidaten zit, wint een van hen alsnog. Op een nieuwere evaluatie met 3.880 records over 13 subsets had Jev een lagere gerapporteerde kalibratiefout in 11 van de 13 subsets en een lagere Brier-score in 10 van de 13. Dus vergelijkbare labelovereenstemming impliceert niet vergelijkbare waarschijnlijkheidskwaliteit, en dat zegt Bespoke ook.

De openbaarmaking van Convai is het spiegelbeeld: de verwachte kalibratiefout van 0,466 staat op de kaart, naast de 0,081 die temperatuurherfitting per vraagtype oplevert. Geen van beide projecten levert een model waarvan je zonder extra werk op de betrouwbaarheid kunt afgaan. Beide vertellen je dat zwart-op-wit. Als je een betrouwbaarheidsdrempel bouwt — automatisch vrijgeven boven 0,95, escaleren onder 0,7 — dan vertelt de documentatie van beide auteurs je hetzelfde: fit de drempel eerst op je eigen gelabelde data.

De vergelijking, dimensie voor dimensie

• Backbone — Laya: ModernBERT-large 421M-encoder, bidirectioneel, geen generatieve pretraining. Nimble: Qwen3.5-9B met een LoRA-finetune, generatieve basis behouden.

• Talen — Laya: 100+ via het 322M meertalige checkpoint. Nimble: Engels.

• Promptbudget — Laya: 512 tokens Engels, 1.024 meertalig. Nimble: 2.048 tokens maximaal per prompt, alleen platte schema's, enums beperkt tot 26 opties per veld.

• Snelheid — Laya: 32,8 ms p50 op een T4, 7,2 ms per vraag in batches van 10. Nimble: ongeveer 106 ms mediaan op een H100, 444 ms op een M5 Pro 64GB.

• Hardware — Laya: CPU, CUDA en Apple MPS; minder dan een gigabyte aan resident geheugen op de MLX-port. Nimble: BF16 CUDA-GPU voor de genoemde cijfers, met ondersteuning voor MLX- en CUDA-paden.

• Gerapporteerde nauwkeurigheid — Laya: 0,362 zero-shot, 0,766 fine-tuned, 0,425 op Banking77. Nimble: 90,12% op 324 gecureerde, achtergehouden voorbeelden tegenover de 93,21% van Jev.

• Methode — Laya: architectuur eerst, fine-tunen per deployment. Nimble: contrastieve datacuratie, gepubliceerd als een recept.

• Licentie — Apache 2.0 voor beide.

Twee beperkingen in die lijst verdienen het om twee keer te worden gelezen voordat je je vastlegt. De limiet van 26 opties per enum en het promptplafond van 2.048 tokens bij Nimble zijn harde schemalimieten, geen prestatievermindering — als je taxonomie veertig labels heeft of je prompt een lang document bevat, is Nimble het verkeerde hulpmiddel, ongeacht de nauwkeurigheid. En Nimble scoort elk veld onafhankelijk, dus elke consistentieregel tussen velden — 'als A waar is, dan moet B onwaar zijn' — moet in je code staan, niet in het model.

Waarom het datarecept het draagbaardere artefact is

Hier is het argument voor Nimble dat de nauwkeurigheidstabellen missen. Bespoke heeft de curatiepijplijn gepubliceerd, niet alleen de gewichten. Als je beslissingsprobleem een vaste taxonomie heeft en je de regels kunt opschrijven, is de contrastieve methode iets dat je op je eigen data kunt draaien met je eigen focusfeiten, bovenop welk basismodel je ook verkiest. De 9B LoRA is evenzeer een demonstratie van de methode als een product.

De draagbaarheid van Laya is anders en complementair. Omdat het klein is, omdat het op CPU draait en omdat de ONNX- en MLX-porten bestaan, is Laya het model dat je kunt onderbrengen in een proces zonder GPU en zonder netwerk. In een benchmark van een derde partij voor browseragents voltooide Laya 0 van de 50 taken en verklaarde het in 33 pogingen voortijdig voltooid — maar de auteurs van de benchmark merken op dat het was getraind voor beoordelingswerk zoals supporttickets, facturen en het beoordelen van agent-traces, niet voor navigatie. Lees dat resultaat als een afbakening van de scope, niet als een eindoordeel, en het is consistent met de framing van beide projecten: dit zijn componenten voor een specifieke klasse van beslissingen, niet voor algemene agents.

Noch Laya, noch Nimble is een gehost model op OrcaRouter. Beide zijn gewichten die je zelf draait, en niets in dit stuk mag worden gelezen als een bewering dat wij ze hosten. De reden dat het routingproduct überhaupt ter sprake komt, is dezelfde reden waarom het in elke beslissingsmodel-architectuur ter sprake komt: het beslissingsmodel beantwoordt één aanroep, en de applicatie eromheen heeft nog steeds lopende tekst nodig. Een pipeline die Nimble gebruikt om te beoordelen of een concept conform is en Laya om de uitzondering te routeren, heeft nog steeds een generatief model nodig om het concept te schrijven. Die generatieve helft op één OpenAI-compatibel endpoint houden — 200+ modellen, de lijstprijs van de provider doorgegeven met 0% opslag, zodat een prijsverlaging van een leverancier dezelfde dag live is, automatische failover tussen providers — betekent dat de beslissingslaag kan worden vervangen zonder het contract van de generatieve laag aan te raken.

Het oordeel, en het experiment dat het zou veranderen

Kies Nimble als je taxonomie vast en smal is, je invoer Engelstalig en kort is, je een GPU hebt en je net zo veel om het datarecept geeft als om het model. Kies Laya als je meertalige invoer nodig hebt, een budget van minder dan 40 ms, of een proces zonder enige GPU — en begroot de fine-tuning vanaf het begin mee, want het zero-shot-checkpoint zit onder de triviale baseline en dat staat ook op de modelkaart.

Het experiment dat dit zou beslechten is een gepaarde evaluatie op echte traffic: dezelfde inputs, dezelfde optiesets, dezelfde betrouwbaarheidsdrempels, geëvalueerd aan de hand van menselijke labels, met voor elk een betrouwbaarheidsdiagram. De eigen documentatie van Nimble waarschuwt dat de waarschijnlijkheden geen correctheidspercentages zijn en de kaart van Laya rapporteert een calibratiefout van 0,466 vóór herfitten, dus dat diagram is het artefact dat je daadwerkelijk zou vertellen welk model je in productie moet nemen. Geen van beide projecten heeft er een gepubliceerd, en geen van beide heeft die van het andere gepubliceerd. Bouw het op je eigen data voordat je een drempel instelt.