Jev AI: het beslismodel van TypeSafe AI uitgelegd

Jev AI is een AI-model van TypeSafe AI dat geen tekst schrijft, maar alleen beslissingen teruggeeft: een keuze uit een lijst, een score of een ja/nee-kans. Het is gemaakt voor software die snel en goedkoop veel beslissingen moet nemen, zoals supporttickets routeren of risico's inschatten. In dit artikel lees je hoe Jev werkt, hoe het verschilt van een taalmodel zoals ChatGPT, en hoe je het verstandig inzet.

Belangrijkste inzichten

• Jev AI is een ‘System One’-model van TypeSafe AI dat alleen beslissingen teruggeeft (Choice, Score en een ja/nee-vraag) met kansen en een zekerheidsscore, zonder tekst te genereren.

• Is Jev een taalmodel? Nee. Jev is expliciet géén taalmodel, maar een beslismodel dat in hybride workflows vaak naast een generatief model draait, maar zelf geen tekst produceert.

• Het kernvoordeel: extreem lage latentie, lage kosten per beslissing en een goed gekalibreerde choice score waarmee je in productie betrouwbaar kunt automatiseren.

• Lees verder voor een stapsgewijze uitleg over hoe je Jev in je software opneemt, van de eerste schaduwtest tot volledige automatisering.

Wat is Jev AI precies?

Jev is een gehost ai model van TypeSafe AI. Het ontvangt een state (de context van je vraag) plus getypeerde vragen - zogenaamde primitives - en stuurt gestructureerde antwoorden terug. Geen vrije tekst, geen samenvattingen, geen uitleg. Alleen gestructureerde beslissingen met waarschijnlijkheden.

Jev is een system one model: het neemt beslissingen in één stap, zonder keten van tokens, zonder zichtbaar redeneren. Je krijgt direct een uitkomst die software veilig kan gebruiken. Het model is ontworpen voor snelle, intuïtieve beslissingen. Jev verwerkt een state en een set vragen, en geeft besluiten terug met kansen en confidence-scores.

Jev werd uitgebracht op 15 september 2026 en is beschikbaar in early access via een API. TypeSafe AI werd opgericht door voormalige onderzoekers van OpenAI, onder wie Diogo Almeida, een van de bedenkers van RLHF (het trainen van taalmodellen met menselijke feedback).

Wat Jev wél doet:

• Eén optie kiezen uit een lijst (Choice)

• Een score toekennen op een schaal (Score)

• Een ja-of-neevraag beantwoorden met een kanswaarde (Noul)

• Meerdere van deze vragen parallel verwerken in één aanroep

Wat Jev niet doet:

• Tekst schrijven

• Uitleg of redenering geven

• Zelf informatie opzoeken op het internet

• Rekenen: Jev is geen rekenmachine

Waarom Jev geen taalmodel is: ‘System One’-denken

Veel mensen die voor het eerst over Jev horen, denken: "Is dit gewoon een nieuwe taalmodel?" Het antwoord is nee. TypeSafe zegt expliciet dat Jev geen generatief model is. Het genereert geen tekst, het produceert geen stap-voor-stap tokens. Het is een aparte categorie: decision-only.

Het verschil zit in de denkwijze. Denk aan het onderscheid fast en slow van Daniel Kahneman. Een taalmodel werkt als Systeem 2: langzaam, bewust, stap voor stap redeneren over complexe problemen. Jev werkt als system one: direct, intuïtief, zonder zichtbaar denkproces. In plaats van lange instructies stuur je compacte, getypeerde vragen die je in code definieert.

Concrete voorbeelden om het verschil voelbaar te maken:

• Routing: "Stuur dit supportticket naar facturatie, technisch of accountbeheer." Jev kiest in milliseconden de juiste categorie.

• Risicobeoordeling: "Is dit verzoek hoog risico?" Jev geeft een kans tussen 0 en 1 terug. Een Noul-beslissing, geen essay.

• Gereedschapskeuze voor agents: "Welk gereedschap moet de agent nu gebruiken?" Jev selecteert uit een vooraf gedefinieerde lijst, zodat de agent direct kan handelen.

Bij geen van deze taken heb je gegenereerde tekst nodig. Jev beslist, en je code handelt.

De drie primitives: Choice, Score en Noul

Alle interactie met Jev loopt via drie vaste vraagtypen. Dit maakt het model typesafe en voorspelbaar: je weet altijd precies welke vorm de output heeft.

Choice - Kiest één optie uit een vaste lijst (volgens TypeSafe maximaal 255 opties). Per optie krijg je een waarschijnlijkheid en een aparte confidence score. Gebruik dit wanneer je precies één label nodig hebt, zoals een afdeling, categorie of actietype. Choice selecteert één optie uit een lijst en geeft daarbij een choice score per optie.

Score - Beoordeelt de state op een ordinale schaal van twee tot tien niveaus. Denk aan urgentie, prioriteit of scoring van risico. Jev kan een waarde geven die tussen twee niveaus in ligt, plus een kansverdeling over alle niveaus. Score beoordeelt de staat op een schaal van twee tot tien.

Ja/nee (‘Noul’) - Beantwoordt een ja-of-neevraag met een waarde tussen 0 en 1. Klopt deze bewering? Moet dit geblokkeerd worden? Is er sprake van vertrouwelijke informatie? De kanswaarde is hier meteen de maat van zekerheid; een aparte confidence ontbreekt bewust. Jev kan ja/nee-vragen beantwoorden met een kanswaarde.

Het sterke punt: alle drie vraagtypen kunnen in één aanroep worden gecombineerd. Je stuurt één verzoek met een state en meerdere vragen, en Jev beoordeelt ze parallel en onafhankelijk. Zo neem je in één pass tientallen beslissingen over dezelfde input.

Hoe werkt Jev onder de motorkap?

Jev is een transformer-gebaseerd ai model, maar specifiek zo getraind dat het in één stap een volledige kansverdeling per vraag geeft. Volgens TypeSafe verwerkt Jev lange invoer, ruim genoeg voor uitgebreide documenten of JSON-objecten.

De input state kan een gewone tekst zijn, een JSON-object of een array van berichten. Alles wat je applicatie relevant vindt, stop je in die state. Jev leest dit als context en retourneert strikt getypeerde output: kansen, labels en confidence-waarden. Geen vrije tekst, geen onverwachte velden.

Jev verwerkt vragen parallel en onafhankelijk voor snellere evaluatie. Dat betekent: geen volgordeproblemen, geen contextlek tussen vragen, en stabiele latentie ongeacht hoeveel vragen je meestuurt. Jev verwerkt de invoer in één keer, anders dan taalmodellen die woord voor woord genereren.

Er is geen stap-voor-stap redenering zichtbaar. Het model produceert alleen eindbeslissingen. Stel je het voor als een pijplijnblok in je workflow: data gaat erin, gestructureerde antwoorden komen eruit, en je applicatie bepaalt wat er vervolgens gebeurt. Audit en foutopsporing verplaats je dus bewust naar je eigen code.

RLCD, calibratie en vertrouwen in de choice score

Calibratie betekent: als Jev een kans van 0,8 aangeeft, hoort het over veel beslissingen in de praktijk ongeveer 80 procent van de tijd correct te zijn. Dat klinkt simpel, maar de meeste modellen zijn hier slecht in. Ze zijn te zelfverzekerd of juist te voorzichtig.

TypeSafe's system one model is getraind met een methode genaamd RLCD: reinforcement learning voor calibrated decisions. Het doel is niet alleen gelijk hebben, maar ook eerlijk zijn over onzekerheid.

Het verschil tussen kans en confidence:

• Kans per label: hoe waarschijnlijk is elke optie? Bijvoorbeeld: "facturatie" 72%, "technisch" 25%, "account" 3%.

• Confidence: hoe scherp is de verdeling? Een hoge confidence score betekent dat het model overtuigd is. Een lage zekerheid wijst op twijfel en is een signaal om voorzichtig te zijn.

In de praktijk betekent dit: bij lage confidence stuur je het geval door naar een mens of een duurder generatief model. Bij hoge confidence en laag risico automatiseer je direct. Goed gekalibreerde scores zijn cruciaal voor typesafe AI in productie, zeker bij compliance-gevoelige beslissingen.

Jev versus een taalmodel

TypeSafe claimt dat Jev voor vergelijkbare beslistaken vele malen sneller en goedkoper is dan een groot taalmodel. Dat zijn cijfers van de maker; meet het zelf op je eigen data voordat je erop bouwt. De conclusie is niet ‘of-of’ maar ‘en-en’: Jev beslist, een taalmodel schrijft of redeneert.

Jev als typesafe AI: schema's, garanties en beperkingen

Het concept typesafe AI betekent dat je applicatie precies weet welk type waarde het ontvangt. Geen verrassingen, geen parsingfouten, geen onverwachte strings. Jev geeft altijd gestructureerde uitkomsten met zekerheidsscores, binnen het vooraf vastgelegde schema.

Jev kan geen hallucinaties genereren in de traditionele zin: het produceert geen zelfverzonnen labels, velden of tekst. Maar Jev kan wel verkeerde keuzes maken binnen het schema. Een e-mail over facturatie kan per ongeluk als "technisch" worden bestempeld. De scores maken die fouten zichtbaar, zodat je erop kunt reageren.

Voorbeelden van veilige vertakkingen in code:

• Als de Noul-waarde voor "is dit vertrouwelijk?" boven 0,9 ligt → blokkeer automatisch

• Als de Choice voor routing "facturatie" teruggeeft met confidence boven 0,85 → stuur direct door

• Als de Score voor urgentie op het hoogste niveau uitkomt → markeer als prioriteit

Typesafe betekent voorspelbare vormen van output, niet perfecte inhoud. De verantwoordelijkheid voor de juiste acties blijft bij het systeemontwerp.

System One in actie: typische Jev AI use cases

Jev blinkt uit in hoge-volume, lage-latentie beslissingen diep in software - niet in chatvensters.

Supportticket-triage: Jev classificeert tickets en beoordeelt urgentie. Het bepaalt in één aanroep de afdeling (Choice), de prioriteit (Score) en of er sprake is van een terugbetaling (Noul). Jev categoriseert snel binnenkomende data en gebruikersinteracties. Een taalmodel schrijft vervolgens het antwoord aan de klant.

Contentmoderatie: Jev beoordeelt of content in strijd is met beleidsregels (Noul), kiest de juiste categorie (Choice) en scoort de ernst (Score). Onzekere gevallen gaan naar een menselijke moderator. Jev kan beslissingen nemen zonder tekstoutput.

Risicoscoring in fintech: Jev fungeert als een beslissingslaag die structuren aanbrengt in software. Het scoort risico, controleert compliance en vlagt verdachte patronen. Jev kan risicovolle tool-aanroepen in real-time controleren.

Leadkwalificatie: Choice bepaalt het type contact, Score schat de kans op conversie en Noul checkt budgetbeschikbaarheid. Jev is ontworpen om terugkerende beslissingen te automatiseren en is voordelig voor bedrijven die veel terugkerende beslissingen nemen.

Bij al deze toepassingen geldt hetzelfde patroon: Jev beslist, het taalmodel doet de rest: tekst schrijven, uitleggen waarom, of rapporten maken.

Hybride workflows: Jev naast een LLM in de praktijk

De kracht van Jev wordt pas echt zichtbaar als je het combineert met een generatief model in één architectuur. Hier volgt een concreet patroon, stap voor stap:

1. Verzoek binnenkomt: een gebruiker stuurt een bericht, document of formulier.

2. Verrijk de state: je applicatie haalt relevante context op uit databases of zoekindexen en bouwt de state op.

3. Jev beslist: model routing vindt plaats. Jev bepaalt de categorie, urgentie en of verdere verwerking nodig is. Jev kan snel bepalen welke AI-modellen moeten worden ingezet voor specifieke taken.

4. Alleen complexe gevallen naar een taalmodel: bij hoge confidence handelt je code het zelf af. Bij lage confidence of hoog risico schakelt een duurder ai model in voor diepere analyse.

Een concreet voorbeeld: een agent die gereedschappen moet kiezen. Jev selecteert het juiste gereedschap uit een lijst (Choice) en voert tegelijk een veiligheidscheck uit (Noul). Alleen als het gekozen gereedschap een complexe interactie vereist, neemt het taalmodel het over. Confidence-gebaseerde routing bepaalt dus of code, mens of taalmodel aan zet is.

Jev wordt gebruikt voor automatiseringstaken in softwareontwikkeling en AI-pipelines, als de dunne maar essentiële beslislaag.

Jev AI integreren in je bestaande stack

Jev roep je aan als externe service: je hebt een API-sleutel en een eindpunt nodig. Kies bewust een versie (bijvoorbeeld jev-latest of een vast versienummer) om onverwacht gedrag bij updates te voorkomen. Jev kan worden geïntegreerd in bestaande softwaresystemen via een standaard HTTP-aanroep.

Een typische aanroep bevat:

• Een state-object (de context als tekst, JSON of berichtenarray)

• Een verzameling vragen met het type (Choice, Score of Noul) en de antwoordruimte

• De respons bevat dezelfde sleutels, aangevuld met getypeerde antwoorden, kansen en confidence

Combineer Jev met je bestaande observeerbaarheid. Log per vraag de choice score, confidence en input als kernmetrics. Zo bouw je een auditspoor op en zie je snel wanneer prestaties veranderen.

Voor een veilige uitrol: begin in schaduwmodus naast menselijke beslissingen. Vergelijk uitkomsten, verfijn drempels, en automatiseer pas de duidelijkste gevallen. Automatisering voeg je geleidelijk toe.

Operationele grenzen en failure modes van Jev

Elk model - ook een system one model - heeft zwakke punten die je expliciet moet kennen.

Beperkingen:

• Geen tekstgeneratie, geen uitleg, geen redeneren

• Beperkt tot de aangeleverde state; geen internettoegang, geen eigen kennisbank

• Jev is geen rekenmachine: het kan niet betrouwbaar tellen of rekenen

• Afhankelijk van goede vraagformulering; een verkeerd gekozen primitief leidt tot onbruikbare output

• Geen uitleg waarom een beslissing is genomen

Typische fouten:

• Verkeerd label binnen het schema, vooral bij randgevallen

• Te hoge confidence op ambigue gevallen

• Overmatig vertrouwen in één Score zonder menselijke controle

Tips voor veilig mislukken:

• Stel een drempel in: bij lage zekerheid → altijd terugvallen naar mens of taalmodel

• Beperk automatische acties tot laagrisicogevallen

• Monitor distributies over tijd (drift) en vergelijk met referentiemodellen

• Log alles: elke beslissing, elke confidence, elke input voor audits

Wanneer kies je Jev AI, en wanneer juist een generatief model?

Een eenvoudige vuistregel: kies Jev als je eindigt in een beslissing die code direct gebruikt. Kies een taalmodel als het resultaat door mensen gelezen of bewerkt wordt.

Typische Jev-taken:

• Classificeren van berichten, tickets of documenten

• Routing naar de juiste afdeling of workflow

• Scoring van risico, urgentie of relevantie

• Moderatie en pre-executiechecks

• Model routing binnen agents

Typische taalmodeltaken:

• Rapporten of e-mails schrijven

• Code genereren

• Lange samenvattingen van een document maken

• Ketenredenering over meerdere stappen

In de praktijk combineren de meeste serieuze systemen beide: Jev voor de dunne beslislaag, een taalmodel voor rijke, taalintensieve output. Het advies: inventariseer in je bestaande stromen welke aanroepen eigenlijk "beslissingen" zijn, en verplaats die stap voor stap naar Jev. Volgens TypeSafe is Jev nauwkeuriger in beslistaken dan brede taalmodellen, juist omdat het zich volledig op beslissen richt. Meet dat zelf op je eigen data.

Praktische eerste stappen met Jev AI (stap voor stap)

Hier volgt een concrete aanpak om Jev in een klein pilotproject te testen. Geen grote migratie, geen risico - gewoon leren en meten.

Stap 1: Kies één repetitieve, gestructureerde taak waar je nu regels of een taalmodel voor gebruikt. Denk aan ticket routing of contentmoderatie.

Stap 2: Definieer de state - welke velden stuur je mee? - en de vragen. Welke Choice, Score of Noul heb je nodig? Definieer expliciete antwoordruimtes, geen open einden.

Stap 3: Draai Jev eerst in schaduwmodus naast menselijke beslissingen of een bestaand model. Vergelijk de uitkomsten, de choice score en de confidence. Meet waar Jev het eens is met de menselijke beoordelaar en waar niet.

Stap 4: Stel drempels in voor confidence en implementeer beperkte automatische acties voor de duidelijkste gevallen. Houd alles gelogd en monitor de impact op je proces.

Door de lage prijs per beslissing hoeven de kosten geen obstakel te zijn, ook niet bij grote aantallen per dag.

Beslismodellen en de toekomst van zoeken

Modellen als Jev maken het goedkoop om software overal kleine beslissingen te laten nemen, ook bij het kiezen van welke bron, welk product of welk bedrijf een AI-agent gebruikt. Hoe duidelijker en betrouwbaarder de informatie over jouw bedrijf, hoe groter de kans dat zo'n keuze op jou valt. Lees meer over generative engine optimization, over AI-agenten in onze artikelen over Hermes en Fetch.ai, of vraag de gratis AI audit aan.

Conclusie

Jev AI is een nieuw soort AI-model: geen schrijver, maar een snelle beslisser. Voor software die veel kleine, gestructureerde beslissingen neemt, zoals routeren, scoren en controleren, kan het een goedkoop en snel alternatief zijn voor een taalmodel. Begin met één taak in schaduwmodus, werk met drempels voor zekerheid en laat twijfelgevallen altijd naar een mens of taalmodel gaan.