De meeste generatieve AI die we vandaag gebruiken heeft min of meer dezelfde vorm.

Je geeft een model tekst, beeld of andere informatie. Het model denkt daarover na en genereert vervolgens nieuwe tokens: woorden, code, JSON of een andere tekstuele representatie.

Dat werkt verbluffend goed wanneer het eindresultaat bedoeld is voor een mens.

Maar computers willen meestal helemaal geen mooie alinea.

Ze willen weten:

  • Is dit belangrijk genoeg om door te sturen?
  • Is deze transactie verdacht?
  • Is dit artikel relevant?
  • Welk model moet deze taak uitvoeren?
  • Is het antwoord van een andere AI waarschijnlijk correct?
  • Moet een menselijke medewerker hiernaar kijken?
  • Is het nú een goed moment om te gaan kitesurfen?

Voor precies dat soort vragen heeft TypeSafe AI Jev gebouwd.

En dat maakt Jev interessanter dan de zoveelste naam op een AI-leaderboard.

Geen taalmodel dat toevallig beslissingen neemt

TypeSafe introduceerde Jev op 15 september 2026 als het eerste model uit een nieuwe categorie die het bedrijf System One Models noemt.

De naam verwijst naar Daniel Kahnemans bekende onderscheid tussen snel, intuïtief System 1-denken en langzaam, analytisch System 2-denken.

Waar een traditioneel taalmodel een reeks tokens genereert, krijgt Jev een toestand van een systeem en één of meer duidelijk gedefinieerde vragen.

Bijvoorbeeld:

Is dit nieuws relevant voor onze lezers?

Of:

Welke categorie past het beste bij dit supportticket?

Of:

Hoe geschikt zijn de omstandigheden om te kitesurfen?

Jev retourneert vervolgens geen verhaal, maar een typed decision: bijvoorbeeld ja/nee, een keuze uit een vooraf gedefinieerde set of een score — samen met waarschijnlijkheden en een confidence-score.

Dat lijkt een klein verschil.

Architectonisch is het een behoorlijk fundamenteel verschil.

Software hoeft namelijk niet meer te hopen dat een taalmodel zich aan een afgesproken JSON-schema houdt en daarna het gegenereerde antwoord te parsen. De mogelijke antwoorden staan vooraf vast.

TypeSafe omschrijft het treffend als een soort “frontier-intelligence function call.”

Invoer erin. Beslissing eruit.

Een AI-model als slimme if-statement

Dat levert een interessante nieuwe manier op om naar AI-applicaties te kijken.

De eerste generatie generatieve-AI-software draaide vooral om prompts:

prompt → LLM → antwoord

De volgende generatie bestaat steeds vaker uit workflows:

data → beslissing → actie → nieuwe data → beslissing → actie

Daarbinnen kan een traditioneel groot taalmodel eigenlijk nogal omslachtig zijn.

Stel dat een agent uit 5.000 nieuwsberichten moet bepalen welke twintig interessant genoeg zijn voor verdere analyse.

Je kunt 5.000 keer een groot taalmodel vragen een gemotiveerde beoordeling te schrijven.

Maar je hebt die motivatie helemaal niet nodig.

Je wilt uiteindelijk bijvoorbeeld slechts drie getallen:

relevantie: 0.94
nieuwswaarde: 0.87
vibelab_fit: 0.91

Daarna kan gewone software beslissen wat ermee gebeurt.

Dat is het terrein waarop Jev interessant wordt.

Belachelijk goedkoop

Ook economisch wijkt Jev sterk af van traditionele frontiermodellen.

Op OpenRouter staat Jev 1.13 momenteel voor $0,042 per miljoen inputtokens. Outputtokens kosten niets.

Dat laatste is logisch: Jev genereert geen lange teksten.

OpenRouter testte Jev onlangs op Banking77, een dataset waarin 3.080 supportvragen in 77 categorieën moesten worden ingedeeld.

Jev 1.13 kwam daar uit op 81,0% accuracy, tegenover 84,4% voor Claude Opus 5.

Maar de andere cijfers zijn minstens zo interessant:

  • mediane latency Jev: 175 ms
  • mediane latency Opus 5: 2.266 ms
  • kosten per 1.000 classificaties Jev: $0,11
  • kosten per 1.000 classificaties Opus: $2,42

In deze specifieke test was Jev dus ongeveer dertien keer sneller en 22 keer goedkoper, terwijl het 3,3 procentpunt aan accuracy inleverde.

Dat betekent nadrukkelijk niet dat Jev “bijna net zo goed is als Opus” in algemene zin. Het experiment ging over één duidelijk afgebakende classificatietaak.

En precies daar zit de essentie.

Jev probeert geen Claude, Gemini of GPT te vervangen.

Het probeert een enorm deel van de taken weg te halen waarvoor we nu automatisch een groot taalmodel inzetten.

De verborgen AI-belasting van agents

Dat kan vooral belangrijk worden wanneer AI-agents serieuzer worden.

Een goede agent neemt tijdens één opdracht tientallen of honderden kleine beslissingen.

Moet ik zoeken?

Heb ik genoeg informatie?

Welke tool heb ik nodig?

Is dit resultaat betrouwbaar?

Moet ik opnieuw proberen?

Welke bron is relevant?

Moet ik escaleren?

Welk model moet de volgende stap uitvoeren?

Op dit moment worden veel van zulke keuzes gemaakt door hetzelfde generatieve model dat ook het moeilijke werk uitvoert.

Dat is alsof je voor iedere verkeersregelaar op een kruispunt een hoogleraar inhuurt.

Het werkt.

Maar zodra agents duizenden of miljoenen workflows per dag uitvoeren, worden latency en kosten ineens fundamentele architectuurproblemen.

Een model als Jev kan dan fungeren als een extreem goedkope beslissingslaag tussen software en grote AI-modellen.

Jev als portier voor duurdere AI

Een van de interessantste architecturen is daarom misschien:

Jev → goedkoop model → frontiermodel → mens

Jev maakt eerst een snelle beoordeling.

Bij zeer hoge zekerheid handelt software automatisch.

Bij redelijke zekerheid gaat de taak naar een goedkoop taalmodel.

Bij ingewikkelde gevallen wordt een krachtiger reasoningmodel ingeschakeld.

En alleen bij uitzonderingen komt er een mens aan te pas.

Daarmee krijg je geen applicatie die één AI-model gebruikt.

Je krijgt een intelligentie-stack.

En Jev wordt daarin niet de schrijver of de denker, maar de verkeersregelaar.

Een praktisch voorbeeld: Vibelab

Stel dat Vibelab continu honderden technologiebronnen volgt.

Een traditionele pipeline zou ieder artikel door een LLM kunnen halen met de vraag:

Beoordeel of dit nieuws interessant is voor Vibelab en leg uit waarom.

Dat werkt.

Maar Jev maakt een andere architectuur mogelijk.

Ieder bericht krijgt bijvoorbeeld vragen als:

Is dit daadwerkelijk nieuw?
Heeft dit gevolgen voor hoe mensen AI gebruiken?
Is dit relevant voor ondernemers of developers?
Is dit vooral marketing?
Is hier een verrassende Vibelab-invalshoek?

Jev kan die beslissingen in fracties van een seconde uitvoeren.

Alleen artikelen met bijvoorbeeld meer dan 90 procent relevantie gaan vervolgens naar een krachtiger model dat research doet, bronnen controleert en een artikel schrijft.

Daarmee gebruik je dure intelligentie alleen waar die waarde toevoegt.

Of neem surfvoorspellingen

Een totaal andere toepassing laat nog beter zien waarom deze categorie interessant is.

Een surf-app beschikt continu over gegevens:

  • windsnelheid
  • windrichting
  • windvlagen
  • golfhoogte
  • golfperiode
  • getij
  • locatie
  • materiaal
  • niveau van de surfer
  • historische voorspelfouten

Een generatief model zou daar iedere paar minuten een uitgebreid weerpraatje van kunnen maken.

Maar de software hoeft eigenlijk alleen te weten:

Is er tussen 16:00 en 19:00 een goede surfwindow voor deze gebruiker?

Met daarachter bijvoorbeeld een kans van 87%.

Daar ontstaat een systeem dat honderdduizenden omstandigheden continu kan beoordelen zonder honderdduizenden mini-chatgesprekken te voeren.

Dat is wezenlijk andere AI.

En dan wordt confidence ineens belangrijk

Misschien is het interessantste onderdeel van Jev niet eens snelheid of prijs.

Het zijn de waarschijnlijkheden.

Een groot probleem met autonome AI is namelijk niet dat modellen nooit fouten maken.

Mensen maken ook fouten.

Het probleem is dat een systeem moet weten wanneer het zichzelf voldoende vertrouwt om zelfstandig te handelen.

TypeSafe traint Jev volgens eigen zeggen met een methode die het Reinforcement Learning for Calibrated Decisions — RLCD noemt.

Het doel is dat confidence daadwerkelijk iets betekent.

Als een model bij honderd beslissingen ongeveer 90% confidence rapporteert, wil je idealiter dat ongeveer negentig daarvan correct blijken.

Daarmee kun je software bouwen die zegt:

> 98% → automatisch uitvoeren
80–98% → extra AI-controle
< 80% → mens inschakelen

Dat is voor automatisering veel waardevoller dan een model dat altijd overtuigend klinkt.

Maar er zit een belangrijke beperking aan

Jev kan geen wonderen verrichten.

OpenRouter vergeleek Jev ook met een traditionele LLM-as-a-Judge.

Bij gesloten beoordelingscriteria — waar de relevante informatie aanwezig was en het gewenste oordeel duidelijk gedefinieerd — deed Jev het volgens die test vergelijkbaar met een LLM-judge, terwijl het ongeveer een vijfde kostte en circa een tiende van de latency gebruikte.

Maar bij een open beoordelingsvraag, waarbij bijvoorbeeld de kwaliteit van een compleet nieuwsartikel beoordeeld moest worden, presteerde het traditionele taalmodel duidelijk beter.

Dat is logisch.

“Is deze bewering ondersteund door deze bron?” is een relatief afgebakende beslissing.

“Is dit een briljant en origineel artikel?” is dat niet.

Jev vervangt reasoning dus niet.

Het reduceert hoeveel reasoning je nodig hebt.

En dat onderscheid is belangrijk.

Misschien kijken we verkeerd naar de AI-race

De afgelopen jaren ging bijna alle aandacht naar één vraag:

Wie heeft het slimste model?

GPT versus Claude versus Gemini versus DeepSeek.

Maar softwaregeschiedenis suggereert dat infrastructuur uiteindelijk zelden uit één gigantische component bestaat.

We bouwen systemen uit gespecialiseerde onderdelen.

Databases.

Caches.

Queues.

Search engines.

Load balancers.

API’s.

Misschien gebeurt met AI hetzelfde.

Dan hebben we straks modellen die bijzonder goed kunnen redeneren, modellen die code genereren, modellen die zoeken, modellen die beelden begrijpen — en modellen die vrijwel uitsluitend beslissingen nemen.

Jev is een vroeg voorbeeld van die laatste categorie.

En juist omdat het minder kan dan een traditioneel taalmodel, kan het voor sommige toepassingen veel bruikbaarder zijn.

De echte innovatie is misschien niet Jev zelf

Of Jev uiteindelijk dé standaard voor deze beslissingslaag wordt, is onmogelijk te zeggen. Het model is pas net beschikbaar en veel claims komen logischerwijs van TypeSafe zelf.

Belangrijker is daarom het idee dat erachter zit.

De eerste AI-golf draaide om:

machines die taal kunnen produceren.

De huidige agentgolf draait steeds meer om:

machines die werk kunnen uitvoeren.

En zodra AI daadwerkelijk werk uitvoert, bestaat het grootste deel van zijn dag misschien helemaal niet uit schrijven of uitgebreid redeneren.

Het bestaat uit duizenden kleine beslissingen.

Doorgaan.

Stoppen.

Controleren.

Escaleren.

Kiezen.

Routeren.

Scoren.

Daarvoor heb je misschien helemaal geen chatbot nodig.

Je hebt een intelligente if-statement nodig.

En precies dat probeert Jev te worden.

Bronnen en verantwoording