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 geheel 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 op basis van de open Qwe​n3.5-basisgewichten — ruwweg 0,8B, 4B en 9B — met een rank-16 LoRA-adapter en een pointer-head die op een bevroren basis zijn vastgeschroefd in plaats van een beslissingsmodel vanaf nul. Het spiegelt Jev's getypeerde-beslissings-API exact: Choice, Score en Noul, dicht genoeg bij om compatibel te zijn met TypeSafe's eigen Python-SDK. Jev van zijn kant werd op 15 september 2026 gelanceerd als TypeSafe AI's gesloten, gehoste System One-model, 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 Jev's waarde het overleeft om in een middag te worden gereproduceerd voor de prijs van een gebruikte laptop. Geen van beide modellen is nieuw — Jev 1.13 (typesafe/jev-1.13) is de release van 15 september en Kev volgde vijf dagen later — maar één ding aan deze vergelijking is recent veranderd: op 24 september 2026 voegde OrcaRouter Jev 1.13 toe aan zijn catalogus, zodat de beslissingshelft van het paar nu op dezelfde sleutel antwoordt als de generatieve helft in plaats van alleen via het eigen endpoint van de leverancier.

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 niet meer te vergelijken zijn. Jev kost $0,042 per miljoen inputtokens, waarbij output gratis is — het tarief op de eigen prijslijst van TypeSafe, en het tarief dat onze modelkaart voor typesafe/jev-1.13 vermeldt — wat goedkoop is op een manier die per aanroep echt moeilijk te verslaan is. Het is een gehoste API, en de eigen homepage van TypeSafe beschrijft het nog steeds als in early access; dat is de eigen formulering van de leverancier, en de wachtlijst die er vroeger achter zat, is verdwenen — TypeSafe heeft die op 21 september 2026 verwijderd, en wat de modeldocumentatie nu in plaats daarvan publiceert, is de serveerlimiet zelf: 100.000 tokens per seconde en 40 verzoeken per seconde per account, dynamisch aangepast en zonder kennisgeving wijzigbaar. Kev is 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 van derden, geen afgeschermde toegang, geen deprecatierisico. De eigen documentatie van TypeSafe behoudt zich het recht voor om die gepubliceerde limieten op elk moment aan te passen, wat een wezenlijk verschil is met een checkpoint op je eigen schijf. Een lokaal checkpoint kent geen dergelijke clausule.

• 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. Het gedocumenteerde aanvraagbudget van Jev is 64K tokens, waarvan 32.000 de status plus de langste afzonderlijke vraag is in plaats van een aparte toewijzing, en Choice-velden zijn beperkt tot 255 opties. Kev erft het venster van Qwe​n3.5, dat veel groter is, en de optielimiet is een implementatiedetail van je eigen serving-stack 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 Qwe​n3.5 is getraind. Een 9B-model met een rank-16-adapter heeft een kennisplafond, en de MMLU-Pro-kloof van 0,515 tegenover 0,840 is dat plafond in zichtbare vorm. Als je routeringsbeslissing af en toe vereist dat je weet wat iets is, dan doet Jevs grotere, niet bekendgemaakte architectuur werk dat Kevs adapter niet kan.

Latentie en de deploymentvorm

De gedocumenteerde end-to-endlatentie 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 toestand. Er is één gemeten tegenhanger van die leveranciersclaim, en die is van ons en niet van TypeSafe: over de zeven dagen dat onze modelkaart voor typesafe/jev-1.13 het model al sinds 24 september 2026 serveert, duurde de mediane aanvraag 151 ms en het 95e percentiel 247 ms. Dat is een servingrecord van één route, geen benchmark. 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 appels met appels: 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 kan worden gezegd, is dat beide snel genoeg zijn voor gebruik per beurt in een agent-loop, en dat de latentie van Kev een functie is van hardware die je 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 zetten. Als je Jev aan het evalueren bent, is de verstandige houding om het te proberen zonder je eraan te binden — en sinds 24 september 2026 is dat iets wat je kunt doen op onze sleutel: OrcaRouter serveert Jev 1.13 als typesafe/jev-1.13, aangeroepen via hetzelfde POST /v1/systemone endpoint en dezelfde niet-streaming requestvorm die het overal gebruikt, tegen een context van 65.536 tokens voor $0,042 per miljoen inputtokens, met output gefactureerd tegen nul. De beslissingslaag en de generatieve laag zitten nu op één account: 200+ modellen achter één OpenAI-compatibele sleutel tegen de lijstprijs van de provider, doorgegeven met 0% opslag, met automatische failover. Een twee-modelarchitectuur 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 failover-pad dat 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.