Jev vs DeepSeek V4.1 Flash: acht cent per duizend is geen slotgracht

De vergelijking die de Jev-kwestie beslecht, is niet met een frontiermodel. Het is met DeepSeek V4.1 Flash, uitgebracht op 10 september 2026 — vijf dagen voordat TypeSafe AI Jev op de markt bracht — omdat DeepSeek V4.1 Flash een generatief model is dat echt goedkoop is, en het is het goedkoopste in de ruimte dat bijna alles kan wat Jev kan. Een onafhankelijke test die in september 2026 werd gepubliceerd, liet 77 voorbeelden uit BANKING77, de standaard intentieclassificatieset, door beide gaan: Jev kwam terug op 7 cent per 1.000 classificaties bij 75% nauwkeurigheid. DeepSeek V4.1 Flash kwam terug op 8 cent per 1.000 bij 79% nauwkeurigheid. Dezelfde test zette GPT-5.6 Luna op 12 cent en 83%. Een generatief model met een contextvenster van een miljoen tokens, native tool calling en beeldinvoer eindigde één cent per duizend classificaties achter een speciaal gebouwd beslissingsmodel — en vier punten voor op nauwkeurigheid. Dat is het ongemakkelijke feit in het centrum van deze confrontatie, en het herkadert wat Jev eigenlijk verkoopt.

Wat elk model doet

Jev is een System One-beslissingsmodel: het retourneert helemaal geen tekst. Je stuurt een toestand plus getypeerde vragen — Choice uit een lijst die je aanlevert, Score op een geordende rubric, of Noul (een ja/nee-bewering met een gekalibreerde waarschijnlijkheid) — en het retourneert getypeerde antwoorden met betrouwbaarheidswaarden. Alle vragen worden parallel geëvalueerd op basis van één gedeelde lezing van de toestand, daarom verandert het toevoegen van vragen de responstijd nauwelijks, en daarom kost output niets: er zijn geen outputtokens om te meten. Input kost $0,042 per miljoen tokens, output is gratis, en het aanvraagbudget is ongeveer 32.000 tokens. Het werd gelanceerd op 15 september 2026, vanuit TypeSafe AI, opgericht door Diogo Almeida met een seedronde van $40M onder leiding van DCVC.

DeepSeek V4.1 Flash is een conventioneel generatief model en pretendeert niet anders te zijn. Het werd uitgebracht op 10 september 2026 met een API-id van deepseek-flash, gebouwd als een mixture-of-experts met 552 miljard parameters en asymmetrische activatie bij 8B/16B, een contextvenster van 1M tokens en tekst- plus beeldinvoer. Het genereert tekst token voor token, en dat is precies de eigenschap die het per aanroep duurder en capabeler maakt. Het draait op 208,3 tokens per seconde met een tijd tot het eerste token van 1,13 seconde, en de prijs is $0,30/$1,20 per miljoen tokens tijdens piek en $0,15/$0,60 buiten piek. Op Artificial Analysis staat het op een Index van 40 — middenklasse, niet frontier.

Waarom de wiskunde per classificatie uitkomt waar die uitkomt

Het verschil van één cent is geen toeval en het is niet stabiel. Het vloeit voort uit hoe elk model factureert.

• De kosten per beslissing van Jev zijn in feite vast — je betaalt voor één doorgang over de invoer, tegen $0,042 per miljoen tokens, en het aantal vragen dat je stelt verandert daar nauwelijks iets aan. Een classificatie die één label nodig heeft en een classificatie die twintig labels nodig heeft, kosten bijna hetzelfde.

• De kosten per beslissing van DeepSeek V4.1 Flash schalen mee met de output. Classificatie naar een kort label is goedkoop; dezelfde taak waarbij je om een motivering, een betrouwbaarheidsscore en een gestructureerde JSON-envelop vraagt, kost meerdere keren zoveel outputtokens en dus meerdere keren zoveel geld.

• Piek versus daluren verdubbelt DeepSeeks inputprijs en verdubbelt de outputprijs. Batch een classificatietaak op het verkeerde uur en het verschil van één cent wordt een heel ander getal.

Dat is waarom onafhankelijke schattingen van het verschil zo sterk uiteenlopen. De BANKING77-test met 77 voorbeelden vond 7¢ tegenover 8¢. Een aparte samengestelde benchmark, JevBench, zette Jev op $0.041 per 1,000 en DeepSeek V4.1 Flash op $0.579 per 1,000 — een veertienvoudig verschil. Een derde test op 83 verkoopcontacten vond DeepSeek V4.1 Flash op $0.183 per run tegenover de $0.0055 van Jev, een 33-voudig verschil. De reden dat die getallen twee ordes van grootte omspannen, is dat elk ervan uitging van een andere prompt, een andere outputvorm en een ander tijdstip van de dag. Iedereen die één enkel cijfer per classificatie citeert alsof het een eigenschap van het model is in plaats van van de testopstelling, probeert iets te verkopen.

Wat Jev's structuur je geeft wat een generatief model niet kan

De onderscheidende factor is niet de prijs. Het is het contract. De output van Jev is schema-vergrendeld: omdat elk mogelijk antwoord wordt opgesomd voordat het model draait — jij hebt de keuzelijst, de rubric of de waar/onwaar-bewering aangeleverd — is er geen ruimte om een waarde buiten het gedeclareerde type uit te geven. Een misvormde respons is niet iets wat Jev kan produceren. DeepSeek V4.1 Flash kan met een schema worden beperkt tot gestructureerde output, en voldoet in de praktijk meestal, maar de garantie is een sterke prior in plaats van een structurele eigenschap. Als je pijplijn tien miljoen classificaties per maand draait, zijn "meestal" en "altijd" verschillende regelitems op een incidentrapport.

De tweede eigenschap is calibratie. Jev wordt getraind met een methode die TypeSafe RLCD noemt — Reinforcement Learning for Calibrated Decisions — en elk antwoord bevat een kansverdeling, zodat je code drempels kan instellen: automatisch accepteren boven de drempel, markeren in het midden, escaleren eronder. DeepSeek V4.1 Flash produceert een betrouwbaarheidsgetal als je erom vraagt, maar het is een gegenereerd token, geen gekalibreerde uitvoer, en een gegenereerde betrouwbaarheid is een bewering over zichzelf in plaats van een meting. Dat onderscheid is de hele reden om voor een beslissingsmodel te betalen, en het is het enige dat een goedkoop generatief model structureel niet kan evenaren.

De derde is de vorm van de latentie. De gedocumenteerde end-to-end latentie van Jev is 70–500 ms, ongeacht hoeveel vragen eraan zijn gekoppeld, tegenover 3–329 seconden voor frontier-LLM-aanroepen in de eigen vergelijking van TypeSafe. De TTFT van 1,13 seconde en de doorvoer van 208 tokens per seconde van DeepSeek V4.1 Flash zijn uitstekend voor een generatief model, en dat is de maatstaf waaraan het moet worden afgemeten — maar bij een paar honderd milliseconden gegenereerde output plus latentie van de eerste token, is het seconden per beslissing, niet fracties van een seconde. Op het interne workflowdashboard van TypeSafe wint Jev de kolommen kosten en latentie en verliest Jev de kolom nauwkeurigheid, met 61,8% tegen 79,1% bij factuurverwerking en 76,0% tegen 78,3% bij klantenservice. De referentieantwoorden van het dashboard zijn gemiddelde modelbeoordelingen in plaats van ground truth, en het dashboard zelf markeert mogelijke harnasbias.

De contextkloof is reëel en eenzijdig.

Eén dimensie hier is niet nauw aan elkaar gewaagd en is geen kwestie van framing. DeepSeek V4.1 Flash heeft een contextvenster van één miljoen tokens; het verzoekbudget van Jev is ongeveer 32.000 tokens. Als je classificatie afhangt van het lezen van een heel contract, een lange supportthread of een groot codebestand, kan DeepSeek V4.1 Flash het wel zien en Jev niet — hoe goedkoop elke afzonderlijke beslissing ook is, het verhelpt niets aan een toestand die niet past. Jev accepteert bij de lancering ook geen beeld- of audio-invoer, terwijl DeepSeek V4.1 Flash afbeeldingen accepteert.

De keerzijde is dat Jevs smalle venster wordt geprijsd alsof het een last is in plaats van een beperking, en het tweetrapspatroon in TypeSafe's eigen documentatie is de workaround: voor Choice-velden boven de limiet van 255 opties scoor je kandidaten in batches en kies je vervolgens op basis van de scores. Dat werkt wanneer de toestand klein is en de set opties groot. Het werkt niet wanneer de toestand groot is.

Waar elk thuishoort

Kies Jev wanneer de beslissing echt closed-form is, de state binnen 32K tokens past, het volume hoog genoeg is dat seconden per aanroep een echte kostenpost vormen, en de pipeline een confidencewaarde nodig heeft waarop hij kan vertakken. Guardrail-controles, verificatie per beurt binnen een agent-loop, routering met hoog volume en het parallel scoren van grote documentensets zijn de gedocumenteerde toepassingen.

Kies voor DeepSeek V4.1 Flash wanneer de taak vereist dat er een lange tekst wordt gelezen, wanneer er een onderbouwing naast het label geproduceerd moet worden, wanneer er een afbeelding bekeken moet worden, of wanneer de classificatie één stap is in een langere generatieve workflow en het afsplitsen ervan naar een tweede leverancier een extra hop zou toevoegen voor een besparing van één cent die een slechte prompt teniet kan doen. En merk op dat "een generatief model kan het ook" de juiste beschrijving van de taak is, geen tekortkoming van Jev — de interessante vraag is of je de confidence-waarde nodig hebt, want dat is het enige regelitem in de vergelijking dat een generatief model tegen geen enkele prijs kan bieden.

De beslissingslaag en de generatieve laag op één sleutel draaien

DeepSeek V4.1 Flash is een van de modellen die OrcaRouter routeert, tegen de lijstprijs van de provider en met 0% markup doorgegeven — dus de off-peakkorting is bij ons al live op dezelfde dag dat DeepSeek die uitbrengt, en hoef je niet twee prijslijsten bij te houden. Jev zelf bieden we niet aan: het model van TypeSafe is early-access en hanteert zijn eigen requestformaat. De architectuur waar deze vergelijking op wijst, is de architectuur met twee modellen — Jev beslist, DeepSeek V4.1 Flash genereert — en OrcaRouter dekt de generatieve helft achter één OpenAI-compatibel endpoint, met automatische failover, zodat een onbewezen beslissingscomponent nooit een single point of failure wordt. 200+ modellen, één sleutel, één factuur.

Het vonnis

Als je hiernaartoe kwam in de verwachting dat Jev dramatisch goedkoper zou zijn dan een generatief model, dan is het eerlijke antwoord dat dat tegenover DeepSeek V4.1 Flash meestal niet zo is, en in deze specifieke test met 77 voorbeelden was het één cent goedkoper en vier punten minder nauwkeurig. Wat Jev verkoopt is niet de prijs per classificatie. Het is een structurele garantie dat de output niet misvormd kan zijn, een gekalibreerde betrouwbaarheidswaarde waarop je code kan vertakken, en een latency-ondergrens gemeten in milliseconden in plaats van seconden. Die drie dingen zijn het waard om voor te betalen in een pipeline die vaak genoeg draait om er iets om te geven — en ze zijn helemaal niets waard als je taak is om een document van 400 pagina's te lezen en er een samenvatting van te schrijven, wat de taak van DeepSeek V4.1 Flash is en nooit die van Jev was.