Het Jev-principe uitgelegd: AI die aankruist in plaats van schrijft
Jev schrijft geen tekst maar beantwoordt meerkeuzevragen, met een kans bij elk antwoord. Het principe in gewone taal, met PHP-voorbeelden die je kunt overnemen, tot en met Claude en Jev die samenwerken.
Een webwinkel krijgt op maandagochtend tweehonderd mails. "Waar blijft mijn jas?" "Kan ik deze schoenen ruilen voor een maat groter?" "Jullie hebben twee keer afgeschreven!" Iemand leest ze één voor één en sleept ze naar het juiste mapje. Per mail kost dat een paar seconden, en er wordt geen letter voor geschreven.
Voor precies dat soort werk bouwde TypeSafe AI Jev, een AI-model dat op 15 september 2026 werd gepresenteerd. Jev schrijft niets. Het leest een tekst, krijgt een paar vragen met vaste antwoorden en kruist aan, met bij elk vakje hoe zeker het is. In dit artikel leg ik dat principe uit met herkenbare voorbeelden en korte stukjes PHP die je kunt overnemen, tot en met een opzet waarin Claude en Jev samenwerken. Benchmarks en prijsvergelijkingen staan in mijn eerdere artikel over Jev.
Gecontroleerd in de documentatie van TypeSafe op 1 oktober 2026. De antwoorden van Jev en Claude in de voorbeelden zijn illustraties: ze laten zien hoe een antwoord eruitziet, het zijn geen uitkomsten van echte aanroepen.
Wat is het Jev-principe?
Jev beantwoordt meerkeuzevragen over een tekst. Jij levert de tekst en de vragen, inclusief alle toegestane antwoorden. Jev geeft per vraag het meest waarschijnlijke antwoord terug, plus een kans voor elk mogelijk antwoord. Wat er daarna gebeurt, bepaalt je eigen code.
Het verschil met ChatGPT, Claude of Gemini zie je het best aan een proefwerk. Een taalmodel krijgt een open vraag en schrijft een antwoord, woord voor woord. Dat antwoord kan alle kanten op: het kan uitweiden, een categorie verzinnen die niet bestaat, of netjes "levering" zeggen. Jev krijgt een meerkeuzevraag en kan alleen een vakje aankruisen dat op het formulier staat. Daar komt de claim van TypeSafe vandaan dat Jev niet hallucineert: er is geen ruimte om iets te verzinnen. Het verkeerde vakje aankruisen kan Jev wel. Daar kom ik op terug.
Omdat Jev niets hoeft te schrijven, is het snel en goedkoop. Een taalmodel rekent voor elk woord opnieuw; Jev rekent volgens TypeSafe alle kansen in één keer uit. TypeSafe noemt 70 tot 500 milliseconden per aanroep, onafhankelijke metingen kwamen rond 0,4 seconde uit. Invoer kost 0,042 dollar per miljoen tokens (een token is grofweg een lettergreep of kort woord) en het antwoord is gratis.
De drie vraagsoorten van Jev
Jev kent drie soorten vragen. Meer is er niet.
Noul: ja of nee, met een kans
Een Noul is een ja/nee-vraag. Het antwoord is één getal tussen 0 en 1: de kans dat het antwoord "ja" is. Lees het als de regenkans in het weerbericht. 0,9 is een duidelijk ja, 0,1 een duidelijk nee, en rond 0,5 weet Jev het niet.
Het getal is een kans, geen maat. Vraag je "Is de klant boos?" en krijg je 0,6, dan betekent dat niet "een beetje boos". Het betekent zestig procent kans dat het antwoord ja is. De documentatie waarschuwt hier zelf voor. Wil je weten hoe boos, dan gebruik je een Score.
Choice: één vakje uit een lijst
Een Choice kiest één optie uit een lijst die jij opgeeft, tot 255 opties. Je krijgt de gekozen optie, een kans per optie (samen 1) en een getal voor de zekerheid. Jev moet altijd iets kiezen, dus de documentatie raadt een optie "anders" aan. Zonder die optie wordt een open sollicitatie in je klantenservicemailbox toch in "retour" gepropt.
Score: een plek op een schaal
Een Score plaatst de tekst op een schaal van 2 tot 10 niveaus die je in woorden beschrijft, bijvoorbeeld "kalm", "geïrriteerd" en "woedend". De uitkomst is een gewogen gemiddelde van de niveaunummers, die bij 0 beginnen. Daardoor krijg je vaak een kommagetal: 1,4 ligt tussen "geïrriteerd" (1) en "woedend" (2), dichter bij geïrriteerd.
Je eerste Jev-aanroep in PHP
TypeSafe heeft officiële bibliotheken voor Python en JavaScript, niet voor PHP. Dat maakt weinig uit: Jev is één webadres waar je een JSON-bericht naartoe stuurt. Deze functie doet dat met curl, dat in vrijwel elke PHP-installatie zit. Ik heb hem zelf opgebouwd uit de API-documentatie; het is geen code van TypeSafe.
function vraagJev(string|array $tekst, array $vragen): array
{
$ch = curl_init('https://api.typesafe.ai/v1/systemone');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 10,
CURLOPT_HTTPHEADER => [
'Authorization: Bearer ' . getenv('TYPESAFE_API_KEY'),
'Content-Type: application/json',
],
CURLOPT_POSTFIELDS => json_encode([
'model' => 'jev-latest',
'state' => $tekst,
'questions' => $vragen,
], JSON_THROW_ON_ERROR),
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($body === false || $status !== 200) {
throw new RuntimeException("Jev gaf geen bruikbaar antwoord (HTTP $status)");
}
return json_decode($body, true, flags: JSON_THROW_ON_ERROR)['answers'];
}Er gaan drie dingen in. model zegt welke versie van Jev je gebruikt, state is de tekst waarover je vragen stelt, en questions zijn je vragen. Terug komt een lijst antwoorden, één per vraag. De API-sleutel maak je aan in de console van TypeSafe en zet je in een omgevingsvariabele, zodat hij niet in je code staat.
Voorbeeld 1: de mailbox van een webwinkel
$mail = 'Hoi, vorige week heb ik een winterjas besteld (order 48213) en ik heb nog '
. 'steeds niks ontvangen. Zaterdag vertrek ik op wintersport, dus ik heb hem echt nodig!';
$onderwerpVraag = [
'type' => 'choice',
'instructions' => 'Waar gaat deze klantmail over?',
'criteria' => [
'levering' => 'Pakket is niet, te laat of beschadigd aangekomen',
'retour' => 'Klant wil iets terugsturen of ruilen',
'betaling' => 'Factuur, afschrijving of terugbetaling',
'productvraag' => 'Vraag over maat, materiaal of voorraad',
'anders' => 'Past bij geen van de andere opties',
],
];
$antwoorden = vraagJev($mail, [
'onderwerp' => $onderwerpVraag,
'deadline' => [
'type' => 'noul',
'instructions' => 'Noemt de klant een dag of datum waarop het product er moet zijn?',
],
]);Elke vraag krijgt een naam die je zelf kiest, hier onderwerp en deadline. Onder die naam vind je straks het antwoord terug. In criteria staat per optie in gewone taal wat je ermee bedoelt. Dat is bij Jev het hele "prompten": duidelijke omschrijvingen schrijven.
Het antwoord ziet er zo uit (illustratie):
{
"onderwerp": {
"type": "choice",
"choice": "levering",
"probabilities": { "levering": 0.94, "retour": 0.01, "betaling": 0.01, "productvraag": 0.01, "anders": 0.03 },
"confidence": 0.91
},
"deadline": { "type": "noul", "noul": 0.97 }
}Daarna is het weer gewone PHP. zetInMap() en markeerAlsSpoed() staan voor je eigen functies:
$onderwerp = $antwoorden['onderwerp']['choice']; // 'levering'
$zekerheid = $antwoorden['onderwerp']['confidence']; // 0.91
$haast = $antwoorden['deadline']['noul']; // 0.97
if ($zekerheid >= 0.9) {
zetInMap($onderwerp);
} elseif ($zekerheid >= 0.5) {
zetInMap($onderwerp, laatControleren: true);
} else {
zetInMap('handmatig');
}
if ($haast >= 0.8) {
markeerAlsSpoed();
}Kijk wie hier wat doet. Jev zegt wat er in de mail staat. Jouw code beslist wat er gebeurt. Jev verstuurt niets, verplaatst niets en kan niets kapotmaken. Dat is de kern van het principe: de AI geeft een oordeel in een vorm die een computer kan lezen, en de regels blijven van jou. De drempels van 0,9 en 0,5 zijn het startadvies van TypeSafe: boven 0,9 automatisch, daartussen met controle, eronder door een mens.
De voorbeelden zijn in het Nederlands. Volgens TypeSafe is Engels de taal waarin Jev het nauwkeurigst is; andere talen werken, maar minder goed. Test het dus op je eigen Nederlandse mails voordat je erop gaat bouwen.
Wat betekent "91 procent zeker"?
De kansen zijn het interessantste deel van Jev, en het makkelijkst verkeerd te lezen.
TypeSafe traint Jev op gekalibreerde kansen. Dat werkt als een goed weerbericht: als de weerman op honderd dagen 70 procent kans op regen voorspelt, moet het op ongeveer zeventig van die dagen echt regenen. Niet op alle honderd en niet op dertig. Zo bedoelt TypeSafe het ook: van alle antwoorden waar Jev 0,8 bij zet, zou ongeveer 80 procent moeten kloppen. Dat zegt iets over een groep antwoorden, nooit over dat ene antwoord.
De confidence bij een Choice of Score is iets anders. Dat getal zegt hoe geconcentreerd de kansen zijn: alles op één optie geeft bijna 1, gelijk verdeeld over alle opties bijna 0. Een mail die half over een retour en half over een dubbele afschrijving gaat, krijgt dus een lage confidence, ook als Jev beide onderwerpen prima herkent. De confidence zegt hoe uitgesproken het antwoord is. Hoe vaak zo'n antwoord klopt, zegt hij niet.
Of de kansen bij jouw teksten eerlijk zijn, moet je zelf nagaan. Twee kleine onafhankelijke tests kwamen daarover tot tegengestelde conclusies (zie het eerdere artikel), en de documentatie zegt het ook: stel drempels af op je eigen data en begin voorzichtig.
Drempels kies je op basis van de gevolgen
Wat doe je met 0,7? Dat hangt niet af van Jev, maar van wat het kost als het antwoord fout is. Voor Nouls geeft de documentatie een vuistregel: 0,5 als ja en nee even makkelijk te herstellen zijn, hoger als een onterecht "ja" duur is, lager als een gemist "ja" duur is.
$antwoorden = vraagJev($mail, [
'wil_retour' => [
'type' => 'noul',
'instructions' => 'Wil de klant een product terugsturen?',
],
'gevaar' => [
'type' => 'noul',
'instructions' => 'Meldt de klant rook, brand, oververhitting of een stroomschok bij een product?',
],
]);
// Een onterecht retourformulier is onhandig, maar snel rechtgezet
if ($antwoorden['wil_retour']['noul'] >= 0.7) {
stuurRetourformulier();
}
// Een gemiste veiligheidsmelding is veel erger dan een collega die voor niets kijkt
if ($antwoorden['gevaar']['noul'] >= 0.2) {
waarschuwTeamleider();
}Een gemiste melding over een föhn die begon te roken weegt zwaarder dan een collega die een onschuldige mail leest. Daarom staat die drempel laag. Geld terugstorten laat je nooit alleen van een kans afhangen, hoe hoog die ook is: voor onomkeerbare en financiële acties is een mens of een harde regel in je code nodig.
Voorbeeld 2: stel alle vragen tegelijk
Bij een gewoon taalmodel stel je vragen vaak na elkaar: eerst "waar gaat het over?", en alleen bij een retour daarna "wat is de reden?". Elke vervolgvraag is een extra aanroep en een extra wachtronde.
Bij Jev raadt TypeSafe het omgekeerde aan en noemt dat speculative fan-out: stel in één aanroep alle vragen die je misschien nodig hebt. Jev beantwoordt ze tegelijk, dus een extra vraag kost nauwelijks tijd. Omdat het antwoord gratis is, betaal je alleen voor de woorden van de vraag zelf. Je code negeert wat niet relevant blijkt.
$antwoorden = vraagJev($mail, [
'onderwerp' => $onderwerpVraag,
'retour_reden' => [
'type' => 'choice',
'instructions' => 'Waarom wil de klant het product terugsturen?',
'criteria' => [
'maat' => 'Past niet, te groot of te klein',
'defect' => 'Kapot, beschadigd of werkt niet',
'verkeerd' => 'Ander product ontvangen dan besteld',
'smaak' => 'Kleur of model valt tegen',
'onbekend' => 'De reden staat niet in de mail',
],
],
'boosheid' => [
'type' => 'score',
'instructions' => 'Hoe boos klinkt de klant?',
'criteria' => ['Kalm en zakelijk', 'Geïrriteerd maar beleefd', 'Woedend, harde taal'],
],
]);
if ($antwoorden['onderwerp']['choice'] === 'retour') {
$reden = $antwoorden['retour_reden']['choice']; // alleen bij een retour relevant
}
if ($antwoorden['boosheid']['score'] > 1.2) { // schaal 0 tot 2
geefVoorrang();
}Gaat de mail over een late levering, dan staat er toch een antwoord op de retourvraag. Dat antwoord gebruik je gewoon niet. Het kostte een paar tokens, en het scheelt je een tweede aanroep bij elke mail die wél over een retour gaat.
Voorbeeld 3: een cv beoordelen zonder zwarte doos
Vraag je een AI "Geef deze kandidaat een cijfer van 1 tot 10", dan krijg je een 7 en weet je niet waarom. Was het de ervaring? Een mooi geformuleerde motivatie?
TypeSafe beschrijft een andere aanpak, composite scoring: knip het oordeel op in kleine, losse vragen, laat Jev elk onderdeel scoren en tel de scores in je eigen code op met gewichten die jij kiest. Een voorbeeld voor een vacature als PHP-developer:
$cv = file_get_contents('cv-kandidaat-17.txt');
$niveaus = [
'Geen aanwijzingen in het cv',
'Genoemd, maar zonder concrete projecten',
'Een of twee concrete projecten',
'Meerdere jaren aantoonbare ervaring',
'Diepe ervaring: leidt anderen op of bouwt de basis',
];
$antwoorden = vraagJev($cv, [
'php' => ['type' => 'score', 'instructions' => 'Ervaring met PHP', 'criteria' => $niveaus],
'laravel' => ['type' => 'score', 'instructions' => 'Ervaring met het Laravel-framework', 'criteria' => $niveaus],
'teamwerk' => ['type' => 'score', 'instructions' => 'Ervaring met werken in een ontwikkelteam', 'criteria' => $niveaus],
]);
// De gewichten zijn jouw keuze, niet die van Jev
$gewichten = ['php' => 0.5, 'laravel' => 0.3, 'teamwerk' => 0.2];
$totaal = 0;
foreach ($gewichten as $vraag => $gewicht) {
$totaal += $gewicht * ($antwoorden[$vraag]['score'] / 4); // vijf niveaus: score loopt van 0 tot 4
}
printf("Totaalscore: %d van 100\n", round($totaal * 100));Dit levert twee dingen op. Je kunt uitleggen waarom kandidaat A boven kandidaat B staat: hoger op PHP, lager op teamwerk. En klopt de ranglijst niet met wat een recruiter verwacht, dan pas je de gewichten aan zonder Jev opnieuw iets te vragen. Voor een teamleidersfunctie schuif je het gewicht van teamwerk omhoog, met dezelfde scores.
De scores van verschillende vragen zijn niet op elkaar afgestemd: een 3 op PHP en een 3 op teamwerk hoeven niet even sterk te zijn. De gewichten zijn dus een keuze, en daarmee ook jouw verantwoordelijkheid. Reistijd staat bewust niet in de lijst. Of Arnhem dicht genoeg bij Utrecht ligt, is een berekening en geen oordeel; daarover verderop meer.
Voorbeeld 4: Claude en Jev laten samenwerken
Jev schrijft geen code en voert geen gesprek. Claude doet dat wel. De twee vullen elkaar dus aan: Claude analyseert, redeneert en schrijft; Jev maakt onderweg de afgebakende keuzes, met een kans erbij. Je PHP-code verbindt ze en houdt de regie. TypeSafe zegt het zelf ook: Jev vervangt het model achter een coding agent niet, maar kan er wel de routeer- en beoordelingsstappen voor doen.
Neem een bugmelding: "Ons PHP-script slaat soms dubbele bestellingen op." Claude leest de code en het log en komt uit op een paar mogelijke oorzaken. Welke onderzoek je eerst? Dat is een meerkeuzevraag, en die kan Claude aan Jev voorleggen. Daarvoor geef je Claude een tool: een functie die Claude zelf mag aanroepen wanneer dat nodig is. Dit voorbeeld gebruikt de officiële PHP-SDK van Anthropic (composer require anthropic-ai/sdk) en de functie vraagJev() van hierboven.
Eerst de tool. De beschrijving vertelt Claude wanneer hij bedoeld is; de functie eronder geeft Claudes vraag door aan Jev en het antwoord terug:
$jevTool = [
'name' => 'kies_met_jev',
'description' => 'Laat Jev een afgebakende keuze maken uit een paar duidelijke opties, '
. 'bijvoorbeeld welke mogelijke oorzaak je eerst onderzoekt. Geef de relevante '
. 'feiten mee als state en voeg altijd een optie "anders" toe.',
'inputSchema' => [
'type' => 'object',
'properties' => [
'state' => ['type' => 'string', 'description' => 'De feiten waarop de keuze rust'],
'vraag' => ['type' => 'string', 'description' => 'De vraag, kort en direct'],
'opties' => [
'type' => 'object',
'description' => 'Per optie een korte naam met een omschrijving',
'additionalProperties' => ['type' => 'string'],
],
],
'required' => ['state', 'vraag', 'opties'],
],
];
function voerToolUit(string $naam, array $input): string
{
if ($naam !== 'kies_met_jev') {
return "Onbekende tool: $naam";
}
$antwoord = vraagJev($input['state'], [
'keuze' => [
'type' => 'choice',
'instructions' => $input['vraag'],
'criteria' => $input['opties'],
],
])['keuze'];
return json_encode([
'keuze' => $antwoord['choice'],
'kansen' => $antwoord['probabilities'],
'confidence' => $antwoord['confidence'],
]);
}Dan het gesprek met Claude. Claude krijgt de opdracht, de code en een stuk van het log. Zolang Claude een tool wil gebruiken (stopReason is dan tool_use), voert PHP die uit en stuurt het resultaat terug:
use Anthropic\Client;
use Anthropic\Messages\ToolUseBlock;
$claude = new Client(apiKey: getenv('ANTHROPIC_API_KEY'));
$systeem = 'Je bent een ervaren PHP-developer en onderzoekt bugs. Sta je voor een afgebakende keuze '
. 'met een paar duidelijke opties, gebruik dan kies_met_jev. De kansen zijn advies: jij blijft '
. 'verantwoordelijk voor de analyse. Is de confidence lager dan 0,5, onderzoek dan ook de tweede optie.';
$berichten = [[
'role' => 'user',
'content' => "Ons script slaat soms dubbele bestellingen op. Zoek uit waarom en stel een oplossing voor.\n\n"
. "Code:\n" . file_get_contents('bestelling-opslaan.php') . "\n\n"
. "Log:\n" . file_get_contents('logs/dubbele-bestellingen.log'),
]];
do {
$antwoord = $claude->messages->create(
model: 'claude-opus-5-5',
maxTokens: 16000,
system: [['type' => 'text', 'text' => $systeem]],
tools: [$jevTool],
messages: $berichten,
);
$berichten[] = ['role' => 'assistant', 'content' => $antwoord->content];
$resultaten = [];
foreach ($antwoord->content as $blok) {
if ($blok instanceof ToolUseBlock) {
$resultaten[] = [
'type' => 'tool_result',
'toolUseID' => $blok->id,
'content' => voerToolUit($blok->name, $blok->input),
];
}
}
if ($resultaten) {
$berichten[] = ['role' => 'user', 'content' => $resultaten];
}
} while ($antwoord->stopReason === 'tool_use');
foreach ($antwoord->content as $blok) {
if ($blok->type === 'text') {
echo $blok->text; // Claudes analyse en voorstel
}
}Wat er gebeurt, stap voor stap. Claude leest de code en het log en ziet bijvoorbeeld drie kandidaten: twee gelijktijdige verzoeken die allebei een bestelling opslaan (een race condition), een ontbrekende unieke index in de database, of een formulier dat twee keer wordt verstuurd. Claude roept kies_met_jev aan met die drie opties plus "anders", en met de feiten uit het log als state. Het antwoord dat terugkomt, ziet er zo uit (illustratie):
{
"keuze": "race_condition",
"kansen": { "race_condition": 0.62, "geen_unieke_index": 0.24, "dubbel_verstuurd": 0.11, "anders": 0.03 },
"confidence": 0.47
}Claude onderzoekt eerst de race condition. Omdat de confidence onder 0,5 ligt, kijkt Claude volgens de instructie ook naar de unieke index, en schrijft daarna een analyse met een voorstel. Bij dubbele records in een database is dat vaak allebei: een unieke index die het dubbele record weigert, en code die daar netjes mee omgaat.
Twee kanttekeningen. Jev weet alleen wat Claude in de state zet: vat Claude het log verkeerd samen, dan kiest Jev op verkeerde feiten. En een oorzaak afleiden uit code en log is redeneerwerk in meerdere stappen, precies het soort werk waar Jev volgens TypeSafe zwakker in is. Of Jev hier beter kiest dan Claude zelf, heeft voor zover ik weet niemand gemeten. Wat Jev wel toevoegt, is een antwoord in steeds dezelfde vorm, met een getal dat je kunt loggen en achteraf controleren, voor een fractie van de prijs: Jev rekent 0,042 dollar per miljoen invoertokens, Claude Opus 5.5 4 dollar.
De rem hoort in je code, niet bij Claude
In het voorbeeld hierboven bepaalt Claude zelf wanneer Jev iets wordt gevraagd. Dat is advies. Een controle die niet mag worden overgeslagen, laat je je eigen code doen, buiten Claude om. Bijvoorbeeld voordat Claudes voorstel wordt doorgevoerd:
$risico = vraagJev($voorstel, [
'raakt_data' => [
'type' => 'noul',
'instructions' => 'Verwijdert of wijzigt deze aanpassing bestaande gegevens of de databasestructuur?',
],
]);
if ($risico['raakt_data']['noul'] >= 0.3) {
zetKlaarVoorReview($voorstel); // eerst kijkt een mens
} else {
draaiTests($voorstel);
}Claude kan deze stap niet vergeten of wegredeneren, want Claude weet niet eens dat hij bestaat. Het is hetzelfde principe als bij de mailbox: het model geeft een oordeel, je code beslist. De drempel staat bewust laag, want een onnodige review kost een paar minuten en een verloren tabel veel meer.
En in Claude Code zelf?
Werk je met Claude Code, dan kun je hetzelfde idee als skill vastleggen: een instructiebestand dat Claude vertelt wanneer en hoe het iets doet. TypeSafe heeft een eigen plug-in voor Claude Code (claude plugin install typesafe@typesafe-ai), maar die leert Claude vooral hoe je de Jev-API in je eigen code inbouwt. Met een API-sleutel kan Claude er ook proefvragen mee stellen, maar Claude gaat daardoor niet vanzelf zijn eigen keuzes aan Jev voorleggen.
Wil je dat wel, dan schrijf je een kleine skill, bijvoorbeeld in .claude/skills/jev-triage/SKILL.md. Dit is mijn eigen opzet, niet getest:
---
name: jev-triage
description: Gebruik bij een bug met meerdere duidelijke mogelijke oorzaken, om te bepalen welke je eerst onderzoekt.
---
1. Schrijf de relevante feiten en de mogelijke oorzaken naar vraag.json, met altijd een optie "anders".
2. Draai: php jev-keuze.php vraag.json
3. Onderzoek de oorzaken in volgorde van kans. Bij een confidence onder 0,5 controleer je ook de tweede optie.
4. De uitkomst is advies. Spreekt je eigen onderzoek hem tegen, volg dan je onderzoek en meld dat.Het script dat de skill aanroept, is weer gewoon PHP met de functie van hierboven:
require __DIR__ . '/vraag-jev.php'; // bevat vraagJev()
$vraag = json_decode(file_get_contents($argv[1]), true, flags: JSON_THROW_ON_ERROR);
$antwoord = vraagJev($vraag['state'], [
'keuze' => ['type' => 'choice', 'instructions' => $vraag['vraag'], 'criteria' => $vraag['opties']],
])['keuze'];
arsort($antwoord['probabilities']);
foreach ($antwoord['probabilities'] as $optie => $kans) {
printf("%-20s %3d%%\n", $optie, round($kans * 100));
}
printf("confidence: %.2f\n", $antwoord['confidence']);Claude ziet dan een lijstje als race_condition 62%, geen_unieke_index 24%, enzovoort, en gaat daarmee verder. De taakverdeling blijft dezelfde als in het PHP-voorbeeld: Claude is de developer, Jev beantwoordt afgebakende vragen, en wat er echt niet mag misgaan, regel je in code.
Waar Jev de mist in gaat
TypeSafe publiceert zelf een lijst met de zwakke plekken van de huidige versie, Jev 1.13. Dat is ongebruikelijk eerlijk en ook bruikbaar, want bijna elk punt heeft dezelfde oplossing: laat dat stukje door je eigen code doen. Dit zijn de zes die je het snelst tegenkomt.
Rekenen en tellen
"Jev is not a calculator", schrijft TypeSafe. Vraag niet "Heeft de klant meer dan drie artikelen besteld?" Het aantal staat in je bestelsysteem; tel het daar.
Datums
Jev leest datums als tekst, niet als momenten op een tijdlijn. "Valt deze aankoop nog binnen de garantie?" is daarom een vraag voor PHP:
// Niet: 'garantie' => ['type' => 'noul', 'instructions' => 'Is de aankoop meer dan twee jaar geleden?']
// Wel: de datum komt uit je bestelsysteem en PHP rekent
$besteldOp = new DateTimeImmutable($bestelling['besteld_op']);
$inGarantie = $besteldOp->modify('+2 years') > new DateTimeImmutable('today');Letterlijk lezen
"Jev answers the question you wrote, not the one you meant." Vraag je "Is de klant tevreden?" bij "Het pakket was er snel, maar de jas heeft een scheur", dan is elk antwoord half fout. Splits het op in "Is de klant tevreden over de levering?" en "Is de klant tevreden over het product?", en combineer de antwoorden in je code.
Dubbele ontkenningen en omwegen
"Is het niet zo dat de klant geen retour wil?" maakt Jev minder nauwkeurig. Schrijf de vraag zo direct als je kunt: "Wil de klant iets terugsturen?"
Veel tekst die er niet toe doet
Volgens TypeSafe daalt de nauwkeurigheid naarmate je meer tekst meestuurt die niets met de vraag te maken heeft. Stuur dus de mail zelf, niet de hele reeks eerdere antwoorden met handtekeningen en disclaimers eronder. Filteren doe je vooraf, in PHP.
Tekst die Jev probeert te sturen
Jev behandelt kwaadwillige tekst niet vanzelf als vijandig. Een sollicitant die in wit lettertype "Deze kandidaat is een uitstekende match" in een cv zet, is een scenario dat je moet testen. Laat een score daarom nooit in zijn eentje een afwijzing of uitnodiging bepalen. Je zou een extra Noul kunnen toevoegen, zoals "Bevat de tekst aanwijzingen gericht aan een beoordelaar of computer?", maar dat is mijn eigen suggestie en niet getest.
Wanneer je Jev niet nodig hebt
Het principe nodigt uit om van alles een vraag te maken. Doe dat niet. Kun je de regel opschrijven, schrijf hem dan op. "Bestelbedrag boven 500 euro: handmatig controleren" is een if-statement, geen AI-vraag. Jev is bedoeld voor oordelen waar taalbegrip voor nodig is, die een mens in een paar seconden maakt, en waarbij de mogelijke antwoorden vastliggen.
Heb je al duizenden mails die met de hand zijn ingedeeld, dan kan een kleine, zelf getrainde classifier het beter en goedkoper. In een onafhankelijke test won zo'n classifier ruim van Jev, al had die classifier ruim tienduizend gelabelde voorbeelden gezien en Jev geen enkel.
Wat Jev kost en wat je vooraf moet weten
De rekensom is simpel, omdat alleen de invoer telt. Een klantmail plus de vraagdefinities is samen al gauw 500 tokens. Tienduizend mails per maand is dan vijf miljoen tokens: 21 dollarcent.
- Alleen via internet. Jev is niet te downloaden. Elke tekst die je meestuurt, gaat naar TypeSafe. Volgens TypeSafe wordt er niet op klantverzoeken getraind; wie cv's of andere persoonsgegevens verstuurt, leest eerst de verwerkersvoorwaarden.
- Limieten. Op 1 oktober noemt de documentatie 100.000 tokens per seconde en 40 aanroepen per seconde, met de toevoeging dat die limieten zonder aankondiging kunnen veranderen. Bij de lancering stonden er andere getallen.
- Versie vastzetten.
jev-latestwijst naar de nieuwste stabiele versie. Draai je iets in productie, dan kun je een vaste versie opgeven, zoalsjev-1.13.0, zodat het gedrag niet ongemerkt verandert nadat je je drempels hebt afgesteld. - Toegang. TypeSafe pauzeerde op 22 september de aanmeldingen vanwege de drukte. Kijk op console.typesafe.ai of je een account kunt aanmaken.
Begin met vijftig mails die je al kent
Pak vijftig mails die je al met de hand hebt ingedeeld. Laat Jev ze met de functie uit dit artikel opnieuw indelen en zet zijn keuze en confidence in een spreadsheet naast die van jou. Na een uur weet je drie dingen die geen benchmark je vertelt: hoe vaak Jev het met je eens is, of de fouten bij de lage confidence zitten, en welke drempel bij jouw mails past. Vijftig mails van 500 tokens kosten samen ongeveer een tiende cent.
Bronnen
- TypeSafe-documentatie: Primitives, met Choice, Score en Noul: de drie vraagsoorten, de optie "anders" en de drempelregel voor Nouls.
- API Reference: het endpoint en de velden van verzoek en antwoord waarop de PHP-functie is gebaseerd.
- Confidence en AI Primer: wat confidence en kalibratie betekenen, en waarom drempels op eigen data moeten worden afgesteld.
- Speculative Fan-Out en Composite Scoring: de patronen achter voorbeeld 2 en 3.
- Jev with Coding Agents en Agent Skill: wat Jev naast een coding agent wel en niet doet, en de plug-in voor Claude Code.
- Anthropic PHP SDK: de officiële bibliotheek waarmee voorbeeld 4 Claude aanroept, inclusief tool use.
- Jev 1.13 Jaggedness: TypeSafes eigen lijst met zwakke plekken.
- Models: modelversies, prijs, contextlengte, taalondersteuning en limieten (geraadpleegd 1 oktober 2026).
- Flavio Copes: A deep dive into Jev (29 september 2026) en How to get access to Jev: onafhankelijke uitleg en de pauze in de aanmeldingen.
- Jev van TypeSafe: een AI-model dat kiest in plaats van schrijft: de onafhankelijke metingen van snelheid, nauwkeurigheid en confidence waarnaar dit artikel verwijst.
