Beslissingsmodellen (1): je hebt geen duizend woorden nodig om te beslissen

Al drie jaar zijn we gewend geraakt om kunstmatige intelligentie te associëren met tekstgeneratie. Men stelt een model een vraag, het denkt na, het produceert enkele tientallen of enkele honderden woorden. Een mens leest het antwoord, of een programma haalt het resultaat op en probeert er iets mee te doen.

Deze manier van werken is volkomen logisch voor het opstellen van een brief, het samenvatten van een consult of het schrijven van code. Ze is veel minder logisch wanneer men alleen een beslissing wil nemen. En een groot deel van wat wij voor onze klanten automatiseren, komt neer op één beslissing: gaat deze e-mail naar het secretariaat of naar de boekhouding, is dit dossier compleet, is dit bericht van een patiënt urgent.

Op 15 september 2026 presenteerde een bedrijf uit San Francisco, TypeSafe AI, een model dat precies dat doet. Het heet Jev, en het kan geen zin schrijven. Dit eerste deel legt uit wat dit model verandert ten opzichte van een generatief model, wat geverifieerd is en wat nog niet, en waarom dezelfde capaciteit gedeeltelijk al bestond in de open modellen die iedereen thuis kan draaien. Het tweede deel kijkt naar wat er met automatisering gebeurt wanneer een beslissing honderd milliseconden kost in plaats van tien seconden.

Wat een generatief model werkelijk doet wanneer men het om een beslissing vraagt

Neem een alledaags voorbeeld. Een klant schrijft: “Ik heb mijn bestelling ontvangen, maar het product is kapot.” We willen weten naar welke dienst het bericht moet, met welke prioriteit, en of een terugbetaling mogelijk is.

De gangbare praktijk bestaat erin een groot taalmodel te vragen te antwoorden in een gestructureerd formaat dat het programma kan lezen. Het model schrijft dan, in de vorm van tekst, het equivalent van deze kleine tabel:

Het is de moeite waard om te bekijken hoe dit resultaat tot stand komt. Een taalmodel schrijft in kleine tekstbrokjes, die we tokens noemen (tokens in het Engels): een woord, een deel van een woord, een accolade, een aanhalingsteken. Elk token wordt gekozen op basis van alle voorgaande tokens, één voor één. Het antwoord hierboven bestaat uit een dertigtal tokens, dus een dertigtal opeenvolgende doorgangen door het model. De “gestructureerde uitvoer” die aanbieders voorstellen, verandert niets aan dit mechanisme: bij elke stap worden de tokens verboden die het formaat zouden breken, maar het antwoord blijft token voor token geschreven.

Ons programma wacht vervolgens tot de tekst klaar is, controleert of ze correct is opgebouwd, haalt er de velden uit, en past dan zijn eigen regel toe. Het volledige traject ziet er zo uit:

Deze omweg kost tijd, enkele seconden per aanroep, en opent de deur voor formatteringsfouten die het programma daarna moet opvangen.

Een model dat niet kan schrijven

Jev schrapt deze omweg. Het programma stuurt het een toestand, dat wil zeggen een beschrijving van de situatie in vrije tekst of in gegevens, en een of meer vragen waarvan de mogelijke antwoorden vooraf vastliggen. TypeSafe biedt drie soorten vragen aan: een keuze tussen benoemde opties, een score op een schaal die door niveaus wordt beschreven, en een ja-of-nee-antwoord. Het model geeft voor elke vraag een getypeerde waarde en een waarschijnlijkheid per optie terug. Hier volgt, vereenvoudigd, het soort antwoord dat TypeSafe documenteert:

Er is geen tekst meer te interpreteren. De mogelijke uitkomsten waren vastgelegd vóór de aanroep, en het programma ontvangt getallen die het kan vergelijken met een drempel. Alle vragen die over eenzelfde toestand worden gesteld, worden samen geëvalueerd, in één enkele doorgang, en niet na elkaar.

Naast elkaar gezet, komen de twee trajecten hierop neer:

Dit is het punt dat de nadruk verdient, want de rest vloeit eruit voort. Tot nu toe was de beslissing een bijproduct van de generatie: men liet het model schrijven, en las vervolgens in zijn tekst af wat het had beslist. Jev keert deze relatie om.

TypeSafe noemt Jev een “System One Model”. De uitdrukking verwijst naar de twee denksystemen die de psycholoog Daniel Kahneman beschreef: systeem 1, snel en intuïtief, dat een gezicht herkent of aanvoelt dat een bericht agressief is zonder erover na te denken, en systeem 2, traag en weloverwogen, dat een vermenigvuldiging maakt of een argument afweegt. De redeneermodellen die in 2024 en 2025 verschenen, de modellen die “nadenken” voordat ze antwoorden, werden voorgesteld als kunstmatige systeem-2-modellen. TypeSafe doet het omgekeerde en claimt een systeem 1: een onmiddellijk oordeel, zonder geschreven redenering, verkocht als een volwaardig product op zich.

TypeSafe leidt daaruit een sterke bewering af, die in de aankondiging zo staat.

Men zegt van een taalmodel dat het hallucineert wanneer het met grote stelligheid iets onjuist of verzonnen schrijft. In strikte zin klopt de bewering: een model dat niets schrijft, kan geen optie, geen veld en geen feit verzinnen, en zijn antwoord blijft altijd binnen de keuzes die het heeft gekregen. Dat betekent nog niet dat de keuze juist is. Jev kan nog steeds de verkeerde optie kiezen met een hoog vertrouwen, en daarom is de kwaliteit van de waarschijnlijkheden die het teruggeeft zo belangrijk.

Het bedrijf beschrijft een trainingsmethode die het Reinforcement Learning for Calibrated Decisions noemt. Het aangekondigde doel is niet dat het antwoord een menselijke beoordelaar bevalt, zoals bij de training van conversatie-assistenten, maar dat de teruggegeven waarschijnlijkheid overeenkomt met de werkelijke frequentie van juiste antwoorden: wanneer het model 0,8 zegt, zou het acht keer op tien gelijk moeten hebben. TypeSafe kondigt responstijden aan tussen 70 en 500 milliseconden afhankelijk van de belasting, een voorbeeld van een werkstroom die in 114 milliseconden wordt uitgevoerd tegenover 8,6 seconden voor dezelfde keten toevertrouwd aan een groot taalmodel, en een prijs van 0,042 dollar per miljoen invoertokens.

Deze cijfers roepen drie voorbehouden op, die we overnemen uit de eerste analyses die in de week van de lancering zijn gepubliceerd. Ten eerste komen ze van TypeSafe zelf: de snelheids- en kostenvergelijkingen nemen als referentie modellen die een volledige redenering uitschrijven, en het verschil wordt duidelijk kleiner tegenover het model dat qua precisie het dichtst in de buurt komt. Ten tweede wordt de interne testset beoordeeld door andere taalmodellen, niet door menselijke beoordelaars, en is tot op heden geen enkele kalibratiecurve gepubliceerd: de documentatie verwijst de gebruiker naar zijn eigen metingen. Ten slotte is Jev een gesloten dienst, waarvan noch de architectuur noch de omvang bekend is. Een deel van de commentatoren ziet er eerder een zorgvuldig getraind classificatiemodel in dan een doorbraak. Dit debat doet niets af aan wat ons hier interesseert, namelijk de verandering van interface, en het rechtvaardigt om te kijken naar wat open modellen nu al mogelijk maken.

SemIf: dezelfde capaciteit, afgelezen in een open model

Al de dag na de aankondiging, op 16 september, publiceerde een onafhankelijke ontwikkelaar, Theodore Lee, een project dat eerst OpenJev heette en later SemIf, zonder enige band met TypeSafe. Het project probeert niet het model te reproduceren, waarvan niets openbaar is, maar wel de interface: een situatie, opties, waarschijnlijkheden.

SemIf steunt op Qwen3.5-4B, een open model met vier miljard parameters dat op een grafische kaart van een particulier past. Het vraagt het model niet om te schrijven. Het legt het de situatie, de vraag en de opties met labels A, B, C voor, en leest rechtstreeks de scores af die het model aan elk van deze letters toekent voor het volgende token. Deze interne scores, die we logits noemen, bestaan bij elke stap in elk taalmodel: het zijn de getallen op basis waarvan het volgende token normaal gezien wordt getrokken. SemIf zet ze om in waarschijnlijkheden en stopt daar. Er wordt geen enkel token gegenereerd.

De auteur noemt dit een semantic if: een softwarevoorwaarde waarvan de regel niet in de code staat geschreven, maar door een model wordt begrepen. Het model brengt zijn kennis van taal en de wereld mee. Het weet dat een patiënt die twee dagen na een operatie hevige pijn beschrijft, niet hetzelfde vertelt als een patiënt die om een factuur vraagt. Men vraagt het model alleen niet meer om dat met zoveel woorden te zeggen.

De gepubliceerde meting is duidelijk. Op een RTX 3090-kaart, met precies hetzelfde Qwen3.5-4B, dezelfde situatie en dezelfde 21 binaire vragen, leverde het rechtstreeks aflezen van de scores de 21 paren waarschijnlijkheden op in 1,023 seconde, zonder ook maar één token te genereren. Hetzelfde model een compacte tabel van 21 waarden laten schrijven, kostte 5,332 seconden, dus vijf keer zoveel. Beide manieren van aflezen kwamen overeen op 18 van de 21 vragen, wat de auteur eerlijk voorstelt als een snelheidsvergelijking, en niet als een bewijs dat beide methoden hetzelfde beslissen.

Hij is even eerlijk over wat ontbreekt. Het omdraaien van de volgorde van de opties deed 10 van de 144 antwoorden in zijn testset veranderen. En hij schrijft dat de verkregen waarschijnlijkheid een score is die afhankelijk is van de aangeboden opties, “geen gekalibreerd operationeel vertrouwen”. Deze twee zwakke punten zijn niet nieuw: onderzoek beschreef al in 2021 dat taalmodellen bepaalde antwoorden bevoordelen op basis van hun positie of frequentie in de trainingsteksten, en stelde correcties voor. Andere open projecten, die dezelfde week verschenen, pakken dit aan door een klein model specifiek voor dit soort uitvoer te verfijnen.

Wat SemIf laat zien is dus beperkt, maar conceptueel belangrijk.

Waarom geen klassieke machinelearning gebruiken?

Op het eerste gezicht lijkt dit allemaal sterk op wat we al twintig jaar kunnen met logistische regressie, een random forest of XGBoost, methoden die leren classificeren op basis van geëtiketteerde voorbeelden. En voor een bepaalde familie van problemen blijven deze methoden superieur.

Stel dat men het risico op een complicatie na een oogoperatie wil inschatten op basis van perfect gestructureerde variabelen: leeftijd, intraoculaire druk, hoorndikte, type ingreep, voorgeschiedenis. Als men over enkele tienduizenden correct ingevulde dossiers beschikt, zou een beroep doen op een model met vier miljard parameters een slechte uitgangshypothese zijn. Een boomgebaseerd model is piepklein, draait op een gewone processor in een fractie van een milliseconde en leert precies de statistische relatie die ons interesseert. Een referentiestudie uit 2022 bevestigt dit op 45 tabulaire datasets: bomen blijven vóór neurale netwerken op data van gemiddelde omvang, zelfs zonder hun snelheidsvoordeel mee te rekenen.

Neem een bericht dat het secretariaat van een praktijk ontvangt: “Ik ben eergisteren geopereerd en sinds vanochtend zie ik veel slechter. Mijn oog doet erg pijn.” We willen kiezen tussen vier vervolgstappen: een administratief antwoord, een gewone consultatie, een snel medisch advies, een spoedgeval. Om een klassieke classificator te bouwen, moet men genoeg berichten verzamelen, de categorieën vastleggen, elk voorbeeld laten annoteren door iemand die een patiëntenbericht kan lezen, opschonen, trainen, en dan opnieuw beginnen op de dag dat de praktijk haar categorieën wijzigt. Studies die de twee benaderingen vergelijken, leggen het kantelpunt laag, rond enkele honderden geannoteerde voorbeelden: daarboven verslaat een klein verfijnd model het grote model dat zonder voorbeelden wordt gebruikt. Maar daaronder, en vooral op de eerste dag, is het grote model het enige dat antwoordt.

Een generalistisch model beschikt al over een representatie van concepten zoals recente chirurgie, pijn, verminderd zicht of spoed. SemIf of Jev benutten dit onmiddellijk, zonder lokale dataset. Traditionele machinelearning leert uw specifieke probleem. Het generalistische model heeft al een bij benadering model van de wereld geleerd, en u geeft het in het verzoek aan welk specifiek probleem u wilt oplossen.

De categorieën verlaten het model en komen in het programma terecht

Deze eigenschap wordt waardevol in automatisering, omdat organisaties van mening veranderen. Een classificator die getraind is om te sorteren tussen “spam”, “normaal” en “urgent” heeft deze drie klassen geleerd. Als de organisatie zes maanden later besluit om onderscheid te maken tussen secretariaat, boekhouding, technische ondersteuning, directie en spoed, is het probleem veranderd en moet men opnieuw annoteren en opnieuw trainen. Een studie uit 2026 over intentiedetectie meet dit zonder omwegen: een vaste classificator scoort nul op een nieuw categorieschema, terwijl een generalistisch model gewoon blijft antwoorden.

De ontwikkelaar houdt de structuur van het probleem onder controle, in code die hij kan lezen, testen en aanpassen, en het model levert alleen het moeilijk te schrijven deel: begrijpen wat de waargenomen situatie betekent. Dit brengt kunstmatige intelligentie dichter bij gewone software, en dat is precies de plaats die wij eraan geven in onze automatiseringsmethode: micro-processen waarvan elke stap leesbaar is, met het model daar waar een geschreven regel niet volstaat.

Wat het vervolg onderzoekt

Even samenvatten. Een generatief model schrijft een tekst die het programma vervolgens moet naherlezen om er een beslissing in te vinden. Een beslissingsmodel krijgt de situatie en de opties, en geeft een waarschijnlijkheid per optie terug, in één enkele doorgang. De categorieën liggen niet langer vast in het model; ze staan geschreven in het programma, waar men ze kan lezen en aanpassen. En deze capaciteit is niet voorbehouden aan een gesloten dienst: SemIf toont dat een deel ervan al bestaat in een open model met vier miljard parameters, tegen de prijs van beperkingen die de auteur zelf documenteert.

Dat alles zou van Jev of SemIf al soepelere classificatoren maken, en dat zou al nuttig zijn.

Bij die snelheid komt het model terecht in lussen waarin men observeert, meerdere acties vergelijkt voordat men handelt, en waarin een klein gespecialiseerd model uiteindelijk de terugkerende gevallen overneemt. Dat is het onderwerp van het tweede deel van dit artikel.

Als u een proces heeft waarin een beslissing tientallen keren per dag terugkomt en vandaag steunt op het lezen door een persoon, volstaat doorgaans een gesprek van dertig minuten om te weten of een model van dit type daarbij past. Schrijf ons onderaan de pagina, of boek rechtstreeks een moment in onze agenda.

Bronnen

• TypeSafe AI, Introducing System One Models & Jev (15 september 2026)
  Officiële aankondiging: de drie soorten vragen, de parallelle evaluatie, de trainingsmethode, de latenties van 70 tot 500 ms, het voorbeeld van 114 ms en de prijs.

• TypeSafe AI, documentatie: confidence
  Pagina die de betrouwbaarheidsscore beschrijft en de gebruiker voor de kalibratie naar zijn eigen metingen verwijst.

• Business Wire, TypeSafe AI Emerges From Stealth With $40M in Funding (15 september 2026)
  Lanceringspersbericht: financiering, oprichters en positionering.

• Pear Pages, Jev, sorted: what TypeSafe’s System One model actually is, and what is still just a claim (16 september 2026)
  Kritische analyse van de door TypeSafe gepubliceerde vergelijkingen en het ontbreken van kalibratiecurves.

• Hacker News, discussie over de lancering van TypeSafe AI
  Ontvangst door ontwikkelaars, met onder meer het bezwaar “het is een classificator”.

• Theodore Lee, SemIf (voorheen OpenJev), GitHub-repository
  Methode voor het rechtstreeks aflezen van scores, meting van 1,023 s tegenover 5,332 s op een RTX 3090, verstoringstests en de door de auteur genoemde beperkingen.

• Zhao et al., Calibrate Before Use: Improving Few-Shot Performance of Language Models (ICML 2021)
  Positie- en frequentiebias in de antwoorden van taalmodellen, en voorgestelde correctie.

• Zheng et al., Large Language Models Are Not Robust Multiple Choice Selectors (ICLR 2024)
  Gevoeligheid van modellen voor de volgorde en het label van de opties.

• Grinsztajn, Oyallon, Varoquaux, Why do tree-based models still outperform deep learning on tabular data? (NeurIPS 2022)
  Referentie voor de superioriteit van bomen op tabulaire data van gemiddelde omvang.

• Bucher en Martini, Fine-Tuned ‘Small’ LLMs (Still) Significantly Outperform Zero-Shot Generative AI Models in Text Classification (2024)
  Kantelpunt rond enkele honderden geannoteerde voorbeelden.

• When Do LLMs Replace Fine-Tuned NLU? A Decision Framework for Intent Detection in Production Conversational Systems (2026)
  Vergelijking bij een veranderend categorieschema: de vaste classificator antwoordt niet meer.