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 op te specialiseren, geen zero-shot beslissingsengine." Convai Innovations bracht Laya uit op 18 september 2026, drie dagen nadat TypeSafe AI Jev lanceerde, onder Apache 2.0, met gewichten op Hugging Face en een pip install laya als instappunt. Het beantwoordt getypeerde vragen in één enkele forward pass zonder token-voor-token-decodering, wat dezelfde architectonische 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 236–276 ms p50 via zijn gehoste API. De claim is echt en meet tegelijkertijd twee verschillende dingen — een lokale GPU tegen een netwerkaanroep — en het accuratesseplaatje daaronder is het deel dat zou moeten bepalen of je het downloadt. Zero-shot scoort Laya 0,362 op de getypeerde-beslissingenbenchmark van TypeSafe. Willekeurig gokken scoort 0,318. De meerderheidsklasse-baseline scoort 0,461. Laya zit out of the box dichter bij willekeurig gokken dan bij de triviale baseline.

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: het eerste System One-model van TypeSafe AI, gelanceerd op 15 september 2026, gehost en met vroege toegang, met drie getypeerde primitieven — Choice uit een lijst die u 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 staat, output is gratis omdat er geen outputtokens zijn, en input kost $0,042 per miljoen tokens. De architectuur, het aantal parameters en de trainingscompute worden niet bekendgemaakt, en TypeSafe heeft gezegd dat de details onder de pet 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 de uitvoer gratis is, wat neerkomt op $42 per miljard, en een aanroep van maximale omvang bij het gedocumenteerde budget van ~32.000 tokens per verzoek kost ruim minder dan een cent. De onafhankelijke test van Every kwam voor 777 beoordelingen over 37 documenten uit op 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 op een alinea is afgestemd. Jevs aanvraagbudget van ongeveer 32.000 tokens is zestig keer groter, en zelfs dat ligt een orde van grootte onder de generatieve modellen waartegen beide qua prijs worden afgezet. Als jouw status 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 nooit uw infrastructuur verlaat en dat het endpoint nooit een rate limit 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 enkel gehost endpoint wint dat argument, tegen welke prijs dan ook. TypeSafe's Jev is in early access en kent een wachtlijst, en de eigen documentatie merkt op dat rate limits 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 een workflow. Het patroon waarvoor beide zijn ontworpen, bestaat uit twee modellen: een beslislaag die de getypeerde aanroep doet, en een generatief model dat het deel afhandelt dat proza, code of een uitleg nodig heeft. OrcaRouter levert Jev of Laya niet — Jev is het early-access-endpoint van TypeSafe en Laya zijn gewichten die je zelf draait — maar de generatieve helft van dat patroon is precies wat wij dekken: 200+ modellen achter één OpenAI-compatibele sleutel tegen leverancierslijstprijs, doorgegeven met 0% opslag, zodat een prijswijziging van een leverancier dezelfde dag nog live is aan onze kant. De tweemodelarchitectuur is testbaar zonder een tweede leverancierscontract, en met automatische failover wordt het generatieve pad geen single point of failure terwijl je besluit of de goedkope beslislaag goed genoeg gekalibreerd is om je automatisering op te baseren.

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.