Oordelen zonder te schrijven.

Jev komt van TypeSafe AI, dat het een System One-model noemt, naar het snelle, intuïtieve denken dat Daniel Kahneman “systeem 1” noemde. Je geeft het model gegevens en een vraag met vaste antwoordopties, en het geeft een keuze terug met een kansverdeling erbij. Geen tekst, geen uitleg, geen “Goede vraag!”.

Je kunt drie soorten vragen stellen: een ja-neevraag, waarbij de kans zelf het antwoord is, een keuze uit maximaal 255 opties die je elk in gewone taal beschrijft, of een positie op een schaal van twee tot tien niveaus. Meerdere vragen gaan in één verzoek mee en worden tegelijk beantwoord.

Jev is getraind met een vorm van reinforcement learning die TypeSafe Reinforcement Learning for Calibrated Decisions noemt, kortweg RLCD. Het is familie van de methode waarmee chatmodellen leerden behulpzaam te antwoorden (RLHF) en van de methode achter de huidige redeneermodellen (RLVR), met een eigen doel: het model wordt beloond voor een beslissing met een kans die klopt. Hoe groot Jev is en hoe het in elkaar zit, maakt TypeSafe niet bekend.

Die kans maakt het model bruikbaar in een systeem. Volgens TypeSafe hoort over veel antwoorden gemeten een kans van 0,8 ongeveer acht van de tien keer bij een goed antwoord, al zegt dat over één los antwoord weinig. Je zet er dus een drempel op: boven de 0,8 handel je automatisch af, en wat eronder blijft gaat naar een slimmer model of een mens.

Volgens TypeSafe scoort Jev op dit soort vragen gemiddeld ongeveer als GPT-5.6 Terra, terwijl het veertig tot tweehonderd keer sneller antwoordt. Die vergelijking komt uit eigen tests, met het gemiddelde antwoord van GPT-6 Astra en Fable 5.1 als maatstaf; op publieke benchmarks publiceert TypeSafe bewust niets.

De zwakke plekken staan in de documentatie en zijn goed te voorspellen. Tellen en rekenen gaan slecht en datums leest het als tekst. Engels is de primaire trainingstaal; Nederlands werkt, met iets minder zekerheid. In de praktijk maakte vooral uit dat Jev letterlijk leest. Het “answers the question you wrote, not the one you meant”, zoals de documentatie het zelf zegt.

Wij gingen er eerst van uit dat het model ongevoelig was voor instructies die in een mail verstopt zitten, omdat gegevens en vragen in aparte velden staan. TypeSafe schrijft zelf dat dat niet klopt: tekst die het antwoord bewust probeert te sturen, kan dat antwoord ook verschuiven. Bij een sorteervraag is dat risico klein, maar wie Jev loslaat op invoer van onbekenden, test daar apart op.

Classificatiemodellen bestaan al zo lang als spamfilters, en modellen die kiezen uit opties die je in gewone taal beschrijft, zijn ook al jaren beschikbaar. Jev heeft de aanpak vooral op de kaart gezet, met kansen die volgens de maker kloppen en een niveau dat in de buurt komt van de grote taalmodellen. Een dag na de lancering verscheen al een open variant, SemIf, die hetzelfde doet met een bestaand open model van vier miljard parameters, een fractie van de honderden miljarden van de grootste taalmodellen.

Dat kan omdat kiezen uit een paar opties veel minder rekenwerk is dan tekst schrijven. SemIf draait op één gamekaart uit 2020 en neemt daar 21 beslissingen in ongeveer een seconde, tegen ruim vijf seconden als hetzelfde model de antwoorden moet uitschrijven. Op eenvoudige vragen is het volgens de nog jonge benchmark JevBench even nauwkeurig als Jev; bij de moeilijkste vragen haalt het 60% tegen 74% voor Jev. Voor bedrijven die gevoelige data liever in huis houden, is dat relevant. TypeSafe belooft niet te trainen op wat je instuurt, maar draait in de Verenigde Staten.

Wat Jev interessant maakt voor de bouw van systemen, is de combinatie van snelheid en prijs. TypeSafe noemt een antwoordtijd van 70 tot 500 milliseconden, en zet in een eigen demo 0,11 seconde tegenover 8,6 seconden voor een taalmodel. Vanuit Nederland meten wij 0,6 tot 1 seconde, netwerk inbegrepen.

Bij ongeveer twee honderdste cent per mail kun je een classificatiemodel overal laten meekijken: bij elke binnenkomende mail, elke nieuwe order, elk bericht in een kanaal en elke foutmelding in een systeem. Dat is een andere manier van denken over AI. Een taalmodel roep je aan zodra er werk ligt, terwijl een classificatiemodel werkt als een wachter: het ziet elke gebeurtenis en haalt alleen een duurder model of een mens erbij wanneer er iets te doen is.

Wat je eigenlijk wilt weten, is steeds of er iets moet gebeuren. Die vraag stel je alleen zo dat het antwoord in het bericht zelf te zien is. Of iets een automatisch statusbericht is of een foutmelding, kan een classificatiemodel betrouwbaar zeggen. Of het belangrijk is voor jouw bedrijf, vraagt kennis van dat bedrijf en hoort bij het taalmodel dat daarna komt.

Voor zulke stromen is een vaste regel in code te grof, en een taalmodel per item vaak te traag of te duur voor het volume. Een klantenservice kan elk bericht een soort geven, zoals klacht of vraag over een bestelling, voordat iemand het opent. Een koppeling tussen webshop en voorraad kan bij elke order kijken of er een opmerking van de klant bij staat, zoals een afwijkend afleveradres. Een formulier kan al tijdens het typen bepalen naar welke afdeling een vraag gaat. En in een stroom foutmeldingen komen dan alleen de nieuwe, ernstige meldingen bij een mens terecht.

De gebruikelijke opzet is één grote aanroep, waarin een taalmodel alles tegelijk beslist: wat voor bericht dit is, voor wie, wat ermee moet en of het al bekend is. Met een snel classificatiemodel knip je dat op in losse beslissingen die na elkaar komen, als takken van een boom. Elke vraag heeft een paar opties en elk antwoord bepaalt welke vraag volgt. In de mail van Accelar is de helft van de items na de eerste vraag al afgehandeld.

Het taalmodel komt pas aan het eind, op de takken waar kennis van je bedrijf nodig is, en krijgt dan een item waarvan al vaststaat wat het is en bij wie het hoort. Met de kennistekst erbij schrijft het uit welke taken en besluiten erin staan en wat er in het dossier komt. Dat scheelt tijd en geld. Het maakt fouten ook vindbaar: omdat elke tak een eigen vraag en drempel heeft, zie je bij een fout op welke vraag het misging en met welke kans.

Twee ontwerpkeuzes bepalen of zo’n boom te vertrouwen is. De eerste is de kant waarop je bij twijfel valt. Een item dat onnodig naar het taalmodel gaat, kost een paar tienden van een cent; een item dat onterecht wordt afgesloten, ziet nooit meer iemand. De drempels staan daarom zo dat twijfel doorloopt naar het slimmere model. De tweede keuze is wat je aan gewone code overlaat. Dat is alleen wat zonder twijfel vaststaat, zoals een e-mailadres dat bij precies één klant hoort, en alles wat meestal klopt gaat als vraag naar een model.

Sinds september 2026 verwerkt het systeem achter Accelar alle binnenkomende mail en gesprekken op deze manier. Jev sorteert, en het taalmodel GPT-6 Luna werkt uit wat daarna overblijft.

In de eerste opzet kreeg Jev vijf vragen per mail: staat hier een taak in, staat hier een besluit in, moet er gereageerd worden, is het een factuur en moet er iets beslist worden? Naast een handmatig oordeel over 100 mails leverde dat 73 afwijkingen op.

“Staat hier een besluit in?” betekent voor een mens: is hier iets besloten dat ik wil onthouden. Jev leest: komt er een besluit in deze tekst voor. Een automatische samenvatting van een meeting bevat altijd besluiten, dus Jev zei steeds ja, en had letterlijk gelijk. Daarbij overlapten de vragen. Taak, reageren en beslissen zijn voor een mens drie kanten van dezelfde situatie, waarin de bal bij jou ligt, en een model dat elke vraag los beantwoordt, verdeelt zijn twijfel dan willekeurig over drie vragen.

De tweede versie stelt één vraag: wat voor soort mail is dit? Er zijn vier opties die elkaar uitsluiten: persoonlijk geschreven, factuur, melding of ruis. Die grens ligt bij de vorm, niet bij het belang. Of een mens of een machine iets schreef, en of er iets stukgaat als niemand reageert, is aan de mail zelf te zien. Wat er met de mail moet gebeuren, beslist daarna het taalmodel, met een paar pagina’s tekst over hoe er bij Accelar met mail wordt omgegaan.

Op dezelfde 100 mails sorteerde Jev er 100 goed. Die mails lagen wel op tafel bij het schrijven van de beschrijvingen, dus de eerlijkere toets is een tweede set van 119 oudere mails die daarbij niet gebruikt zijn. Daarvan handelde Jev er 68 af als ruis, met een kans boven 0,8 en zonder taalmodel, en nooit bij een mail waar het oude systeem wel iets mee deed. Waar Jev het oneens was met dat oude systeem, had het gelijk: berichten als “build failed” of “DOWN” bij een systeem van een klant had het oude systeem als ruis weggezet.

De vraag bij welke klant of relatie een mail hoort, klopte bij alle 50 mails uit de eerste set die geen ruis waren. Bij 21 stond dat al vast op e-mailadres of domein; de andere 29 koos Jev uit alle relaties, op basis van een korte herkenningstekst per relatie.

Omdat Jev vooral op Engels getraind is, draaide dezelfde sorteervraag op de 119 ongeziene mails twee keer, met Nederlandse en met Engelse beschrijvingen bij de opties. De mails zelf bleven Nederlands.

Met Engelse beschrijvingen was Jev vaker zeker genoeg, 68 keer tegen 61, zonder extra fouten. Teksten die alleen het classificatiemodel leest, zijn daarom in het Engels geschreven; teksten die ook het taalmodel of een mens leest, blijven Nederlands.

Neem een maand met 300 mails en 30 gesprekken. Taalmodellen rekenen in tokens, stukjes tekst van een paar letters, en per mail gaan er gemiddeld zo’n 4.500 tokens naar Jev, voor de soort, de relatie en later de controle op dubbelen. De helft van de mails komt door de eerste vraag en gaat naar Luna, samen met de kennistekst en de gegevens van die ene relatie. Een gesprek is groter: het hele transcript gaat mee, en Luna denkt daar langer over na.

Daarvoor houdt het systeem per klant, project en persoon een dossier bij van wat er speelt, met de taken, besluiten en mijlpalen uit elke mail en elk gesprek. Waar het systeem twijfelt, zet het een vraag op een beslislijst.

Met een goedkoop taalmodel als Luna is geld bij dit volume geen argument meer; ook alles via Luna zou maar een paar euro per maand kosten. De winst van Jev zit hier in de snelheid en in de kans bij elke beslissing, waardoor je een fout kunt terugvinden. Bij grotere volumes of zwaardere modellen telt de prijs wel: Jev kost per mail ongeveer een tiende van een Luna-aanroep, en volgens TypeSafe is de invoerprijs 238 keer lager dan die van Claude Fable 5.1. Bij tienduizend mail-grote items per dag kost Jev zo’n zestig dollar per maand, en hetzelfde werk via Luna rond de zeshonderd.

Buiten de testset gaat het ook weleens mis. Bij het transcript van een gesprek koos Jev de verkeerde van twee verwante relaties, en een betaalbevestiging is voor het systeem de ene keer een factuur en de andere keer iets om alleen te lezen. Zulke fouten zie je alleen als nakijken makkelijk is, en daarom is dat vanaf het begin onderdeel van de opzet.

Op een nakijkpagina staat per mail en per gesprek wat er besloten is, door welk model en met welke kans of reden. Klopt iets niet, dan klik je op “klopt niet”, kies je wat het had moeten zijn en typ je eventueel waarom. Wat je niet aanraakt, geldt als goed.

Elke afkeuring wijst zo de tekst aan die de fix krijgt, waardoor aanpassingen niet in de verkeerde tekst belanden. Elke wijziging gaat eerst langs dezelfde testset, met het menselijke oordeel als maatstaf. En het model staat vast op één versie, zodat een update van TypeSafe de drempels niet ongemerkt verschuift.

Wie één taalmodel op alles zet, merkt de nadelen pas in productie. Elk item wacht op een model dat eerst moet nadenken, en bij een fout zie je niet in welke stap hij zat. Een snel classificatiemodel ervoor maakt twee dingen haalbaar: altijd meekijken, en beslissingen opknippen in kleine stappen die elk te controleren zijn.

Begin klein, met één stroom met veel volume en weinig signaal, zoals klantvragen of meldingen uit systemen, en één vraag die aan de vorm te beantwoorden is. Schrijf per optie op wat het is en wat het niet is, met een paar echte voorbeelden erbij. Bouw vanaf de eerste dag een plek om beslissingen af te keuren, voor de collega die het werk nu doet, met de juiste keuze en een reden erbij; die afkeuringen worden vanzelf je testset.

Tussen de eerste en de tweede versie van de mailverwerking bleef het model hetzelfde. Alleen de vragen en de beschrijvingen veranderden, en dat is vakkennis op papier die elk bedrijf al in huis heeft.