
Jev weigert ook maar één woord te schrijven: wat het beslissingsmodel van TypeSafe AI doet, en wat de audits sindsdien hebben gevonden
- OrcaNIEUWOrcaCyber: Hy4 Flash Abliterated / Uncensored2026-11-18$0.07 / $0.28 per 1 mln tokens · 141 tok/s
- tencentNIEUWTencent: Hy4 Flash2026-11-16$0.02 / $0.07 per 1 mln tokens · 175 tok/s
- GoogleNIEUWGoogle: Gemini 4 Carbon2026-11-10$2.00 / $10.00 per 1 mln tokens · 89 tok/s
- AnthropicNIEUWAnthropic: Claude Fable 5.22026-11-09$8.00 / $40.00 per 1 mln tokens · 97 tok/s
- orcaNIEUWOrca: OrcaC2 1.02026-11-079 tok/s
- OrcaOrcaCyber: GLM 5.3 Abliterated / Uncensored2026-11-04$3.00 / $5.00 per 1 mln tokens · 88 tok/s
- OrcaOrcaCyber: Hy4 Abliterated / Uncensored2026-11-04$0.80 / $1.60 per 1 mln tokens · 134 tok/s
- OrcaOrcaCyber: Kimi K3.1 Pro Abliterated / Uncensored2026-11-04$2.00 / $5.00 per 1 mln tokens · 85 tok/s
- tencentTencent: Hy42026-11-04$0.83 / $2.50 per 1 mln tokens · 94 tok/s
- OrcaOrcaCyber: MiniMax M3.1 Flash Abliterated / Uncensored2026-10-29$0.80 / $1.60 per 1 mln tokens · 120 tok/s
- OrcaOrcaCyber: GLM 5.3 Flash Abliterated / Uncensored2026-10-27$0.80 / $1.60 per 1 mln tokens · 68 tok/s
- OrcaOrcaCyber: Qwen3.8 Flash Next Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1 mln tokens · 93 tok/s
- OrcaOrcaCyber: MiMo V2.6 Flash Abliterated / Uncensored2026-10-26$0.80 / $1.60 per 1 mln tokens · 44 tok/s
- MoonshotMoonshotAI: Kimi K3.1 Pro2026-10-2447Intelligentie
- OrcaOrcaCyber: DeepSeek V4.1 Flash Abliterated / Uncensored2026-10-23$0.80 / $1.60 per 1 mln tokens · 196 tok/s
- minimaxMiniMax: M3.1 Flash2026-10-1929Intelligentie
- OrcaOrca: OrcaCyber Ultra 1.02026-10-17$5.00 / $10.00 per 1 mln tokens · 115 tok/s
- deepseekDeepSeek: DeepSeek V4.1 Flash 10172026-10-1733Intelligentie
- DeepSeekDeepSeek: DeepSeek V4.1 Flash 09102026-10-17$0.15 / $0.60 per 1 mln tokens
- DeepSeekDeepSeek: DeepSeek V4.1 Flash2026-10-1740Intelligentie
Jev 1.13 (typesafe/jev-1.13) is het eerste model van TypeSafe AI dat een lezer waarschijnlijk eerder via een kostentabel dan via een chatbox tegenkomt, want er is geen chatbox. Gelanceerd op 15 september 2026 door Diogo Almeida — medeauteur van de InstructGPT-paper, het werk waardoor ChatGPT zich als een assistent ging gedragen — genereert Jev helemaal geen tekst. Het neemt een stukje toestand (een e-mail, een logregel, een supportticket, een JSON-blob met spelcoördinaten) plus een lijst met getypeerde vragen, en retourneert getypeerde antwoorden: een keuze uit een set die je hebt aangeleverd, een score op een rubric, of een ja/nee-waarschijnlijkheid, elk met een eigen betrouwbaarheidswaarde. Geen proza, geen code, geen uitleg. De pitch van TypeSafe is dat deze beperktheid het product is, omdat het snelheid en prijs oplevert die een generatief model niet kan evenaren — 20 tot 200 keer sneller en 40 tot 400 keer goedkoper dan "vergelijkbare LLM's" in de eigen lanceringsmaterialen van het bedrijf, tegen $0,042 per miljoen inputtokens, waarbij output tegen nul wordt gefactureerd. Het is algemeen beschikbaar sinds 21 september 2026, toen TypeSafe de wachtlijst opruimde en nieuwe accounts $5 aan tegoed begon te geven — de eigen omrekening van de leverancier, ongeveer 120 miljoen inputtokens waard tegen listprijs. Het model is ouder dan het nieuws in dit stuk. OrcaRouter voegde typesafe/jev-1.13 op 24 september 2026 toe aan zijn catalogus en routeert het nu op dezelfde key als de generatieve modellen waarnaast het is ontworpen, en dat is de verandering die vandaag het weten waard is. Het tweede waar deze pagina nu rekening mee moet houden, is niet van TypeSafe: RSI-Jev, een open project van een derde partij dat Jev-achtige System One-beslissingsmodellen bouwt, waarvan de huidige release de 4B RSI-Jev v6.0-VL is, gedateerd 6 oktober 2026. Het kopieert Jevs wire-formaat bewust, en de eigen licentieregel zegt ronduit dat het niet is gelieerd aan TypeSafe AI — het is niet TypeSafe's Jev, niet TypeSafe's gewichten, en niet hetzelfde model onder een kortere naam. De laatste sectie van dit stuk staat waar die hoort, want die is het scherpste beschikbare antwoord op de vraag hoeveel van Jevs positie een slotgracht is.
Het nuttigste getal dat in de eerste 48 uur werd gepubliceerd, is er niet een van. Het komt van Every, waar het hoofd evaluaties Jev losliet op 27 gepubliceerde Every-artikelen plus 10 tegenhangers in AI-stijl, en alle 37 documenten tegelijk 21 vragen stelde: 777 beoordelingen in minder dan 0,7 seconde, voor ongeveer een kwart cent. Een tweede test, uitgevoerd door de CEO van Every, zette 12 synthetische passages — zes schone, zes met opzettelijk ingebouwde defecten — tegenover vier schrijfcontroles. Jev kwam uit op een mediaan van 0,35 seconde per passage, tegenover 8,83 seconden voor Claude Fable 5.1 bij hoge inspanning: ongeveer 25 keer sneller voor ongeveer 1/580 van de kosten. Het ving zes van de zeven ingebouwde defecten. Claude Fable 5.1 ving ze alle zeven. Het oordeel van Every was "goed maar niet perfect", en dat is de eerlijke samenvatting in één zin van Jev op basis van de eerste onafhankelijke test die werd gepubliceerd — de beweringen over snelheid en kosten houden stand bij contact met een derde partij, de nauwkeurigheidsclaim zit een tandje onder de frontier, en de steekproef is klein genoeg dat niemand er een productieconclusie uit had moeten trekken — een kloof die latere evaluaties gedeeltelijk hebben gedicht, in beide richtingen.
Een opmerking over met wat voor soort bewijs dit stuk werkt, omdat de bewijsniveaus snel zijn verschoven voor een zo nieuw model. Jev is echt en aanroepbaar: er is een gedocumenteerd endpoint, een Python SDK, een modelalias en een gepubliceerde prijs. De lancering is door de leverancier aangekondigd, niet gelekt, en niemand tast in het duister over of het bestaat. Maar elke prestatieclaim waarmee TypeSafe vooroploopt is van TypeSafe zelf, de architectuur is niet gepubliceerd, de gewichten zijn niet vrijgegeven, en het benchmarkdashboard achter de 20-200x-kop is een reeks interne workflow-evaluaties in plaats van een openbare ranglijst. Onafhankelijk testen is niet langer het ontbrekende stuk dat het op de dag van de lancering was — er zijn nu minstens drie afzonderlijke externe evaluaties, waaronder één vooraf geregistreerde run en één studie die specifiek is opgezet om Jev te testen op invoer die het niet had kunnen zien — en ze zijn het met de leverancier eens over snelheid, maar vertellen een gecompliceerder verhaal over nauwkeurigheid en kalibratie. Dit artikel houdt leverancierscijfers, onafhankelijke cijfers en open vragen zichtbaar gescheiden in plaats van ze te middelen tot een consensus die niet bestaat.
Wat TypeSafe daadwerkelijk heeft uitgebracht
Jev is de eerste van wat TypeSafe System One-modellen noemt — de naam is ontleend aan de snelle, intuïtieve helft van Daniel Kahnemans cognitie, in tegenstelling tot de langzamere, weloverwogen modus die chatbots nabootsen. Het contrast dat TypeSafe trekt, is met het standaardpatroon waarbij een tekstgenerator wordt gedwongen gestructureerde output te produceren en die tekst vervolgens weer wordt geparseerd naar iets waarop code kan vertrouwen. Jev slaat de tekst volledig over. In de eigen documentatie van TypeSafe staat het onomwonden: "Grote taalmodellen (LLM's) zijn ontworpen om tekst te produceren die mensen kunnen lezen. Wanneer je een model een oordeel wilt laten vellen dat door je code wordt gebruikt, ontstaat er een mismatch."
Het uitvoeroppervlak bestaat uit drie primitieven, en er is niets anders. Elke vraag die je stelt moet een van hen zijn:
• Keuze — kies één optie uit een lijst die u aanlevert, en retourneer de gekozen optie plus een waarschijnlijkheid voor elke kandidaat en een betrouwbaarheid. Opties zijn beperkt tot 255 per veld; daarbuiten documenteert TypeSafe een patroon in twee fasen: eerst worden kandidaten onafhankelijk gescoord en daarna wordt er gekozen.
• Score — plaats de toestand op een geordende rubric, waarbij je het niveau, een waarschijnlijkheid per niveau en een zekerheid teruggeeft. Churnrisico op een schaal van 0-1 is het voorbeeld in de documentatie.
• Noul — een samentrekking van "no" en "null" — een enkele ja/nee-bewering, die de gekalibreerde waarschijnlijkheid teruggeeft dat deze waar is.

De interessante eigenschap is niet één enkele primitieve, maar hoe ze zich samenvoegen. Alle drie kunnen in één enkele API-aanroep worden gemengd, en elke vraag wordt parallel geëvalueerd op basis van één gedeelde uitlezing van dezelfde toestand. De documentatie van TypeSafe zegt dat het toevoegen van vragen "de responstijd nauwelijks verandert", en de onafhankelijke tests bevestigen dat in de praktijk — 21 vragen verspreid over 37 documenten bleven binnen dezelfde 0,7 seconde. Dat is wat de prijs per beoordeling doet instorten: je betaalt niet voor een langere generatie, je betaalt voor één doorgang.
De praktische enveloppe, zoals gedocumenteerd en zoals gemeld door vroege gebruikers: een verzoekbudget van ruwweg 64.000 tokens, waarvan ongeveer 32.000 de toestand plus de langste afzonderlijke vraag dekken — de documentatie van TypeSafe merkt op dat de nauwkeurigheid verandert naarmate de toestand groeit; geen beeld- of audio-invoer bij de lancering; en een structuur van verzoek en antwoord die niet de chat-completions-conventie is, zodat een bestaande client zijn base-URL er niet simpelweg naar kan laten wijzen. Toegang was niet langer het obstakel op 21 september 2026, toen TypeSafe de wachtlijst verwijderde en Jev opende voor iedereen met een account; nieuwe accounts beginnen met $5 aan tegoed waarvan de leverancier zegt dat het ongeveer 120 miljoen inputtokens tegen lijstprijs waard is. De eigen homepage van TypeSafe beschrijft Jev nog steeds als in early access, een label dat zijn documentatie niet herhaalt: de documentatie publiceert dynamisch aanpasbare limieten van 100K tokens per seconde en 40 verzoeken per seconde in plaats van een toegangspoort. De browser-playground staat er nog steeds naast de API, en jev-latest blijft de modelalias.
RLCD betekent gekalibreerd, niet geprefereerd
TypeSafe traint Jev met een methode die het RLCD noemt — Reinforcement Learning for Calibrated Decisions, volgens de eigen documentatie van het bedrijf. Het acroniem is zo nieuw dat vroege berichtgeving het inconsistent heeft uitgeschreven, dus het is de moeite waard om precies vast te stellen wat het eigenlijk benoemt, want dat onderscheid vormt de hele onderzoeksclaim.
RLHF optimaliseert voor door mensen geprefereerde output. RLVR optimaliseert voor verifieerbare correctheid, het soort dat de testcase doorstaat. RLCD optimaliseert voor kalibratie: een model dat zegt dat het 70% zeker is, zou ongeveer 70% van de tijd gelijk moeten hebben. Dat is een ander doel dan gelijk hebben, en het is de reden dat elk Jev-antwoord met een bijgevoegde kansverdeling wordt geleverd in plaats van alleen een antwoord. De beoogde faalmodus is een model dat weet wanneer het iets niet weet, zodat je code kan beslissen wat daaraan te doen.
Wat dat in de praktijk oplevert, is een bedieningsoppervlak. Het gedocumenteerde patroon bestaat uit drie betrouwbaarheidsbanden — bovenaan automatisch handelen, in het midden markeren of bevestigen, onderaan naar een mens routeren — waarbij de drempels in je code leven in plaats van in het model. Of de banden eerlijk zijn, is een empirische vraag over je data, en het is er een die TypeSafe je expliciet zegt zelf te beantwoorden, met de opmerking dat betrouwbaarheidsdrempels use-case-specifiek zijn en getest moeten worden tegen je eigen gelabelde voorbeelden. Die instructie is de belangrijkste zin in de documentatie, en wat de documentatie niet bevat, is een extern verslag van de vraag of de methode achter die banden doet wat haar naam zegt. Sinds deze week is er een gedeeltelijk extern verslag, en het is een reconstructie in plaats van een onthulling: RSI-Jev's RL post-mortem bouwt een gecontroleerde zevenarmige reconstructie van de gepubliceerde vermoedens over RLCD — een subset van 13,8k vragen, 1.500 stappen per arm — en publiceert wat er met elke arm gebeurde, inclusief de armen die faalden. Elke RL-beloning daarin maakte de ruwe kalibratie slechter; een goedkope post-hoc confidence-head herstelde ze allemaal behalve de proper-score-arm; en geen enkele doelstelling verbeterde de rangschikking van betrouwbaarheid. Het sluit af met een opsomming van drie ingrediënten die RLCD moet bevatten, geformuleerd als een hypothese over hoe de methode zou kunnen werken in plaats van als een bewering over de interne werking van TypeSafe, die niemand buiten het bedrijf heeft gezien. Lees het als het eerste bewijs van een derde partij dat naast de hieronder gerangschikte kalibratieclaims staat, niet als een kijkje erin; de eigen achtergrond van de methode staat in onze uitleg RLCD Explained.
De nummers, gesorteerd op wie ze heeft geproduceerd
Dit is het punt waarop de meeste berichtgeving over Jev vaag wordt, dus het is de moeite waard om expliciet te zijn over de herkomst. Dit komt van de leverancier, dit is afkomstig van onafhankelijke testers, en dit is simpelweg onbekend.
• Door leverancier gerapporteerd, niet gereproduceerd — de opvallende snelheids- en kostenclaims. 70-500 ms end-to-endlatentie tegenover 3-329 seconden voor frontier-LLM-aanroepen; 20-200x sneller en 40-400x goedkoper; één resultaat van een workflow in het gunstigste geval, aangeprezen als 193,6x sneller en 444,6x goedkoper. TypeSafe erkent dat dit cijfers voor het gunstigste geval zijn en niet universele cijfers.
• Door de leverancier gerapporteerd en controleerbaar op de prijslijst — $0,042 per miljoen inputtokens, wat $42 per miljard is, met gratis output. De reden dat output gratis is, is mechanisch en niet promotioneel: er is geen autoregressieve decoding om te meten, dus er zijn geen outputtokens om te factureren. Ter vergelijking: dezelfde lanceringsmaterialen zetten de typische frontier-inputprijzen op $0,20 tot $10 per miljoen, waarbij output vaak ongeveer vijf keer de inputprijs is.
• Door de leverancier gerapporteerd, afkomstig uit een interne benchmark — het eigen workflowdashboard van TypeSafe, 711 casussen verdeeld over vier taken, met referentieantwoorden die zijn afgeleid van de gemiddelde beoordeling van GPT-6 Astra en Claude Fable 5.1 in plaats van de grondwaarheid. Op dat dashboard komt Jev geaggregeerd uit op 67,8% tegenover 74,1% voor de beste comparator. Uitgesplitst: beveiligingsincidenten 61,7% tegenover 66,2% voor Opus 5; observability van agent-traces 71,6% tegenover 76,6%; factuurverwerking 61,8% tegenover 79,1%; klantenservice 76,0% tegenover 78,3%. Jev wint op die grafiek de kolommen voor kosten en latentie en verliest de kolom voor nauwkeurigheid. Het dashboard zelf vermeldt een mogelijke bias in de testomgeving, en TypeSafe heeft gezegd dat het bewust publieke leaderboards heeft overgeslagen ten gunste van eenmalige evaluaties die aan productupdates zijn gekoppeld.
• Onafhankelijk gemeten, kleine steekproef — de eerste externe test, de hierboven beschreven Every-run: 777 beoordelingen in minder dan 0,7 seconden voor ongeveer een kwart cent; 1.709 beoordelingen over 11 experimenten voor in totaal minder dan een cent; ruwweg 25x sneller en 1/580ste van de kosten van Claude Fable 5.1 bij een classificatietaak met 12 passages, terwijl één van de zeven aangebrachte defecten werd gemist die de comparator wel oppikte. Every's eigen conclusie was dat het een veel grondiger nauwkeurigheidscontrole zou willen voordat het in productie werd genomen — een controle die sindsdien deels is verschenen, hieronder.
• Onafhankelijk gemeten, vooraf geregistreerd en grootschaliger — een extern team publiceerde op 20 september 2026 een vooraf geregistreerde evaluatie, waarbij 21 experimenten en 50 voorspellingen werden vastgelegd voordat er ook maar één verzoek uitging, over 5.721 aanroepen. Op een referentieset van 400 items scoorde Jev 95,9% zero-shot, tegenover 77,2% voor handgeschreven trefwoordregels en 66,0% voor een gesuperviseerde TF-IDF-baseline. Dezelfde studie documenteert de faalmodus die meer van belang is dan de kop: wanneer de criteriumbeschrijvingen in de vraag onjuist waren, stortte de nauwkeurigheid in naar 16,7%, onder de 25%-ondergrens voor willekeurig gokken bij die taak. De auteurs geven hun eigen bias in tegengestelde richting toe — 18 van hun 21 weerlegde voorspellingen zaten er op dezelfde manier naast, omdat ze bleven voorspellen dat het zou mislukken en het bleven mis hebben.
• Onafhankelijk gemeten, buiten de distributie — een apart kalibratieonderzoek, gepubliceerd op 19 september 2026, bouwde 900 regelgegenereerde supporttickets waarvan de labels deels afhangen van een intern accounttierbeleid dat nergens in de tekst staat, zodat geen enkel model het had kunnen memoriseren, en liet ze meelopen met 3.721 items uit publieke benchmarks. Op de synthetische arm bedroeg Jevs verwachte kalibratiefout 0,107, tegen een ruisvloer van 0,024 die de auteurs berekenden voor een perfect gekalibreerd model — ongeveer 4,4 keer de vloer. Op de publieke benchmarks mat hetzelfde onderzoek 0,024 tot 0,032. Het verschil tussen die twee bereiken is de bevinding.
• Onbekend — de architectuur. Geen paper bij de lancering, geen parameteraantal, geen openbaarmaking van de trainingscompute, geen gewichten. TypeSafe heeft gezegd dat de details "voorlopig nog even binnenskamers" worden gehouden, met mogelijk later een paper. De replicatiegolf van medio september veranderde dit niet: die projecten bouwen het gedrag na met hun eigen architecturen, en geen van hen onthult hoe het model van TypeSafe werkt. De open checkpoints die een project van derden nu publiceert, zijn van dat project zelf, geen release van TypeSafe, en ze veranderen niets aan de bovenstaande zinnen — de volledige verantwoording van wat de leverancier wel en niet heeft uitgebracht staat in Is Jev Open Source?.

Het patroon over die niveaus is consistent, en het is niet het patroon dat de 200x-kop suggereert. Elk onafhankelijk en leverancierscijfer is het erover eens dat Jev dramatisch goedkoper en dramatisch sneller is. Geen enkel cijfer, ook niet dat van TypeSafe zelf, toont aan dat het nauwkeuriger is dan de frontier-modellen waarmee het qua prijs wordt vergeleken — op het eigen dashboard van de leverancier komt het uit rond het niveau van een goed mid-tier-model. Wat het nieuwere externe werk toevoegt, is een vorm aan het nauwkeurigheidsverhaal in plaats van een nieuwe kop. Bij taaktypen die het eerder heeft gezien, kan het er zeer sterk uitzien: 95,9% zero-shot op de eigen 400-item referentieset van het vooraf geregistreerde team, ver vooruit op de keyword- en TF-IDF-baselines waarmee het is gemeten. Bij input die is gemaakt om op niets te lijken dat het heeft gezien, verliest zijn vertrouwen zijn houvast. De vergelijking die standhoudt is nog steeds niet "even slim als een frontier-model voor een honderdste van de prijs" — het is "dicht bij het oordeel van een mid-tier-model voor een fractie van een cent per aanroep, snel genoeg om bij elke afzonderlijke beurt te draaien."
Wat "zero hallucination" wel en niet betekent
Het lanceringsmateriaal van TypeSafe bevat een grafiek die een foutpercentage van 0% bij tool-aanroepen voor Jev laat zien, tegenover een niet-nulpercentage voor vergelijkingsmodellen, en de formulering "hallucinatiebestendig" reist mee met het model. Beide zijn waar en beide zijn beperkter dan ze lijken.
De garantie is structureel. Elk mogelijk antwoord wordt opgesomd voordat het model draait — jij hebt de keuzelijst, de rubric of de waar/onwaar-bewering aangeleverd — dus er is geen ruimte om een waarde buiten het gedeclareerde type te produceren. Een misvormde tool-aanroep is niet iets wat Jev kan produceren. Dat is een echte engineering-eigenschap, en voor iedereen die een week heeft besteed aan het schrijven van retry-logica rond JSON-parsefouten, is het echt geld waard.
Het is geen bewering over correct zijn. Een schema-valide antwoord kan nog steeds fout zijn: Jev kan een factuurklacht vol vertrouwen naar de technische wachtrij sturen, en de output zal perfect welgevormd zijn terwijl die nutteloos is. Almeida heeft dat zelf gezegd, en erkende dat het mogelijk is om vol vertrouwen fout te zijn. De nuttige manier om beide feiten te hanteren is dat Jev de categorie fouten elimineert die voortkomt uit de opmaak van de output, en helemaal niets doet aan de categorie die voortkomt uit het oordeel. Wat betekent dat de nauwkeurigheidsvraag volledig een kalibratievraag is, en kalibratie is precies het ding dat je zelf moet meten.
De eerste externe evaluaties voegen een specifieke waarschuwing toe over hoe die structurele garantie zich in productie gedraagt. Omdat Jev altijd een van de antwoorden teruggeeft die jij hebt aangeleverd, heeft het geen manier om "geen van bovenstaande" te zeggen, tenzij je er zelf een aanlevert. Een vooraf geregistreerde run in september vroeg het om materiaal zonder geldige categorie te classificeren en constateerde dat 0 van de 30 berichten buiten scope werden gemarkeerd, elk met een confidence van 0,99. Een recept voor een cake, of een pagina met willekeurige letters, komt terug als een categorie met hoge confidence, omdat de aanvraag nu eenmaal om een categorie vroeg. De oplossing is een ontwerpgewoonte in plaats van een modelinstelling: neem een expliciete ontsnappingsoptie op in elke Choice-lijst en een false-tak in elke Noul-claim, en beschouw het ontbreken daarvan als een bug in je eigen vraagtekst.
Hoe je de kalibratieclaim op je eigen data kunt testen
Calibratie is een van de weinige modeleigenschappen die je goed kunt controleren met een paar honderd voorbeelden en zonder ML-infrastructuur, en het is de enige test die ertoe doet voordat Jev een productiepad aanraakt. De procedure is kort.
Neem een paar honderd gevallen waarvoor je al labels hebt. Stel Jev de vraag die ertoe doet — de routeringsbeslissing, de risicoscore, de defectcontrole — en verdeel de antwoorden in buckets op basis van het gerapporteerde vertrouwen. Controleer vervolgens of de bucket met 0,9 vertrouwen ongeveer 90% van de tijd gelijk heeft, de bucket met 0,7 ongeveer 70%, enzovoort. Een goed gekalibreerd model volgt een diagonale lijn. Een model dat louter zelfverzekerd is, clustert alles boven 0,9 en heeft 70% van de tijd gelijk, en dat is de vorm die een geautomatiseerde pijplijn stilletjes kapotmaakt.
Dezelfde test vertelt je welke drempels je moet gebruiken. Als de 0,9-bucket echt 90% nauwkeurig is op jouw data, kun je die automatiseren. Als je middelste band pap is, stuur je die naar een mens of geef je die aan een generatief model, en laat je het dure pad de ambiguïteit afhandelen. Die splitsing — goedkoop model op de zelfverzekerde meerderheid, duur model op de onzekere rest — is de eigenlijke architectuur waar Jev voor pleit, en het is de reden dat het model het beste kan worden begrepen als een component in plaats van als een vervanging.
De out-of-distributionstudie is het eerste antwoord van buitenaf op die vraag, en het is een waarschuwing in plaats van een goedkeuring. Toen de studie werd uitgevoerd op 900 synthetische supporttickets waarvan het beslissende beleid niet in de tekst staat, kwam Jev's vertrouwen niet meer overeen met de nauwkeurigheid: verwachte kalibratiefout 0,107 tegen een ruisvloer van 0,024, ongeveer 4,4 keer wat een perfect gekalibreerd model op dezelfde set zou scoren. Op de drie publieke benchmarks was die 0,024 tot 0,032 — dus het model is goed gekalibreerd op het soort data waarvoor het is gebouwd en waartegen het is gemeten, en wezenlijk minder goed zodra de taak onbekend is. De score-primitieve was de zwakste van de drie, met 44,7% nauwkeurigheid en een gemiddelde opgegeven waarschijnlijkheid van 0,74. De auteurs van de studie zelf vragen lezers de richting van dat resultaat aan te houden en niet de exacte grootte, aangezien één synthetische taakfamilie bij n=900 geen algemene wet is. De richting is het deel dat ertoe doet voor iedereen die drempels opstelt: voer de bucketingtest hierboven uit op je eigen labels voordat je een beslissing automatiseert, want de kalibratie die je op publieke benchmarks kunt zien, is niet de kalibratie die je op je eigen verkeer zult krijgen.
Wat het kost, uitgewerkt
De prijsstelling is eenvoudig genoeg om te beredeneren, wat zeldzaam is. Input kost $0,042 per miljoen tokens — het tarief dat TypeSafe publiceert, en het tarief dat de OrcaRouter-catalogus hanteert — en output is gratis. Bij het gedocumenteerde budget van ongeveer 64.000 inputtokens kost één aanroep van maximale grootte minder dan drie tienden van een cent.
Twee gerapporteerde cijfers geven een idee van de schaal. Een vroege gebruiker voerde ongeveer 5.000 requests uit voor ongeveer $2. De Doom-demonstratie — waarbij Jev een bot aanstuurde met een tekstbeschrijving van de spelstatus in plaats van met ruwe pixels — draaide op ongeveer 10 calls per seconde voor ongeveer $7 per uur. En de 777 beoordelingen van Every over 37 documenten kwamen uit op ongeveer een kwart cent, en dat is het getal dat het interessante gebruiksscenario inzichtelijk maakt: tegen die prijs houdt het controleren van elke afzonderlijke beurt van een agent-loop op een kostenbeslissing te zijn en wordt het de standaard.
Dat is het echte argument voor Jev. Een verificatieronde per beurt – sprak deze toolaanroep de vorige tegen, is deze uitvoer consistent met de door de gebruiker aangegeven intentie, zou dit een waarschuwing moeten opleveren – is technisch altijd mogelijk geweest met een frontier-model en economisch absurd op schaal. Bij $0,042 per miljoen tokens zonder kosten voor uitvoer wordt dezelfde ronde bij elke beurt betaalbaar. De waarde hier is niet dat Jev beter denkt dan een frontier-model, want dat doet het niet. De waarde is dat het goedkoop en snel genoeg denkt om voortdurend geraadpleegd te worden.
Het is de moeite waard om het ronduit te zeggen, want het is de voor de hand liggende volgende vraag: OrcaRouter heeft typesafe/jev-1.13 op 24 september 2026 aan zijn catalogus toegevoegd, en het model staat vandaag live op de Jev 1.13-modelkaart — één API voor 200+ modellen tegen de lijstprijs van de provider, doorgegeven met 0% opslag, zodat een prijsverlaging van een leverancier dezelfde dag dat die uitkomt ook aan onze kant doorwerkt. Twee details over hoe het wordt aangeboden, want dat zijn de dingen waar mensen naar vragen. Verzoeken gaan naar POST /v1/systemone, non-streaming, tegen een context van 65.536 tokens; dat is niet de vorm van chat-completions, en daarom zit Jev op een eigen endpointtype in plaats van te worden opgenomen in de chatroute. En de kaart publiceert ons eigen servicevenster van zeven dagen, gemeten op verkeer via onze playground sinds 24 september in plaats van overgenomen van de leverancier: p50 151 ms, p95 247 ms, 349 outputtokens per seconde en een foutpercentage van 0,49% over 76,2M tokens. Dat is wat het tweemodelpatroon waarvoor Jev pleit één contract maakt in plaats van twee. Jev neemt de getypeerde beslissing, een generatief model behandelt het deel dat proza, code of uitleg nodig heeft, beide helften worden gefactureerd op dezelfde sleutel tegen de lijstprijs van de provider, en automatische failover voorkomt dat een beslissingscomponent die slecht gekalibreerd blijkt te zijn een productie-incident wordt.

Waar Jev niet past
De beperkingen worden ongewoon duidelijk door de leverancier vermeld, wat het gemakkelijk maakt deze sectie eerlijk te schrijven. Jev kan geen vrije tekst genereren. Het kan geen code schrijven. Het kan geen gesprek voeren. Het heeft geen chatinterface, geen beeldinvoer, en een verzoekbudget van ongeveer 64.000 tokens — waarvan ongeveer 32.000 de status plus de langste enkele vraag bestrijken — een orde van grootte lager dan de long-contextmodellen waarmee het qua prijs wordt vergeleken. Keuzevelden hebben een maximum van 255 opties. En de "geen hallucinatie"-eigenschap, zoals hierboven, gaat over het uitvoerformaat in plaats van de waarheid.
Het net is een vrij beperkte match. Goed: classificatie en routing op grote schaal, guardrail- en verificatierondes, latency-kritische beslissingen, het parallel scoren van grote documentsets, overal waar het juiste antwoord echt een keuze, een getal op een schaal of een boolean is. Slecht: open-ended generatie van welke aard dan ook, redeneren met lange context, dialoog met meerdere beurten, of elke taak waarvan het juiste antwoord een zin is. Als je probleem niet te herleiden is tot een getypeerde vraag, is Jev geen goedkopere manier om het op te lossen — het is helemaal geen manier om het op te lossen.
Er is ook terechte kritiek op de framing die het waard is om mee te nemen. Jev een frontiermodel noemen leent geloofwaardigheid die het model niet heeft verdiend: het kan niet programmeren, chatten of een zin schrijven, en de vergelijkingsgrafieken leunen op frontiermodellen als baseline, terwijl de nauwkeurigheidskolom een ander verhaal vertelt. De beter verdedigbare bewering, en degene die het bewijs daadwerkelijk ondersteunt, is dat TypeSafe de frontier op het gebied van snelheid en kosten voor gestructureerde beslissingen een heel eind heeft verlegd. Dat is een aanzienlijke prestatie. Het is iets anders dan een model bouwen dat kan wedijveren met GPT-6 Astra of Claude Fable 5.1.
Wat zou deze afbeelding veranderen?
Vier dingen zouden dit beslechten, en de week sinds het model zich opende heeft er drie opgeschoven.
• Een gepubliceerd paper over de architectuur of open gewichten. Nog steeds de grootste leemte. Alles over hoe Jev zijn snelheid bereikt, blijft een black box, en de bewering dat parallelle evaluatie het mechanisme is — de analogie die Almeida trekt, is het vervangen van sequentiële berekening zoals transformers recurrente netwerken vervingen — is een bewering in plaats van een aangetoond resultaat. De open-sourcegolf hieronder herimplementeert het gedrag; niets daarvan onthult hoe het model van TypeSafe werkt. Zolang het ontwerp niet is gepubliceerd, is de snelheid een feit en de uitleg marketing.
• Een tweede onafhankelijke evaluatie met een grotere steekproef. Deze landde deels. De vooraf geregistreerde testronde van 20 september omvat 5.721 calls en een referentieset van 400 items, wat een veel grotere steekproef is dan de 12 passages van Every en een veel beter opgezette, en het is het sterkste afzonderlijke bewijsstuk voor Jev dat bestaat. Het is ook zelf opgesteld, op één dag, op één locatie en uitgevoerd tegen één modelversie, en het team publiceert zijn eigen beperkingen naast zijn resultaten. Wat het wel vaststelt, is dat Jev echt goed is in datgene waarvoor het is ontworpen; wat het niet vaststelt, is hoe het presteert op de taak van iemand anders.
• Een kalibratieaudit op realistische, rommelige input. Deze kwam binnen, en het is het minst comfortabele resultaat in dit artikel. De out-of-distributionstudie hierboven is de eerste auditronde op materiaal dat is samengesteld om onbekend te zijn voor het model, en constateerde dat vertrouwen loskoppelde van nauwkeurigheid bij ongeveer 4,4 keer de ruisvloer van een perfect gekalibreerd model — terwijl hetzelfde model op drie publieke benchmarks goed gekalibreerd leek. Eén synthetische taakfamilie met 900 items is geen verdict, en dat zeggen de auteurs ook. Het is genoeg om de vraag te verleggen van "is Jev gekalibreerd?" naar "gekalibreerd op wat?", wat sowieso de nuttigere vraag is.
• Een replicatie die Jev op Jevs eigen voorwaarden verslaat — Nog niet, en de golf stopte niet in september. Binnen ongeveer 48 uur na de lancering hadden minstens zes onafhankelijke open projecten beslissingsmodellen in Jev-vorm uitgebracht — één gebouwd op een encoder met 421 miljoen parameters, één een LoRA op een 9B-model, één klein genoeg om in enkele tientallen kilobytes te passen — en op 23 september stond één ervan bovenaan een trendinglijst voor modelhosting. Elke vergelijking die die projecten publiceren is zelfgerapporteerd door het team dat het alternatief heeft gebouwd, en elk gebruikt zijn eigen evaluatieset. De resultaten wijzen in verschillende richtingen: de kloon die wint op nieuwscategorisatie verliest ruim op een intentietaak met 77 categorieën, en de enige onafhankelijke head-to-head-run op byte-identieke inputs heeft Jev voorop in zes van de negen suites. Jevs eigen nauwkeurigheid op één enkele benchmark is inmiddels in vier verschillende waarden gepubliceerd door vier verschillende evaluaties. Het blijvende exemplaar uit die golf is RSI-Jev, en het is het concrete, gedateerde voorbeeld van dat argument: een open project van derden dat System One-beslissingsmodellen in Jev-stijl bouwt, code MIT, gewichten Apache-2.0 op Hugging Face, met een licentieregel die luidt: "Not affiliated with TypeSafe AI." De release van deze week is de 4B RSI-Jev v6.0-VL, gepubliceerd op 2026-10-06 en de zevende in een zelfverbeterende lus die 471 experimenten heeft uitgevoerd en er maar heel weinig van heeft behouden: een Qwen3.5-4B-Base-toren met een getrainde antwoordhead, één forward pass per beslissing, niets gegenereerd. Het besteedt diepte in plaats van tokens — antwoordheads op lagen 16, 20 en 32, zodat een verzoek stopt bij degene die het eerst zeker genoeg is, mediaan 23, 27 en 40 ms op één H200 in bf16 — en het spreekt het wire-format van TypeSafe exact: dezelfde aanvraag, dezelfde drie vraagtypen, dezelfde confidence-statistiek, zodat alles wat voor Jev is geschreven zonder wijzigingen ook hiermee werkt. Op de eigen openbare Decision Index van het project rapporteert het 38,38 tot 46,24 in één release, met 0,698 op zijn held-outset en 0,440 op MMLU-Pro — zijn eigen cijfers op zijn eigen scorebord, en er is geen onafhankelijke head-to-head tussen dit en Jev 1.13. Het is geen weights-release van Jev, het maakt het model van TypeSafe niet open, en TypeSafe heeft het niet gemaakt en ook niet onderschreven; de eerdere releases op die lijn waren 2B-modellen op Qwen3.5-2B-Base, en het RL-resultaat dat de naam van het project vestigde, is van v3.0, gedateerd 2026-09-28 en drie releases terug — de eerste release waarin een RL-fase het gesuperviseerde model versloeg waarop het voortbouwde, een listwise reranking-beloning over 16 kandidaten die reranking R@1 verhoogde van 0,192 naar 0,308 ten opzichte van zijn eigen voorganger, een stijging van 60%, tegen een suitekostenpost van 0,0028. Onze catalogus bevat geen id voor RSI-Jev: wat wij serveren is typesafe/jev-1.13 op het systemone-endpoint, en dit project draait vanuit zijn eigen repository. De volledige uiteenzetting voor een eerste lezer staat in What Is RSI-Jev?.
Wat die golf aantoont, is niet dat Jev verslagen is — het is dat een open model kan worden gebouwd om ongeveer dit werk in een weekend te doen, wat een andere en duurzamere bewering is over waar de moat ligt. De houding die daaruit volgt is smaller dan een week geleden, en specifieker. Jev is een echt, uitgebracht, ongewoon goedkoop model dat nu open is voor iedereen met een account, met een echt structureel voordeel in de betrouwbaarheid van de uitvoer, een nauwkeurigheidsprofiel rond de middenklasse volgens de eigen cijfers van de leverancier, en een kalibratieclaim die sinds de lancering twee keer onafhankelijk is getest: eens op een grote, gunstige, zelf opgestelde benchmark, en eens op onbekende input waar de betrouwbaarheidsscores geen stand hielden. Beschouw het tweede resultaat als het meest informatieve. Als je workflow een stap bevat die neerkomt op een getypte vraag die vaak genoeg wordt gesteld dat een frontiermodel verspilling zou zijn, is dit een van de goedkoopste manieren om die te stellen — en de betrouwbaarheidswaarde die het teruggeeft, is nog steeds het onderdeel dat je op je eigen data moet testen voordat je erop vertrouwt, niet de snelheid. Het is ook testbaar zonder een tweede account: typesafe/jev-1.13 staat live op OrcaRouter naast de generatieve modellen die een Jev-vormige workflow nodig heeft.
