Jev vs Laya: 33 milliseconden op een T4, en een willekeurige baseline

De modelkaart van Laya bevat de zin die deze vergelijking beslecht, en die is geschreven door de mensen die Laya hebben gemaakt. "Laya is een snelle basis om te specialiseren, geen zero-shot beslissingsengine." Convai Innovations bracht Laya uit op 18 september 2026, drie dagen nadat TypeSafe AI Jev 1.13 (typesafe/jev-1.13) lanceerde, onder Apache 2.0, met gewichten op Hugging Face en een pip install laya-ingangspunt. Het beantwoordt getypeerde vragen in één enkele forward pass zonder token-voor-token-decodering, wat dezelfde architecturale gok is die Jev waagt. De kopclaim is een p50-latentie van 32,8 milliseconden per beslissing op een Tesla T4, gepresenteerd als ruwweg 7,8 keer sneller dan Jevs gepubliceerde p50 van 236–276 ms via zijn gehoste API. De claim is echt, en er worden ook twee verschillende dingen gemeten — een lokale GPU tegenover een netwerkaanroep — en het nauwkeurigheidsbeeld eronder is het deel dat zou moeten bepalen of je het downloadt. Zero-shot scoort Laya 0,362 op TypeSafe's benchmark voor getypeerde beslissingen. Willekeurig gokken scoort 0,318. De baseline van de meerderheidsklasse scoort 0,461. Laya staat out of the box dichter bij willekeurig gokken dan bij de triviale baseline. Wat nieuw is, is niet een van beide modellen, maar waar een van hen kan worden aangeroepen: op 24 september 2026 voegde OrcaRouter typesafe/jev-1.13 toe aan zijn catalogus — het model zelf is van TypeSafe, van 15 september — en dat is het enige in deze vergelijking dat onlangs is veranderd.

Wat Laya eigenlijk is

Laya wordt geleverd als twee checkpoints achter een ingebouwde router die elke invoer naar de juiste stuurt. Het Engelse checkpoint is ModernBERT-large met 421M parameters en een context van 512 tokens. De meertalige variant is mmBERT-base met 322M parameters en een venster van 1.024 tokens over meer dan 100 talen. Beide zijn non-autoregressief: één enkele forward pass retourneert het antwoord, dus er is geen decoderingslus, geen JSON om te parsen, en geen ruimte om tekst buiten het gedeclareerde type te genereren. Die laatste eigenschap is dezelfde structurele garantie die Jev biedt, langs een andere weg bereikt, en is echt waardevol voor iedereen die retry-logica heeft geschreven rond een model dat af en toe vergeet een accolade te sluiten.

Jev is de gesloten tegenhanger, en het onderscheid dat ertoe doet tussen de twee is wie het model draait, niet welke hoger scoort. Het eerste System One-model van TypeSafe AI, gelanceerd op 15 september 2026, wordt gehost — er zijn geen gewichten om te downloaden — en het is via ons routeerbaar als typesafe/jev-1.13 via POST /v1/systemone, niet-streamend, tegen een context van 65.536 tokens. Laya is de andere opzet: open Apache 2.0-gewichten die je zelf draait, op hardware die je al bezit, zonder enig endpoint in het pad. Jev neemt drie getypeerde primitieven — Choice uit een lijst die je aanlevert, Score op een geordende rubric, en Noul, een ja/nee-bewering met een gekalibreerde waarschijnlijkheid. Alle vragen worden parallel geëvalueerd tegen één gedeelde lezing van de toestand. De prijs is $0,042 per miljoen inputtokens, waarbij output tegen nul wordt gefactureerd, omdat er geen outputtokens zijn om te meten. De architectuur, het aantal parameters en de trainingscompute zijn niet bekendgemaakt, en TypeSafe heeft gezegd dat de details geheim worden gehouden, met mogelijk later een paper.

De latentieclaim, correct gemeten

Laya's 32,8 ms p50 op een T4 is een echt getal en een goed getal. De 7,8x-vergelijking met Jev's 236–276 ms is waar voorzichtigheid geboden is, en Laya's eigen kaart is opvallend eerlijk over waarom: de Jev-cijfers zijn door derden gepubliceerde cijfers die Convai nooit zelf heeft gemeten, en de vergelijking zet een lokale GPU-forward pass tegenover een gehoste API-aanroep die netwerk-round-trip en queuing omvat. Haal het netwerk eruit en de architectuurvergelijking gaat tussen twee single-pass-modellen, één met 421M parameters en één met een niet-openbaar gemaakte omvang die TypeSafe nooit heeft gepubliceerd.

Er is ook een batchinggetal dat de moeite waard is om te kennen: bij een batch van tien rapporteert Laya 7,2 ms per vraag. Dat is de vorm van het product. Laya is gebouwd om lokaal op grote schaal te draaien, en community-ports op het apparaat zelf, zoals laya-mlx, breiden dat uit naar Apple Silicon. Virale claims van "50x sneller dan Jev" worden niet ondersteund door de eigen gepubliceerde benchmarks van het project, en de eerlijke framing is een grote kloof tussen lokaal en cloud die deels architecturaal is en deels gewoon het verschil tussen jouw GPU en andermans API.

Wat de nauwkeurigheidscijfers zeggen, in volgorde

Dit is waar de vergelijking niet langer flatteus is, en het loont de moeite om dit in volgorde uiteen te zetten, want de volgorde doet ertoe.

• Zero-shot op de typed-decisions-benchmark van TypeSafe — Laya 0.362, random 0.318, majority-class 0.461, Jev 0.727. Laya zit boven kansniveau en onder de triviale baseline.

• Fijn afgestemd op de eigen trainingssplit van de benchmark — Laya 0,766 tegenover Jevs 0,727. Laya wint, en die overwinning komt van een checkpoint dat de trainingsgegevens van de benchmark heeft gezien, waardoor het een uitspraak is over fine-tuning, niet over het basismodel.

• Intentieclassificatie met Banking77, waarbij de optieset groot is — Laya 0,425 tegenover Jev's 0,870. Laya degradeert sterk zodra er meer dan ongeveer 20 opties zijn, en Jev's Choice-velden kunnen volgens de documentatie tot 255 opties aan voordat het tweefasige scoringspatroon nodig is.

• Kalibratie — Laya wordt geleverd met een gemiddelde verwachte kalibratiefout van 0,466, die pas naar 0,081 verbetert na temperatuurherfitting per vraagtype. Jev is getraind met een methode die TypeSafe RLCD noemt, Reinforcement Learning for Calibrated Decisions, en levert elk antwoord met een kansverdeling — hoewel TypeSafe gebruikers ook vertelt om drempelwaarden op hun eigen gelabelde data te valideren, en een onafhankelijke audit constateerde dat Jevs kalibratie sterk varieerde per taak.

Het patroon is ondubbelzinnig. Laya is een sterke basis om te fine-tunen en een zwakke zero-shot-beslissingsengine, en dat zegt het zelf. Jev is een sterke zero-shot-beslissingsengine waarvan de kalibratie nog per deployment moet worden gecontroleerd. Dat zijn verschillende producten met verschillende prijsstructuren, en de keuze tussen beide is vooral een kwestie van of je gelabelde data en een trainingsloop hebt.

De kostenberekening heeft niet dezelfde vorm als die van Jev.

Jev kost $0,042 per miljoen invoertokens, waarbij output gratis is, wat neerkomt op $42 per miljard, en een aanroep van maximale grootte binnen het gedocumenteerde budget van 64K tokens per aanvraag kost ruim minder dan een cent. Het getal dat gewoonlijk als ongeveer 32.000 tokens wordt genoemd, is het plafond voor de state plus de enkele langste vraag, niet het plafond voor de aanvraag — TypeSafe documenteert 64K tokens per aanvraag over de state en alle vragen samen, en onze eigen modelkaart voor typesafe/jev-1.13 vermeldt een context van 65.536 tokens. Every's onafhankelijke test voerde 777 beoordelingen uit over 37 documenten voor ongeveer een kwart cent.

Laya's kosten per aanroep zijn marginaal nul en in totaal niet nul, en dat totaal is niet klein. Een model met 421M parameters op een T4 is goedkoop om te draaien en kost je alsnog een GPU, en de fine-tuningstap die Laya concurrerend maakt, is waar de echte uitgaven zitten — de datalabeling, de trainingsrun, het evaluatieharnas, en het per vraagtype opnieuw afstellen van de temperatuur waardoor de kalibratiefout van 0,466 naar 0,081 gaat. Voor een vaste taxonomie die nooit verandert, is dat een eenmalige kostenpost die zich bij volume terugbetaalt. Voor een taxonomie die verschuift, is het een terugkerende, en wordt de zero-shotbaseline van Jev van 0,727 een veel betere deal.

Er is een derde kostenpost die gemakkelijk over het hoofd wordt gezien: Laya's Engelse checkpoint heeft een contextvenster van 512 tokens. Dat is geen beslissingsmodel met een klein contextbudget — het is een beslissingsmodel dat is toegesneden op een paragraaf. Jev's aanvraagbudget van 64K tokens is meer dan honderd keer groter, en zelfs dat ligt een orde van grootte onder de generatieve modellen waarmee beide qua prijs worden vergeleken. Als je state een supportthread is in plaats van een supportbericht, dan is het venster van geen van beide modellen de beperking waartegen je zou moeten optimaliseren.

De implementatiekwestie is het echte verschil

Het sterkste argument van Laya is niet latentie. Het is dat Apache 2.0-gewichten op Hugging Face betekenen dat de beslissing je infrastructuur nooit verlaat en dat de endpoint nooit een snelheidslimiet heeft. Voor een routeringsbeslissing op basis van een medisch dossier, een juridisch document of de accountgeschiedenis van een klant is dat geen voorkeur — het is de beslissende factor, en geen enkele gehoste endpoint, tegen welke prijs dan ook, wint dat argument. De eigen homepage van TypeSafe beschrijft Jev nog steeds als in early access, en de documentatie van de leverancier vermeldt dat de snelheidslimieten dynamisch worden aangepast en zonder kennisgeving kunnen veranderen.

Het tegenargument is wat je opgeeft. Jevs niet-onthulde grotere architectuur doet het werk dat Laya's 421M parameters niet kunnen: het zero-shot-verschil van 0,727 tegen 0,362 en het Banking77-verschil van 0,870 tegen 0,425 zijn beide maten voor hoeveel kennis er in het model zit voordat je het traint. Laya's antwoord is dat je die kennis zelf aanlevert via fine-tuning, en op een nauw afgebakend vast domein werkt dat antwoord — het fine-tuned resultaat van 0,766 is het bewijs.

Waar de beslissingslaag zich in een echte stack bevindt

Geen van beide modellen genereert tekst, dus geen van beide vormt het geheel van welke workflow dan ook. Het patroon waarvoor beide zijn ontworpen, bestaat uit twee modellen: een beslissingslaag die de getypeerde aanroep doet, en een generatief model dat het deel afhandelt waarvoor proza, code of een uitleg nodig is. Die splitsing betekende vroeger een tweede leverancierscontract, omdat de beslissingshelft niet iets was dat je met dezelfde sleutel als de generatieve helft kon aanroepen. Nu wel. Jev is via ons routeerbaar als typesafe/jev-1.13 via POST /v1/systemone — non-streaming, een context van 65.536 tokens, $0,042 per miljoen inputtokens, met output tegen nul gefactureerd. Ons eigen serveringsrecord van zeven dagen voor die route toont een p50 van 151 milliseconden, wat ons eigen verkeer op onze eigen hardware is en geen benchmark. Het is een netwerkmeting, en een andere dan de lokale forward pass van 32,8 ms hierboven. Laya blijft de andere opzet: open gewichten die je zelf draait, die wij niet hosten en ook niet hoeven te hosten. De generatieve helft van dat patroon is precies wat wij dekken: meer dan 200 modellen achter één OpenAI-compatibele sleutel tegen de lijstprijs van de aanbieder, doorgegeven met 0% opslag, zodat een prijswijziging van een leverancier dezelfde dag nog aan onze kant live staat. De tweemodelarchitectuur is testbaar zonder een tweede leverancierscontract — voor de beslissingshelft net zo goed als voor de generatieve helft — en met automatische failover wordt het generatieve pad geen single point of failure terwijl je beslist of de goedkope beslissingslaag goed genoeg gekalibreerd is om op te automatiseren.

Het vonnis

Als je een vaste, smalle taxonomie hebt, gelabelde voorbeelden, en een privacy- of latentievereiste die een gehoste API uitsluit, is Laya de beter verdedigbare keuze en de fine-tuned cijfers ondersteunen dat. Als je wilt dat de beslissing out-of-the-box werkt, als je optiesets meer dan twintig categorieën tellen, of als de toestand langer is dan een alinea, dan zegt de model card van Laya zelf je dat het niet het product voor die taak is — en de zero-shot-score van 0,362 tegenover een meerderheidsbaseline van 0,461 is het getal dat je in het oog moet houden wanneer iemand je het 7,8x-latentiecijfer voorhoudt.

Wat de twee gemeen hebben, is nuttiger dan wat hen scheidt. Beide elimineren de klasse van fouten die voortkomt uit uitvoeropmaak en doen niets aan de klasse die voortkomt uit beoordeling. Beide leveren waarschijnlijkheden, en geen van beide heeft een gepubliceerd betrouwbaarheidsdiagram dat je zonder controle kunt vertrouwen. Test de kalibratie op je eigen gelabelde gevallen voordat je op basis van een van beide automatiseert — de latentie is al gecommoditiseerd en de confidencewaarde is het deel dat per implementatie moet worden verdiend.