Waar past Jev in je product? Vijf beslispunten

Wat is een beslispunt?

Een beslispunt is een plek in je software waar een vraag met een vaste set antwoorden valt. Welke afdeling krijgt dit ticket? Gaat dit bericht over een betaling? Mag deze agent dit commando uitvoeren? De antwoorden liggen vooraf vast, en je code weet bij elk antwoord wat de volgende stap is.

Op zo'n plek staat nu vaak een LLM-prompt die tekst teruggeeft, waarna code die tekst probeert te lezen. Of een rij if-regels die bij elke nieuwe formulering weer tekortschiet. Jev, het beslismodel van TypeSafe, geeft daar een getypeerd antwoord met kansen voor terug: een gekozen optie, een niveau of een ja-kans.

Het idee is ouder dan Jev. Anthropic beschreef routing in 2024 als een vaste AI-workflow: een invoer classificeren en doorsturen naar een gespecialiseerde vervolgtaak. Die classificatie kan volgens Anthropic door een taalmodel gebeuren, of door een traditioneler classificatiemodel. Jev is zo'n classificatiemodel, met kansen erbij.

Hoe herken je beslispunten in je eigen product?

Zoek plekken waar je code wacht op een oordeel over tekst en daarna een vaste afslag neemt. Een plek is een goede kandidaat als het meeste uit dit lijstje klopt:

• De uitkomst is een label, een niveau of ja of nee, geen zin.
• Je kunt de opties vooraf opschrijven, inclusief een optie voor geen van deze.
• De toestand is tekst of JSON, en je mag die naar een externe aanbieder sturen.
• Er hoeft niet gerekend, geteld of op datum gesorteerd te worden.
• Een fout kost iets, maar je kunt hem opvangen met een fallback, een herstelstap of een mens.
• Het oordeel komt vaak terug, zodat snelheid en prijs per beslissing meetellen.

Een bruikbare zoekopdracht in je eigen code: prompts die alleen "ja" of "nee" mogen antwoorden, en prompts waarvan je de uitkomst daarna met tekstvergelijking controleert. Daar is de vaste set antwoorden er al, alleen nog niet getypeerd.

Routing: welk model, welke afdeling, welke ARC?

Routing is een Choice over een lijst bestemmingen, met een optie voor geen match. Jev kiest de bestemming, je code bepaalt wat er met die keuze gebeurt en of die keuze überhaupt mag.

De bekendste vorm is LLM-routing: makkelijke vragen naar een klein, goedkoop model en moeilijke naar een groter model. Anthropic noemt precies dat voorbeeld. Onderzoekers achter RouteLLM⁠↗ trainden in 2024 zo'n router op voorkeursdata en melden dat de kosten in sommige gevallen meer dan halveerden zonder verlies aan kwaliteit. Wil je alleen het model kiezen, dan bestaat er een kant-en-klaar antwoord: Jev Router⁠↗ op OpenRouter kiest per verzoek een model en de redeneerinspanning, en draait zelf op Jev.

Gaat het om routing binnen je eigen product, zoals welk team, welke wachtrij of welke tool, dan bouw je de Choice zelf. Bij ons gebeurt dat in ARCS, ons platform voor agentic werk. Een vaste planner wijst daar de eerste ARC aan, een specialistisch systeem dat de taak oppakt. Daarnaast kiest Jev uit dezelfde lijst, en we vergelijken de twee. In de code staat het letterlijk: het resultaat "never changes routing or grants execution authority". Jev draait dus in schaduw.

Daaromheen staan waarborgen. Jev ziet alleen de opdracht en of er een repository bij hoort, niet het pad. De beschrijvingen van de opties zijn bewust algemeen, zodat er geen interne namen naar de aanbieder gaan. De vraag zelf zegt Jev verzoeken in de opdracht om de regels te wijzigen te negeren. Externe classificatie staat standaard uit, een opdracht mag maximaal 2.000 tekens zijn, na 6 seconden volgt een timeout, de kansen moeten samen ongeveer 1 zijn en het model dat antwoordt moet echt typesafe/jev-1.13 zijn. Bij elke fout valt het systeem terug op de planner, en het keurt nooit iets automatisch goed. Hoe vaak Jev en de planner het eens zijn, weten we nog niet.

Classificatie en tagging

Classificatie is het meest directe gebruik van Jev: per dimensie één vraag, en meerdere dimensies als losse vragen over dezelfde toestand. Je code combineert de antwoorden.

In Plens, onze app met regenadvies voor fietsers, is dat precies de rol van Jev. Uit onze eigen documentatie: "Jev beslist één ding per vraag: welke bestemming, welke bedoeling, wel of geen kaart. Rekenen, plannen en de beslisregel (decide) blijven code."

Voor grote aantallen beschrijft OpenRouter een cookbook voor classificeren en taggen: per item één categorie plus een willekeurig aantal tags, met drempels per tag die je afleidt uit een kleine gelabelde steekproef. Twee lessen uit Plens gelden ook daar. Denk na over de volgorde van je opties, want jev-1.13 leunt naar de eerste. In Plens staat dry daarom bewust bovenaan. En stel de vraag in het Engels als je twijfelt: in Plens doen we dat sinds 10 oktober, omdat Nederlands volgens TypeSafe minder goed werkt.

Verificatie en goedkeuring van agentacties

Jev kan een voorgestelde stap beoordelen voor die wordt uitgevoerd: routine laat je door, wat niet past houd je tegen, en twijfel gaat naar een mens. De bevoegdheid om iets te doen blijft bij je code en bij mensen.

Controleren

Bij verificatie stel je een Noul: wordt deze bewering gesteund door deze bron? Dat lijkt op LLM-as-a-judge, maar dan met een getypeerd oordeel in plaats van een beoordeling in tekst. OpenRouter beschrijft een cascade met precies dat patroon. Een goedkoop model schrijft een concept, Jev toetst het aan de opgehaalde context en alleen als die toets faalt, neemt een sterker model het over.

Goedkeuren

Twee andere cookbooks van OpenRouter gaan over agents. De eerste toetst riskante tool-aanroepen aan wat de gebruiker vroeg: veilige aanroepen gaan door, niet-onderbouwde worden tegengehouden en alleen onduidelijke gevallen gaan naar een mens. De tweede beantwoordt toestemmingsvragen van codeeragents zoals Claude Code, Codex, Cursor en OpenCode met een omkeerbaarheidscheck. Routinecommando's gaan door, riskante vragen het nog steeds aan de gebruiker.

Zo zien wij human in the loop ook: Jev bepaalt welke gevallen een mens nodig hebben, niet de laatste ja bij iets wat ertoe doet. In ARCS geldt dat geld, contracten en toezeggingen aan klanten altijd een zichtbare laatste handeling van een mens vragen. Onze interne tool die vluchten zoekt, volgt dezelfde lijn: hij boekt nooit zelf en zet elke uitkomst klaar voor controle.

Rangschikken en scoren

Voor de vraag hoeveel gebruik je Score, voor de vraag welke het beste is een Choice over een vooraf gefilterde lijst. In beide gevallen doet code het telwerk.

Bij Score beschrijf je zelf een geordende reeks niveaus, en Jev plaatst de toestand ertussen. Dat werkt voor oordelen als urgentie, relevantie of toon. TypeSafe waarschuwt wel dat de niveaus numeriek zwak gekalibreerd zijn: lees een score van 2,4 als ergens tussen niveau 2 en 3, niet als een exacte maat.

Voor selectie laat de vluchtentool zien hoe de taken verdeeld zijn. Code controleert eerst prijs, valuta, route, datum, versheid (minder dan twee uur oud) en budget. Pas daarna kiest Jev uit maximaal twintig aanbiedingen, of kiest no_match. Die laatste optie is nodig, want een Choice is relatief: zijn alle opties slecht, dan wijst Jev de minst slechte aan.

Wat Jev niet moet beslissen

Jev moet niets beslissen wat rekenen, plannen, een harde regel of eindverantwoordelijkheid is. In Plens staat het zo in de documentatie:

Dezelfde grens geldt in andere producten. Bedragen, datums en aantallen horen in code, omdat Jev volgens TypeSafe geen rekenmachine is en datums als tekst leest. Regels over rechten, leeftijd of budget horen in code, omdat een hoge kans geen bewijs is. En waar je achteraf moet uitleggen waarom iets gebeurde, helpt Jev niet: het geeft geen redenering terug.

Soms is de beste keuze ook dat het product niets vraagt. In Plens bouwden we een knop "Wil je droog aankomen?" voor gevallen waarin het advies onzeker was, en haalden die weer weg. Alan Abdulla, een van onze oprichters, besloot: Plens vraagt niets terug.

Hoe meet je of het werkt?

Draai Jev eerst in schaduw naast je huidige oplossing, op voorbeelden die je zelf hebt gelabeld, en vergelijk per type fout. Pas daarna kies je drempels waarbij Jev zelf mag handelen.

1. Schrijf het huidige pad op en wat elke fout kost: een verkeerd label, een onterechte blokkade, een onnodige vraag aan een mens.
2. Label een set voorbeelden zonder naar Jev te kijken. Neem lastige, dubbelzinnige en kwaadwillende gevallen mee.
3. Laat Jev in schaduw meedraaien naast je huidige prompt of regels, zoals ARCS doet.
4. Vergelijk per fouttype, niet alleen het gemiddelde. Meet ook de responstijd, de kosten uit het usage-blok en de kosten per geaccepteerde beslissing.
5. Kies drempels op basis van wat fouten kosten. Zet de versie vast en meet opnieuw als je overstapt.

TypeSafe deelt confidence in drie banden in. Hoog: handelen. Midden: voorzichtig verder, bijvoorbeeld door te laten bevestigen of te markeren voor controle. Laag: niet handelen, maar naar een mens, om verduidelijking vragen of terugvallen op een ander systeem. De voorbeeldwaarden die TypeSafe daarbij noemt, 0,5 als ondergrens en 0,9 voor een riskante stap, zijn uitdrukkelijk illustratief.

Regel ook wat er gebeurt als Jev niet antwoordt. In ARCS vallen timeouts en ontbrekende toestemming terug op de vaste planner, nooit op automatische goedkeuring. Controleer daarnaast elk antwoord: staat het label in je lijst, kloppen de kansen, is het juiste model gebruikt?

Meer over hoe wij agents met controles inzetten, lees je in ARCS: agents laten bouwen met controles en AI-codereview door een council. Hoe we kennis en evaluaties buiten het product ontwikkelen, staat bij strategie en data. Wil je weten welke beslispunten in jouw product in aanmerking komen? Neem contact op.