💬 NLP

Evaluating Tool-Using Language Agents: Judge Reliability, Propagation Cascades, and Runtime Mitigation in AgentProp-Bench

Deze studie introduceert AgentProp-Bench, een benchmark die aantoont dat geautomatiseerde evaluaties van tool-gebruikende LLM-agenten vaak onbetrouwbaar zijn vergeleken met menselijke annotatie, en analyseert foutpropagatie en de effectiviteit van runtime-mitigatiestrategieën.

Oorspronkelijke auteurs: Bhaskar Gurram

Gepubliceerd 2026-04-21

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Bhaskar Gurram

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer slimme, maar soms wat slordige assistent hebt die voor je werkt. Deze assistent kan niet alleen praten, maar ook echte taken uitvoeren: hij kan weerberichten opzoeken, afspraken inplannen of medicijnen bestellen. In de tech-wereld noemen we dit een "LLM-agent" (een taalmodel dat werkt als agent).

Het probleem is: wat gebeurt er als deze assistent een fout maakt? Soms typt hij het verkeerde telefoonnummer in, of hij negeert een foutmelding en doet alsof alles goed is. De hele boel kan dan in de war raken.

Deze paper, getiteld AgentProp-Bench, is als een grote, eerlijke test die uitvindt hoe goed we deze fouten kunnen opsporen en hoe ze zich verspreiden. Hier is de uitleg in gewone taal, met een paar leuke vergelijkingen:

1. Het grote misverstand: "Kijk maar of het antwoord klopt"

Tot nu toe keken onderzoekers naar het eindantwoord van de assistent en zeiden: "Zie je die zin? Die lijkt op het juiste antwoord, dus hij heeft het goed gedaan!"

De auteurs zeggen: "Nee, dat is gevaarlijk!"
Stel je voor dat je een toets opeet en er staat "Ik heb de toets gegeten" op je bord, terwijl het antwoord "Ik heb de toets gemaakt" was. Als je alleen kijkt naar het woord "toets", denk je dat het goed is. Maar de assistent heeft de toets opgegeten (een hallucinatie)!

De ontdekking: De auteurs hebben gekeken of die simpele "woord-match" methode werkt. Het resultaat? Het werkt niet. Het is net zo betrouwbaar als het gooien van een muntje (50/50).
De oplossing: Ze hebben een "jury" van drie slimme AI's opgezet om samen te oordelen. Dit werkt veel beter (ongeveer 43% betrouwbaar), maar is nog steeds niet perfect. Ze hebben ook 100 mensen ingehuurd om te kijken of de AI's het echt goed deden.

2. De Raket van de Fout (Error Propagation)

Dit is het coolste deel van het onderzoek. De auteurs hebben een experiment gedaan waarbij ze opzettelijk een fout in het systeem stopten.

Het experiment: Ze gaven de assistent een opdracht om het weer in Londen te checken, maar ze veranderden de stad in de instructie stiekem naar "Manchester" (een geldige stad, maar de verkeerde).
De vraag: Hoe vaak leidt die ene kleine fout tot een volledig verkeerd eindantwoord?

Het bleek dat de fout vaak verspreidt als een dominosteen:

De assistent ziet de fout niet (hij accepteert de verkeerde stad).
Hij vraagt het weerbericht voor Manchester.
Hij geeft het antwoord voor Manchester als antwoord voor Londen.

De les: Als de assistent de fout niet direct "terugkaatst" (rejection), is de kans ongeveer 62% dat hij aan het einde een volledig verkeerd antwoord geeft. Het is alsof je een verkeerd ingrediënt in een cake doet; als je het niet op tijd verwijdert, is de hele cake on eetbaar.

3. Twee verschillende vaardigheden: "Weigeren" en "Herstellen"

De auteurs ontdekten iets verrassends over hoe slim deze assistenten zijn. Ze hebben twee soorten "veerkracht" gemeten:

Weigeren (Rejection): Kan de assistent zeggen: "Hé, dit is een verkeerde stad, ik doe dit niet!"?
Herstellen (Recovery): Als hij de fout toch heeft geaccepteerd, kan hij later denken: "Wacht, dit klopt niet, ik ga het opnieuw doen"?

De verrassing: Deze twee vaardigheden hebben niets met elkaar te maken!

Een assistent kan heel goed zijn in het weigeren van fouten (hij is streng), maar heel slecht in het herstellen ervan als hij toch een fout maakt.
Een andere assistent kan heel makkelijk fouten accepteren, maar als hij eenmaal een fout ziet, kan hij die soms nog wel oplossen.
Vergelijking: Het is alsof je een auto hebt met een perfecte rem (weigeren), maar slechte stuurbekrachtiging (herstellen), of andersom. Je moet ze apart testen.

4. De "Politieagent" (Runtime Interceptor)

Om de assistent te helpen, hebben de auteurs een klein hulpmiddel gebouwd: een Interceptor. Dit is als een politieagent die meekijkt terwijl de assistent werkt.

Als de assistent een fout maakt, grijpt de agent in en zegt: "Stop! Dit ziet er raar uit."
Resultaat: Voor één type assistent (GPT-4o-mini) werkte dit fantastisch. De fouten daalden met 23%!
Maar: Voor een andere assistent (Gemini) werkte het niets. Waarom? Omdat die assistent al zo streng is dat hij de fouten zelf al weigert voordat de agent erbij kan komen. De agent had dus niets te doen.

Conclusie: Wat leren we hieruit?

Stop met simpele zoekopdrachten: Je kunt niet vertrouwen op het controleren van enkele woorden om te zien of een AI-agent goed werkt. Je hebt menselijke of slimme jury's nodig.
Fouten verspreiden zich snel: Een kleine fout in een parameter kan de hele taak verpesten.
Twee soorten slimheid: Een goede AI moet zowel goed zijn in het niet doen van fouten, als in het oplossen ervan als ze toch gebeuren.
Oplossingen zijn maatwerk: Wat werkt voor de ene AI, werkt niet voor de andere. Je moet weten wat je model kan voordat je een "veiligheidsnet" toevoegt.

Kortom: Deze paper is een waarschuwing aan de tech-bedrijven: "Kijk niet alleen naar het eindresultaat, maar kijk ook hoe de assistent denkt en waar hij struikelt, anders bouw je een huis op zand."

Probleemstelling

De automatische evaluatie van tool-gebruikende Large Language Model (LLM) agents wordt vaak als betrouwbaar beschouwd, maar deze aanname is zelden gevalideerd tegen menselijke annotatie. Bestaande benchmarks (zoals $\tau$ -bench en AgentBench) rapporteren vaak slechts één eindresultaat voor "eind-tot-eind" correctheid en kunnen niet lokaliseren waar in de pijplijn een fout optreedt of hoe deze zich voortplant.

Daarnaast is de evaluatiemethode zelf problematisch:

Onbetrouwbare Judges: De meeste benchmarks gebruiken subreeks- of trefwoord-matching heuristieken om te bepalen of een antwoord correct is. Het paper toont aan dat deze methoden in het context van tool-gebruikende agents nauwelijks beter presteren dan willekeur (kansniveau).
Gebrek aan causaliteit: Er is weinig inzicht in hoe een fout in een parameter (bijv. een verkeerde API-parameter) zich door de hele agent-pijplijn voortplant tot een verkeerd eindantwoord.
Beperkte mitigatie-evaluatie: Bestaande methoden voor runtime-mitigatie worden zelden getest onder strikt gecontroleerde, gelijktijdige experimenten.

Methodologie: AgentProp-Bench

Het paper introduceert AgentProp-Bench, een benchmark met 2.000 taken en 2.300 traces over vier domeinen (Kalender, Weer, Medisch, Kennis) en een vastgehouden Retail-domein. De kernmethodologie omvat:

Gecreëerde Fouten (Error Injection):
- In plaats van te vertrouwen op natuurlijk voorkomende fouten, gebruikt het paper een gecontroleerd P2-semantisch-fout-injectieprotocol.
- Voor de uitvoering van de eerste tool-call wordt een semantisch kritieke parameter vervangen door een incorrecte, maar schema-geldige waarde (bijv. "London" vervangen door "Manchester").
- Dit stelt de auteurs in staat om de causale voortplanting van fouten te meten.
Validatie van de Judge (Beoordelaar):
- Er worden drie beoordelingsmethoden vergeleken:
  - Heuristisch: Subreeks-match (standaard in de industrie).
  - Ensemble: Een meerderheidsstemming van drie LLM's (GPT-4o, Gemini-2.5-Flash, GPT-4o-mini).
  - Menselijk: 100 gestratificeerde labels door een menselijke annotator.
- De ensemble-judge wordt gevalideerd tegen de menselijke labels om een "mens-gekalibreerde" waarheid te creëren.
Stap-voor-stap Voortplantingsmeting:
- De auteurs definiëren drie onafhankelijke indicatoren:
  - S1: Injectie toegepast (de geplande tool-call is gewijzigd).
  - S2: Zichtbare uitvoering (de gewijzigde call heeft een effect, bijv. een validatiefout of gewijzigd antwoord).
  - S3: Verkeerd eindantwoord (volgens de ensemble-judge).
- Hiermee wordt de "hop-conditional" voortplantingskans ( $P[S_{k+1}=1 | S_k=1]$ ) berekend.
Runtime Mitigatie (Interceptor):
- Een lichtgewicht Interceptor werkt parallel met de agent en bestaat uit drie lagen:
  - L1: Schema-validatie (telt validatiefouten).
  - L2: Monitoring van denkwoorden (zoekt naar onzekerheidswoorden als "error", "invalid").
  - L3: Consistentiecontrole van de output (checkt of numerieke claims worden ondersteund door tool-observaties).
- Het experiment wordt uitgevoerd met een gelijktijdige controlegroep (concurrent control) van 600 taken per model, waarbij alleen de aanwezigheid van de Interceptor verschilt.

Belangrijkste Bijdragen

Validatie van Judge-betrouwbaarheid: Het paper kwantificeert dat subreeks-matching nauwelijks overeenkomt met menselijke annotatie ( $\kappa = 0.049$ , kansniveau). Een drie-LLM ensemble bereikt echter matige overeenstemming ( $\kappa = 0.432$ ), hoewel het een conservatieve bias heeft.
Stap-voor-stap Voortplanting: Het introduceert een methode om foutvoortplanting te meten onder gevalideerde evaluatie. Een parameter-injectie leidt met een mens-gekalibreerde waarschijnlijkheid van $\approx 0.62$ tot een verkeerd eindantwoord.
Decompositie van Robuustheid: Het toont aan dat afwijzing (het detecteren van slechte parameters) en herstel (het corrigeren van een fout nadat deze is geaccepteerd) statistisch onafhankelijke vaardigheden zijn ( $\rho = 0.126$ ).
Runtime Mitigatie: Een getune Interceptor reduceert hallucinaties aanzienlijk voor bepaalde modellen, maar de effectiviteit is modelafhankelijk.
Open Benchmark: Alle data, traces, code en menselijke labels zijn openbaar gemaakt.

Resultaten

Judge Betrouwbaarheid:
- Heuristische matching ( $\kappa = 0.049$ ) is onbetrouwbaar.
- De ensemble-judge ( $\kappa = 0.432$ ) is een verbetering, maar neigt conservatief (onderrapportage van correctheid met ~13 procentpunten ten opzichte van mensen).
- Mensen accepteren vaak antwoorden die de ensemble-judge afwijst, vooral bij kleine formuleringverschillen.
Voortplanting van Fouten:
- Onder ensemble-judging is de kans dat een zichtbare uitvoering (S2) leidt tot een verkeerd antwoord (S3) ongeveer 78%.
- Na menselijke kalibratie daalt dit naar 62% (bereik 0.46–0.73 per model).
- Dit betekent dat als een fout eenmaal door de tool-pijplijn is gekomen, de kans groot is dat het eindresultaat verkeerd is.
Afwijzing vs. Herstel:
- Er is geen correlatie tussen het vermogen om fouten af te wijzen en het vermogen om te herstellen.
- Voorbeeld: Gemini-2.0-Flash heeft een zeer hoge afwijzingsgraad (95%) maar matig herstel. GPT-4.1-nano heeft een lage afwijzingsgraad en bijna geen herstelvermogen (2.9%).
- Dit impliceert dat het verbeteren van schema-validatie niet automatisch het redeneervermogen verbetert.
Runtime Interceptor Effect:
- Voor GPT-4o-mini reduceerde de Interceptor hallucinaties met 23,0 procentpunten (van 55,8% naar 32,8%) onder strikte controle.
- Voor Gemini-2.0-Flash was er geen significant effect. Omdat dit model al 95% van de fouten op het parameter-niveau afwijst, is er voor de Interceptor weinig "doelwit" over om te vangen.

Significantie en Implicaties

Voor Agent Ontwikkelaars:
- Schema-validatie is cruciaal: Strikte parameter-validatie (zoals bij Gemini) kan de meeste fouten blokkeren voordat ze de tool-executie bereiken.
- Dualiteit van Robuustheid: Ontwikkelaars moeten zowel het input-filteren (afwijzing) als het output-redeneren (herstel) apart evalueren en verbeteren.
- Model-specifieke mitigatie: Runtime-mitigaties zijn niet universeel effectief; ze zijn het meest nuttig voor modellen die een gematigde afwijzingsgraad hebben.
Voor Evaluatie en Onderzoek:
- Subreeks-heuristieken verwerpen: De bevinding dat $\kappa = 0.049$ is een sterk bewijs dat traditionele heuristieken in agent-benchmarks misleidend zijn en moeten worden vervangen door mens-gevalideerde of ensemble-judges.
- Nieuwe Standaard: AgentProp-Bench biedt een methodologie voor het meten van foutvoortplanting en het testen van mitigaties onder gecontroleerde omstandigheden, wat een stap vooruit is ten opzichte van puur eind-resultaatmetingen.
- Relevantie voor IR en QA: De bevindingen zijn direct toepasbaar op Retrieval-Augmented Generation (RAG) en vraag-antwoord systemen, waar output-variabiliteit ook vaak leidt tot onbetrouwbare automatische evaluaties.

Het paper concludeert dat de huidige evaluatiestandaard voor LLM-agents fundamenteel gebrekkig is en dat een combinatie van gevalideerde judges, stap-voor-stap voortplantingsanalyse en model-specifieke mitigatiestrategieën noodzakelijk is voor betrouwbare systemen.