Jev vs Kev: een fine-tune van $95 die Jev verslaat bij supporttickets

Jared Palmer bracht Kev uit op 20 september 2026, vijf dagen nadat TypeSafe AI Jev lanceerde, en het belangrijke getal staat niet in de benchmarktabel. Het staat in de README: het hele ding kostte ongeveer $95 aan H100-tijd op Modal, plus drie cent aan Jev-API-aanroepen die werden gebruikt om evaluatiegegevens te genereren. Kev is Apache-2.0, zelf te hosten en komt in drie maten, gebouwd op de Qwen3.5-basisgewichten — ruwweg 0,8B, 4B en 9B — met een LoRA-adapter met rank 16 en een pointer-head die op een bevroren basis is vastgeschroefd in plaats van een beslissingsmodel vanaf nul. Het spiegelt de getypeerde beslissings-API van Jev exact: Choice, Score en Noul, nauw genoeg om compatibel te zijn met de eigen Python SDK van TypeSafe. Jev werd op zijn beurt op 15 september 2026 gelanceerd als het gesloten, gehoste System One-model van TypeSafe AI, geeft getypeerde antwoorden terug met gekalibreerd vertrouwen en helemaal geen tekst, en heeft nooit zijn architectuur, parameteraantal, trainingscompute of gewichten gepubliceerd. De vergelijking is daarom niet echt een modelvergelijking. Het is een test van hoeveel van de waarde van Jev overleeft wanneer die in een middag wordt gereproduceerd voor de prijs van een tweedehands laptop.

Wat de benchmarks eigenlijk zeggen

De hoofdboodschap is dat Kev dichtbij komt, en op één specifieke taak wint hij. Op Kevs vergrendelde nieuwe-bron-testset scoorde Kev-9B 0,837 tegen de 0,857 van Jev. Bij het routeren van supporttickets over 900 tickets — de scienthoon-set — scoorde Kev-9B 0,952 tegen de 0,897 van Jev, het enige gepubliceerde resultaat waarbij de open reproductie het model verslaat dat ze reproduceert. Kev gaat ook net voorop bij sommige logica-herkenningstaken. Op SemiF-beslissingssets, een gestructureerde set van 144 vragen, wint Jev met 0,965 tegen de 0,917 van Kev-9B.

Waar Kev verliest, verliest het kansloos. Nauwkeurigheid buiten het domein: Kev-8B op 79,6% tegen 85,7% voor Jev. MMLU: 70% tegen 90%. MMLU-Pro: 0,515 tegen 0,840. Datumrekenen op dagprecisie: 60% tegen 93%. Het patroon is consistent — Kev is competitief op smalle routing en classificatie waar de labelset klein is en het domein vastligt, en het valt uit elkaar bij alles waarvoor wereldkennis of rekenwerk in meerdere stappen nodig is, omdat een rank-16-adapter op een bevroren klein basismodel niet de plek is waar wereldkennis zetelt.

Al die cijfers komen uit Kevs eigen testharnas of van trackers van derden, en in Palmers README staat duidelijk dat het geen gecontroleerde vergelijking is — Jevs trainingsdata zijn niet bekendgemaakt, dus er valt er geen te maken. In de README staat ook dat er geen Jev-outputs voor training zijn gebruikt. Beide disclaimers zijn van het soort dat de cijfers betrouwbaarder maakt, niet minder: degene die de vergelijking publiceert, is degene die je vertelt wat die niet kan bewijzen.

Wat je voor $95 krijgt en wat je bij Jev voor geen enkele prijs kunt krijgen

De kostenvergelijking is waar de twee producten helemaal ophouden vergelijkbaar te zijn. Jev kost $0,042 per miljoen inputtokens, waarbij de output gratis is, wat goedkoop is op een manier die per aanroep echt moeilijk te overtreffen is — maar het is een gehoste API met vroege toegang en een wachtlijst, en TypeSafe heeft gezegd dat de snelheidslimieten zonder kennisgeving kunnen veranderen. Kev bestaat uit gewichten die je downloadt. De marginale kosten van de tien miljoenste classificatie zijn je eigen elektriciteit.

Daar volgen vier dingen uit, en geen ervan gaat over benchmarkscores.

• Er verlaat geen enkele data uw infrastructuur. Jev is een gehost endpoint; elke status die u erheen stuurt — het supportticket, de logregel, het medisch dossier — gaat naar TypeSafe. Kev draait op uw eigen GPU, wat voor gereguleerde workloads niet een voorkeur is maar de beslissende factor.

• Geen snelheidslimieten, geen wachtlijst, geen risico op deprecatie. De eigen documentatie van TypeSafe vermeldt dat snelheidslimieten zonder kennisgeving kunnen veranderen. Een lokale checkpoint kent een dergelijke clausule niet.

• Je kunt het fine-tunen. Kev is een basis om te specialiseren, en het LoRA-recept dat hem heeft voortgebracht is openbaar. Als je routerings-taxonomie 40 klassen heeft die geen enkel algemeen model goed aankan, kun je trainen op je eigen labels — precies wat Palmer deed, tegen een prijs van tientallen dollars in plaats van een ML-team.

• Het contextplafond is aan jou om te wijzigen. Jevs gedocumenteerde verzoekbudget is ongeveer 32.000 tokens en Choice-velden zijn beperkt tot 255 opties. Kev erft het venster van Qwen3.5, dat veel groter is, en de optielimiet is een implementatiedetail van je eigen servingstack in plaats van een leverancierslimiet.

Wat Jev nog heeft dat Kev niet heeft

De calibratieclaim is degene die niet netjes overdraagt, en het is de kern van TypeSafe's pitch. Jev wordt getraind met een methode die TypeSafe RLCD noemt — Reinforcement Learning for Calibrated Decisions — die eerder optimaliseert voor een eerlijke betrouwbaarheidswaarde dan voor een antwoord dat de voorkeur geniet. Elk antwoord van Jev wordt geleverd met een kansverdeling over de opties, zodat je code drempels kan instellen: automatisch handelen in de bovenste band, markeren in het midden, escaleren onderaan.

Kev produceert dezelfde getypeerde vorm en dezelfde kansuitvoer, omdat de API bewust compatibel is. Of die kansen gekalibreerd zijn, is een andere vraag, en het eerlijke antwoord is dat niemand een betrouwbaarheidsdiagram voor een van beide modellen heeft gepubliceerd. Een afzonderlijke kalibratie-audit meldde dat Jev 44,7% nauwkeurigheid scoorde met een verwachte kalibratiefout van 0,325 op een prioriteitstaak met verborgen beleid, wat erop wijst dat kalibratie bij Jev sterk per taak varieert in plaats van een universele eigenschap te zijn — en TypeSafe zegt zelf tegen gebruikers dat ze vertrouwensdrempels moeten testen aan de hand van hun eigen gelabelde voorbeelden in plaats van het gepubliceerde gedrag te vertrouwen.

Het andere dat Jev heeft, is dat het niet op Qwen3.5 is getraind. Een 9B-model met een rank-16-adapter heeft een kennisplafond, en het MMLU-Pro-verschil van 0,515 tegenover 0,840 maakt dat plafond zichtbaar. Als je routeringsbeslissing af en toe vereist dat je weet wat iets is, verricht Jevs grotere, niet-bekendgemaakte architectuur werk dat Kevs adapter niet kan.

Latentie en de deploymentvorm

De gedocumenteerde end-to-end-latentie van Jev is 70–500 ms, tegenover 3–329 seconden voor frontier-LLM-aanroepen in de eigen vergelijking van TypeSafe, en het toevoegen van vragen aan een aanroep verandert daar nauwelijks iets aan, omdat elke vraag parallel wordt geëvalueerd tegen één gedeelde uitlezing van de state. Kev-9B op een H100 zal voor één enkele forward pass in dezelfde orde van grootte liggen, maar de vergelijking is in geen van beide richtingen een appels-met-appelsvergelijking: een zelfgehoste 9B op een gedeelde GPU onder belasting heeft niet dezelfde latentie als een gehost endpoint, en een gehost endpoint is niet hetzelfde als een machine in je eigen rack. Wat zonder voorbehoud gezegd kan worden, is dat beide snel genoeg zijn voor gebruik per beurt in een agent-loop, en dat Kevs latentie een functie is van hardware die je zelf beheert in plaats van een serviceniveau dat je wordt beloofd.

De eerlijke kijk op de reproductie

Het feit dat Kev überhaupt bestaat, is bewijs over Jev, en het is de moeite waard om te benoemen. Een gesloten model waarvan het gedrag in vijf dagen voor $95 kan worden benaderd, door één persoon, op openbare basisgewichten, zegt je iets over hoeveel van zijn voordeel architectuur is en hoeveel trainingsdata en serving. Het volgt niet dat Jev gemakkelijk te bouwen is — het API-oppervlak is gemakkelijk te kopiëren, de kalibratie niet. Maar het betekent wel dat de slotgracht niet de interface is, en iedereen die Jev evalueert voor een productiepad moet rekening houden met de mogelijkheid dat een fine-tune van een open basis ze het grootste deel van de weg brengt voor een fractie van de commitment.

Wat ook het argument is om nog geen productiepad op een van beide te wedden. Als je Jev aan het evalueren bent, is de verstandige houding om het te proberen zonder je eraan te binden — en OrcaRouter serveert Jev niet, omdat TypeSafe's model in early access is en zijn eigen requestvorm hanteert. Wat wij wel dekken is de generatieve helft van de workflow waarin deze beslissingsmodellen zich bevinden: 200+ modellen achter één OpenAI-compatibele key tegen de lijstprijs van de provider, doorgegeven met 0% opslag, met automatische failover. Een tweemodelarchitectuur waarbij een goedkope beslissingslaag het verkeer sorteert en een generatief model de rest afhandelt, is aan onze kant testbaar zonder een tweede leverancierscontract, en als de beslissingscomponent slecht gekalibreerd blijkt op jouw data, is het failoverpad wat voorkomt dat dit een incident wordt.

Het vonnis

Als je beslissingstaak smal, domeingebonden, grootschalig en privacygevoelig is, is Kev vandaag de meer verdedigbare keuze, en dat is niet eens een close call: je bezit de gewichten, je beheert het datapad, je kunt fine-tunen op je eigen labels, en bij het routeren van supporttickets verslaat de 9B-checkpoint Jev al op zijn eigen gepubliceerde cijfers. Als je beslissingstaak wereldkennis, rekenwerk in meerdere stappen of een betrouwbaarheidswaarde vereist waarop je wilt automatiseren, doen Jevs grotere, niet-bekendgemaakte model en zijn RLCD-training echt werk, en Kevs adapter is voor geen van beide een vervanging.

Het enige wat geen van beide vergelijkingen beslecht, is kalibratie, want voor geen van beide modellen is een betrouwbaarheidsdiagram gepubliceerd. Test dat op je eigen gelabelde cases voordat je met een van beide gaat automatiseren — de confidencewaarde is het deel van beide producten dat per implementatie moet worden verdiend, en de snelheid is het deel dat al gecommoditiseerd is.