Zo evalueer je AI-agents: testsets, beoordelaars en regressiecontroles

Achter elk geweldig AI-product zit een sterk evaluatieproces voor AI-agents, ook wel evals genoemd, dat fouten vroegtijdig opspoort en ervoor zorgt dat de agent naar behoren functioneert. Evals zijn cruciaal voor AI-agents die risicovolle acties uitvoeren, zoals terugbetalingen namens iemand anders.

Voor het opzetten van dat proces heb je enige technische kennis en vaardigheden in data-analyse nodig. Maar het is lang niet zo eng of ontoegankelijk als het misschien klinkt. Om je op weg te helpen, hebben we zes praktische stappen voor het evalueren van AI-agents op een rij gezet, plus veelvoorkomende misvattingen die het proces ondermijnen.

Wat houdt het evalueren van een AI-agent in?

Een AI-agent evalueren betekent beoordelen hoe goed de agent taken correct uitvoert en of zijn beslissingen voldoen aan de eisen van de organisatie. In de praktijk zijn evaluaties van AI-agents, of evals, specifieke metrics waarmee organisaties kunnen bepalen of de agent betrouwbaar genoeg werkt voor de beoogde rol.

Denk aan een AI-inkoopagent in een productiefabriek die de voorraad reserveonderdelen controleert en aanvullingsverzoeken voorbereidt. Als een goedgekeurd onderdeel niet beschikbaar is of de leveranciersinformatie verouderd is, signaleert de agent dan het probleem of raadt hij een niet-goedgekeurd alternatief aan?

En als je de systeemprompt aanpast om dat probleem op te lossen, hoe weet je dan dat je geen nieuw probleem hebt geïntroduceerd?

Zonder evaluatie blijft het voor productmanagers in feite gissen. Evals bieden daarom een feedbacksignaal om prestaties te meten, terugkerende problemen op te sporen en wijzigingen met meer vertrouwen te testen.

Daarbij kan een agentevaluatie verschillende aspecten van een run onderzoeken:

• De kwaliteit van het eindresultaat
• De informatie die de agent heeft gebruikt
• De tools die de agent heeft aangeroepen
• Of de agent de regels voor zijn gedrag heeft gevolgd

Veelgebruikte metrics voor de evaluatie van AI-agents

Evals werken met kwalitatieve en kwantitatieve gegevens. Kwalitatieve evaluatie helpt je te begrijpen wat er gebeurt en waarom, onder meer door beslissingen van de agent handmatig te beoordelen. Kwantitatieve evaluatie zet die observaties om in meetbare signalen, zoals tellen hoe vaak specifieke faalwijzen voorkomen of het slagingspercentage van taken berekenen.

Dit zijn de belangrijkste metrics voor de evaluatie van AI-agents:

• Taaksucces meet of de agent het beoogde resultaat heeft bereikt; meestal uitgedrukt als het percentage runs dat geldige resultaten oplevert.
• Correctheid van acties meet of de agent tools op de juiste manier heeft gebruikt, geldige argumenten heeft gekozen en machtigingen heeft gerespecteerd.
• Antwoordkwaliteit beoordeelt of de uiteindelijke output nauwkeurig, volledig en nuttig is. Dit kan gaan om feitelijke juistheid, het naleven van instructies en de vraag of de agent zijn beslissingen onderbouwt met de beschikbare informatie.
• Betrouwbaarheid meet de consistentie bij herhaalde pogingen, wisselende inputs en randgevallen.
• Kosten en latentie meten de middelen die nodig zijn om een succesvol resultaat te behalen, waaronder uitvoeringstijd, tokenverbruik en toolaanroepen.

Afhankelijk van wat je meet, kunnen evals de end-to-end prestaties van een agent, het uitvoeringstraject of afzonderlijke componenten zoals toolaanroepen en ophaalstappen beoordelen.

Stap 1: Bepaal hoe een succesvolle agentrun eruitziet

Beschrijf eerst expliciet wat de agent moet bereiken — de productvereisten. Dat klinkt vanzelfsprekend, maar het kan verrassend lastig zijn. Er is zelfs een naam voor: de specificatiekloof.

Zo pak je dat aan, volgens Andrey Khomutov, onze senior data scientist:

“Begin met twee vragen: ‘Wanneer geldt de taak als uitgevoerd?’ en ‘Wat zou een ogenschijnlijk succesvolle run onaanvaardbaar maken?’

Voor agents betekent dat technisch gezien dat je zowel het resultaat controleert als de manier waarop ze daar zijn gekomen.”

Een agent kan het juiste antwoord geven doordat hij toegang krijgt tot een uitgelekte antwoordenlijst, of ongeautoriseerde acties uitvoeren tijdens het voltooien van zijn taak. Khomutov wijst erop dat uitgelekte antwoorden en onveilige acties tijdens evaluaties concrete redenen zijn om niet alleen het eindantwoord te beoordelen.

“Ik verwacht dat trajectinspectie een standaardonderdeel wordt van eval-suites voor agents, in plaats van iets wat we alleen doen als een resultaat verdacht lijkt,” voegt hij eraan toe.

Schakel vervolgens een domeinexpert in om je succescriteria te valideren. Mensen met praktische kennis van het domein kunnen beoordelen of de voorwaarden die we voor een AI-agent stellen een succesvol resultaat weerspiegelen.

Stap 2. Stel een testset samen op basis van echte taken en fouten

Bestudeer het daadwerkelijke gedrag van de agent om te begrijpen hoe goede en slechte prestaties eruitzien. Weersta de verleiding om te beginnen met het genereren van tientallen tests die alleen gebaseerd zijn op wat er volgens jou mis zou kunnen gaan.

Hamel Husain, ML-engineer bij Parlance Lab, en Shreya Shankar, onderzoeker op het gebied van ML-systemen en evals voor toegepaste AI, raden aan om te beginnen met foutanalyse, een techniek die is overgenomen uit machine learning en data science. Het proces begint met een kwalitatieve analyse van de uitvoeringstraces van de agent — vastleggingen van de input van de gebruiker, toolaanroepen, opgehaalde informatie en de output van de agent.

1. Bekijk afzonderlijke traces en annoteer fouten (open coderen). Laat een domeinexpert agentruns inspecteren en korte observaties noteren over wat er misging. Richt je op de eerste betekenisvolle fout.
2. Groepeer observaties in faalwijzen (axiaal coderen). Zodra je genoeg notities hebt, laat je een LLM categorieën voorstellen voor vergelijkbare fouten. Denk aan aanbevelingen voor incompatibele onderdelen, onjuist opgehaalde voorraadgegevens en mislukte overdrachten aan een mens.
3. Tel de voorvallen. Wijs elke observatie toe aan een categorie en gebruik vervolgens een spreadsheet of draaitabel om te berekenen hoe vaak elke faalwijze voorkomt.
4. Bepaal wat je als eerste aanpakt, rekening houdend met zowel frequentie als ernst.
5. Zet belangrijke fouten om in testcases. Sla de relevante input, de beginvoorwaarden, het verwachte resultaat en de beoordelingscriteria op, zodat de agent opnieuw met hetzelfde scenario kan worden getest.

Hoeveel traces moet je bekijken? Ongeveer 100, maar er bestaat geen magisch getal. Stop eerder zodra je theoretische verzadiging bereikt: het punt waarop het bekijken van extra traces geen betekenisvolle nieuwe foutpatronen meer oplevert.

Heb je de applicatie nog niet gelanceerd? Synthetische voorbeelden kunnen helpen een eerste testset op te bouwen, maar zodra er echte gebruikersgegevens beschikbaar zijn, moeten die de basis vormen.

Het gebruik van benchmarks bij de evaluatie van AI-agents

Naast het maken van je eigen testcases kun je bestaande verzamelingen gestandaardiseerde evaluatietaken gebruiken, zogenoemde benchmarks, om de mogelijkheden van agents te beoordelen.

Maar benchmarks zijn niet onfeilbaar. Audits van SWE-bench, de benchmarkreviews van Epoch AI en correcte antwoorden die in TheoPhysEval aanvankelijk werden afgewezen laten zien hoe gebrekkige taken of verwachte antwoorden evaluatieresultaten kunnen vertekenen.

Khomutov adviseert om actuele benchmarks te kiezen die relevant zijn voor je domein, en verrassende successen of mislukkingen te onderzoeken voordat je de scores als betrouwbaar bewijs van de prestaties van de agent beschouwt.

Stap 3. Voer de agent uit in een reproduceerbare testomgeving

Een reproduceerbare testomgeving is een gecontroleerde opzet waarin je een AI-agent dezelfde testcases kunt laten doorlopen onder dezelfde beginvoorwaarden en de resultaten kunt vergelijken. Denk aan een map met testcases, een Python-script dat de agent uitvoert of een reeks controles die de resultaten evalueren.

Je kunt beginnen door representatieve inputs als JSON-bestanden op te slaan en een Python-script te gebruiken om de workflow van je agent uit te voeren en de outputs met asserties te controleren. Voor de voorraadagent van onze productiefabriek kan een reproduceerbare testomgeving er zo uitzien:

Vergroten

Volg deze stappen om een reproduceerbare testomgeving op te zetten:

1. Sla representatieve inputs op. Bewaar echte gebeurtenissen of testcases in dezelfde structuur die je applicatie in productie ontvangt. In ons scenario sla je een onderhoudsverzoek met de machine-ID, het benodigde reserveonderdeel en de onderhoudsdatum op als JSON-bestand, samen met een momentopname van de voorraadgegevens en de gegevens over goedgekeurde onderdelen.
2. Voer de workflow uit. Laat de agent elke input verwerken, inclusief de ophaalstappen, toolaanroepen en het genereren van het antwoord.
3. Leg het resultaat en de trace vast. Registreer de uiteindelijke output en relevante tussenliggende acties (zoals het raadplegen van de voorraad), zodat je niet alleen ziet of de agent heeft gefaald, maar ook waar.
4. Herhaal cases op basis van de ernst en frequentie van de fout en hoe moeilijk het probleem op te lossen is. LLM-applicaties zijn niet-deterministisch (ze kunnen bij identieke inputs verschillende resultaten opleveren), dus een geslaagde run is geen garantie dat de volgende ook slaagt. Rapporteer het aandeel geslaagde pogingen en onderzoek de mislukkingen.

Voor dat laatste adviseert Khomutov om pass@1 te meten (hoe vaak de agent bij één poging slaagt) en pass@k (de kans om minstens één keer te slagen binnen een bepaald aantal pogingen). Rapporteer je pass@k, vermeld dan het aantal pogingen, want één correct antwoord tussen meerdere betekent nog niet dat de agent weet welk antwoord hij moet kiezen.

Naarmate je applicatie groeit, kun je een testframework zoals pytest gebruiken om tests te organiseren en uit te voeren, en kun je overwegen grote testdatasets en resultaten in een database op te slaan.

Stap 4. Kies voor elke controle de juiste beoordelaar

Een beoordelaar (vaak ook evaluator genoemd) is een mechanisme in de vorm van een stuk code, een LLM dat wordt gestuurd door een beoordelingsrubric, of een menselijke reviewer die de output of actie van een agent toetst aan een vastgesteld criterium. Een beoordelaar geeft een oordeel geslaagd/niet geslaagd terug, met een toelichting die het relevante bewijs aanwijst.

Info: Een beoordelingsrubric is een set criteria en instructies die bepaalt wat geldt als een correct of acceptabel resultaat.

Welk type beoordelaar geschikt is, hangt af van wat je wilt verifiëren. Zo verhouden de drie benaderingen zich tot elkaar:

Soms vereisen verschillende aspecten van dezelfde run verschillende evaluatiemethoden, waardoor je mogelijk beoordelaars moet combineren.

Hoe combineer je beoordelaars?

Je vraagt je af: “Kan het resultaat worden geverifieerd aan de hand van een bekende regel of verwachte waarde, of is er een menselijk oordeel voor nodig?”

• Als je het resultaat exact kunt verifiëren, begin dan met een codegebaseerde beoordelaar. Codegebaseerde beoordelaars kunnen ook gestructureerde outputs, geldige veldwaarden, toolargumenten of de eindtoestand van een database verifiëren.
• Als je voor de controle context moet interpreteren, gebruik dan LLM-as-a-judge.
• Schakel menselijke reviewers in voor domeinspecifieke of betwiste beslissingen.

Belangrijk! Een LLM-beoordelaar kan bewijs verkeerd interpreteren of een rubric onjuist toepassen. Daarom is een extra evaluatiestap nodig: kalibratie aan de hand van menselijke oordelen.

Kalibreer de LLM-beoordelaar aan de hand van menselijke oordelen.

Bij kalibratie beoordeelt een domeinexpert in wezen echte agentruns. Vervolgens vergelijkt de expert die oordelen met die van het LLM en verfijnt de beoordelingsrubric op basis van de verschillen.

Dit is een kalibratieproces voor beoordelaars in vijf stappen:

1. Verzamel voorbeelden van inputs en outputs van de agent en relevante traces.
2. Laat een domeinexpert onafhankelijk beoordelen of elk voorbeeld aan het evaluatiecriterium voldoet.
3. Laat de LLM-beoordelaar die voorbeelden beoordelen.
4. Vergelijk de oordelen van de mens en het model.
5. Onderzoek de verschillen en verfijn de rubric van de beoordelaar voordat je deze op nieuwe voorbeelden test.

Khomutov benadrukt ook het belang van het afzonderlijk testen van de consistentie van de LLM-beoordelaar:

“Geef hem meerdere keren exact dezelfde opgeslagen run en bestanden, zonder de agent opnieuw uit te voeren. Zo kun je variatie in het werk van de agent scheiden van variatie in de beoordeling.”

Als dezelfde output verschillende oordelen krijgt, ga er dan niet van uit dat elke scorewijziging door de agent komt. Bekijk in plaats daarvan een confusiematrix die laat zien wanneer de beoordelaar fouten correct herkende, ze miste of acceptabele outputs ten onrechte als fout markeerde.

Menselijke review blijft essentieel voor het vaststellen van referentieoordelen, het beslechten van betwiste gevallen en het ontdekken van nieuwe faalwijzen die bestaande beoordelaars niet kunnen detecteren omdat ze daar niet voor zijn ontworpen.

Stap 5. Vergelijk versies en voer regressiecontroles uit

Stel dat uit foutanalyse blijkt dat je voorraadagent vaak niet-goedgekeurde vervangende onderdelen aanbeveelt. Je past de systeemprompt aan zodat een expliciete compatibiliteitscontrole verplicht is. De case die eerst faalde, slaagt nu. Maar hoe weet je zeker dat de wijziging geen invloed heeft gehad op andere taken?

Daar komt regressietesten om de hoek kijken.

Regressietesten houdt in dat je eerder geslaagde testcases opnieuw uitvoert nadat je de prompt, het model of de workflow van een agent hebt gewijzigd, om te controleren of de wijziging geen nieuwe fouten heeft veroorzaakt.

1. Reproduceer de oorspronkelijke fout met een opgeslagen input uit de testset.
2. Breng een gerichte wijziging aan in de prompt, het model of de workflow.
3. Voer de falende test opnieuw uit om te controleren of het probleem is opgelost.
4. Voer de andere tests uit om te controleren of de wijziging geen gedrag heeft verstoord dat eerder goed werkte.
5. Bekijk de resultaten en onderzoek eventuele nieuwe fouten.

Vergelijk voor nauwkeurige resultaten de referentieversie met de bijgewerkte agent, aan de hand van dezelfde testcases en beoordelingscriteria.

Stap 6: Monitor de prestaties van AI-agents in productie

Agentevaluatie stopt niet zodra je je applicatie hebt geïmplementeerd. Zoals Husain en Shankar uitleggen, kun je dezelfde evaluatoren die je tijdens de ontwikkeling gebruikt ook toepassen op echte productiedata om te meten hoe je agent in de loop van de tijd presteert.

Dit wordt online-evaluatie genoemd en maakt deel uit van een breder monitoringproces in productie dat helpt om terugkerende en voorheen onbekende fouten aan het licht te brengen.

Het proces is iteratief en bestaat uit vier elkaar aanvullende activiteiten:

• Zet gekalibreerde LLM-beoordelaars in op productietraces. Neem steekproeven van echte agentinteracties en pas de evaluatoren toe die je al hebt gevalideerd aan de hand van menselijke beoordelingen.
• Houd foutpercentages in de loop van de tijd bij. Gebruik de foutcategorieën die je tijdens de foutanalyse hebt vastgesteld om terugkerende problemen te kwantificeren.
• Blijf traces handmatig beoordelen. Geautomatiseerde beoordelaars detecteren alleen de problemen waarvoor ze zijn ontworpen. Bekijk handmatig steekproeven van echte agentinteracties om nieuwe fouten of ongebruikelijke gebruikersverzoeken te ontdekken.
• Gebruik A/B-tests om bedrijfsresultaten te meten (alleen wanneer dat zinvol is). Vergelijk verschillende prompts, modellen of workflows aan de hand van metrics zoals taakvoltooiing, gebruikerstevredenheid en tijd tot oplossing. Zo kun je bepalen of een wijziging de daadwerkelijke productervaring verbetert, en niet alleen of afzonderlijke tests slagen.

Een belangrijke kanttekening: evals hoeven niet tot in de perfectie te zijn uitgewerkt. Ze moeten simpelweg goed genoeg zijn om je product te verbeteren.

Veelvoorkomende misvattingen over de evaluatie van AI-agents

• Evals zijn gewoon unittests. Dat klopt niet: unittests zijn kleine, geautomatiseerde controles die slechts één onderdeel van evaluatie vormen. Evals omvatten ook kwalitatieve foutanalyse, menselijke beoordelingen, monitoring in productie en experimenten om de kwaliteit van de applicatie te meten.
• Een evaluatieplatform kan alles voor je doen. Kant-en-klare tools kunnen sommige controles automatiseren, maar ze kunnen niet bepalen welke faalwijzen (soorten fouten of ongewenst agentgedrag) belangrijk zijn voor je product.
• Je kunt een LLM alles laten evalueren. Dat is een grote misvatting. Door mensen geleide foutanalyse en kalibratie van beoordelaars blijven essentieel, omdat LLM's de bedrijfscontext missen die nodig is om elk probleem te ontdekken.
• A/B-tests of het simpelweg gebruiken van de agent vervangen evals. Onjuist. A/B-tests kunnen laten zien welke versie beter presteert op de gekozen metrics, maar kunnen de onderliggende problemen op zichzelf niet verklaren.

Veelgestelde vragen over de evaluatie van AI-agents

1. Wat is het verschil tussen de evaluatie van AI-agents en LLM-evaluatie?

LLM-evaluatie meet hoe goed een taalmodel een bepaalde taak uitvoert, zoals een vraag beantwoorden, een document samenvatten of informatie extraheren. Evaluatie van AI-agents beoordeelt een systeem dat zelfstandig meerdere stappen uitvoert om een taak te voltooien.

In tegenstelling tot een typische LLM-evaluatie onderzoekt agentevaluatie zowel het eindresultaat als de reeks acties die zijn ondernomen om dat resultaat te bereiken, inclusief toolaanroepen, beslissingen en naleving van vooraf gedefinieerde regels.

2. Belangrijke metrics voor de evaluatie van AI-agents

Metrics voor de evaluatie van AI-agents vallen in twee brede categorieën:

• Technische prestatiemetrics: slagingspercentage van taken, correctheid van acties, kwaliteit van antwoorden, betrouwbaarheid (pass@1 en pass@k), latentie, tokengebruik en kosten per geslaagde taak.
• Metrics voor bedrijfsresultaten en gebruikerservaring: klanttevredenheid (CSAT), oplossingspercentage van problemen, escalatiepercentage, conversieratio, doorlooptijd van taken en andere resultaten die specifiek zijn voor de rol van de agent.

Een klantenservice-agent kan bijvoorbeeld worden beoordeeld op het succesvol oplossen van problemen en op klanttevredenheid, terwijl een AI-inkoopagent kan worden gemeten aan de hand van de nauwkeurigheid van aanvullingsverzoeken, goedkeuringspercentages en de doorlooptijd van de inkoopcyclus.

De juiste metrics moeten weerspiegelen hoe betrouwbaar de agent presteert én of zijn werk de bedrijfsresultaten verbetert.

3. Wat zijn de beste tools voor het evalueren van AI-agents?

Veelgebruikte opties zijn onder meer:

• Testframeworks: Python-asserties en pytest zijn handig om herhaalbare testcases uit te voeren en exacte voorwaarden te controleren, bijvoorbeeld of een agent de juiste tool heeft gekozen of een geldig onderdeel-ID heeft teruggegeven.
• Evaluatieframeworks voor AI-agents: DeepEval en de agent-eval toolkit van Google ondersteunen complexere evaluaties, waaronder uitvoeringstraces, op LLM's gebaseerde beoordelaars en geautomatiseerde regressietests.
• Evaluatie- en observability-platforms: LangSmith, Arize Phoenix en MLflow helpen teams om agentgedrag te inspecteren, evaluatiedatasets te beheren, agentversies te vergelijken en prestaties in productie te monitoren.

4. Hoe automatiseer je evaluaties van AI-agents?

Je kunt evaluaties van AI-agents automatiseren door herhaalbare tests te bouwen, geautomatiseerde beoordelaars toe te passen en die controles te integreren in je ontwikkel- en productieworkflows:

1. Stel een evaluatiedataset samen: verzamel representatieve gebruikerstaken, verwachte uitkomsten, bekende fouten en uitvoeringstraces van de agent. Neem ook randgevallen op, zoals mislukte toolaanroepen, ontbrekende informatie en ongeautoriseerde acties.
2. Automatiseer testuitvoering en beoordeling: gebruik frameworks zoals pytest of DeepEval om testcases uit te voeren en codegebaseerde controles of LLM-beoordelaars toe te passen. Valideer LLM-beoordelaars aan de hand van menselijke beoordelingen voordat je op hun scores vertrouwt.
3. Integreer evaluaties in CI/CD: voer regressietests automatisch opnieuw uit wanneer ontwikkelaars de prompts, modellen, tools of workflow van een agent bijwerken. Vergelijk de resultaten met een referentiepunt en stel kwaliteitsdrempels in die releases tegenhouden wanneer cruciale controles mislukken.
4. Pas gekalibreerde beoordelaars toe op steekproeven van productietraces, houd foutpercentages en andere prestatiemetrics bij en onderzoek nieuwe fouten via handmatige beoordeling.