🤖 machine learning

TTHE: Test-Time Harness Evolution

Dit artikel introduceert Test-Time Harness Evolution (TTHE), een ongesuperviseerd framework dat het uitvoerbare controleprogramma van een LLM-agent tijdens evaluatie dynamisch optimaliseert door een populatie van kandidaat-harnesses te evolueren op basis van executietraces, waardoor persistente adaptatie aan test-time distributies mogelijk wordt zonder modelgewichten bij te werken of grondwaarheid-labels te vereisen.

Oorspronkelijke auteurs: Jun Nie, Yonggang Zhang, Jun Song, Qianshu Cai, Dahai Yu, Yike Guo, Xinmei Tian, Bo Han

Gepubliceerd 2026-07-10

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jun Nie, Yonggang Zhang, Jun Song, Qianshu Cai, Dahai Yu, Yike Guo, Xinmei Tian, Bo Han

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 super-slimme robotassistent hebt (een LLM-agent) die code kan schrijven, wiskundige problemen kan oplossen of je vluchten kan boeken. Normaal gesproken besteden we weken aan het trainen van deze robots en daarna "bevriezen" we hun hersenen. Zodra ze bevroren zijn, kunnen we hun interne bedrading niet meer veranderen. Als ze een fout maken, kunnen we ze niet simpelweg vertellen: "Hé, probeer het de volgende keer anders te denken."

Maar wat als de instructies van de robot — het kleine programma dat de robot vertelt hoe hij zijn brein moet gebruiken — on the fly kunnen veranderen? Dat is het grote idee achter een nieuwe methode genaamd Test-Time Harness Evolution (TTHE).

De "Bevroren Brein, Flexibele Pak"-analogie

Beschouw het brein van de robot als een bevroren standbeeld. Je kunt het niet smelten of hervormen. Maar de robot draagt een hightech pak (de harness). Dit pak heeft zakken voor gereedschap, een checklist met stappen en een manier om te controleren of de robot een fout heeft gemaakt.

De meeste robots dragen een statisch pak. Zodra de robot de fabriek verlaat, is het pak dichtgenaaid. Als de robot een deur probeert te openen en faalt, weet het pak niet hoe het dat de volgende keer moet oplossen. Het blijft gewoon dezelfde gebroken manier proberen.

TTHE is als een pak dat zijn eigen naainstructies kan herschrijven terwijl de robot aan het werk is.

Zo werkt het in de praktijk:

De Robot Probeert: De robot probeert een taak uit te voeren (zoals het schrijven van een SQL-query of het oplossen van een bug). Het laat een "spoor van kruimels" achter (een execution trace) die precies laat zien wat het deed, welke tools het gebruikte en waar het struikelde.
Het Pak Leest de Kruimels: Een speciaal onderdeel van het pak (de Proposer) bekijkt die kruimels. Het heeft geen leraar of een correct antwoord nodig. Het vraagt alleen maar: "Hm, de robot probeerde de deur te openen, maar de klink was roestig. Misschien moeten we de klink de volgende keer eerst oliën?"
Het Pak Herschrijft Zichzelf: De Proposer bewerkt de code van het pak. Het voegt misschien een nieuwe stap toe om naar roest te controleren, of een nieuwe regel om de klink dubbel te controleren.
Het Pak Kiest de Beste Versie: Een ander onderdeel van het pak (de Judge) bekijkt alle nieuwe versies van het pak en kiest de versie die het beste lijkt te werken op basis van de eigen prestaties van de robot.
De Robot Gaat Verder: De robot werkt verder met dit nieuwe, verbeterde pak voor de volgende taak.

Wat deze methode Niet Doet

Het is belangrijk om te weten wat deze methode verwerpt:

Geen Hersenchirurgie: De paper stelt expliciet dat ze het bevroren brein van de robot (model weights) niet veranderen. Ze trainen de AI niet opnieuw. Ze veranderen alleen het pak (de harness).
Geen Magische Antwoordkaarten: Ze gebruiken geen "gold labels" (de juiste antwoorden) terwijl de robot leert. De robot moet zelf ontdekken wat werkt door simpelweg naar zijn eigen fouten en successen te kijken.
Geen Pre-planning: Ze zoeken niet naar het perfecte pak voordat de robot begint met werken. Het pak evolueert tijdens het werk.

De Resultaten: Hoe Goed Werkte het?

De onderzoekers testten dit op enkele zeer uitdagende opdrachten, zoals het schrijven van database-queries, competitieve programmering en het oplossen van softwarebugs. Ze vergeleken de robots met het "bevroren pak" tegenover de robots met het "evoluerende pak".

Dit is wat ze vonden (met de exacte cijfers uit hun tests):

Text-to-SQL (BIRD): De baseline-robot kreeg 12,0% goed. Met TTHE sprong dit naar 50,0%. Dat is een enorme verbetering!
Competitive Programming (LiveCodeBench): Het ging van 30,0% naar 38,3%.
Software Engineering (SWE-bench): Het verbeterde van 20,0% naar 35,0%.
Data Science (DS-1000): Het ging van 38,0% naar 44,0%.

Ze probeerden het zelfs op een tool-use taak genaamd claw-eval, waarbij de score iets anders is (een cijfer van 0 tot 1). De score ging van 48,9% naar 69,8%.

De Keerzijde: Het Is Niet Perfect

Het paper is zeer eerlijk over waar deze methode tegen een muur aanloopt. De "Judge" die het beste pak kiest, is niet perfect. Soms kiest de Judge een pak dat er goed uitziet, maar in werkelijkheid faalt bij verborgen tests.

De Selection Regret (Selectie-spijt): In één test, als de Judge het beste pak had gekozen uit de verzameling kandidaten die hij zag, had hij een nauwkeurigheid van 64,0% kunnen bereiken. Maar omdat de Judge een fout maakte en een iets minder goed pak koos, haalden ze slechts 50,0%.
De Coverage Gap (Dekkingskloof): Zelfs als de Judge perfect was geweest, waren er sommige taken (ongeveer 15 van de 50 in één test) die geen van de pakken kon oplossen. De robot had simpelweg nog niet de juiste tools of ideeën.

De Kern van het Verhaal

De auteurs suggereren dat Test-Time Harness Evolution een krachtige manier is om AI-agents slimmer te maken zonder hun brein aan te raken. Het verandert de eigen werklogs van de robot in een leraar.

Ze waarschuwen echter dat dit nog geen "opgelost probleem" is. De methode leunt zwaar op het vermogen van de "Judge" om het verschil te zien tussen een gelukkige gok en een echte oplossing. Als de Judge in de war raakt door een lastige test, leert de robot de verkeerde les. Maar voor nu laat het zien dat het geven van een pak aan een AI dat zichzelf kan repareren terwijl het werkt, een zeer veelbelovende richting is.

Technische Samenvatting: Test-Time Harness Evolution (TTHE)

Probleemstelling

Moderne Large Language Model (LLM) agenten worden steeds vaker geconstrueerd als uitvoerbare systemen waarbij het gedrag niet alleen wordt bepaald door het onderliggende bevroren model, maar ook door de omringende "harness" — het controleprogramma dat contextconstructie, tool-invocatie, tussenliggende verificatie en foutherstel beheert. Huidige implementatiepraktijken omvatten doorgaans het optimaliseren van deze harness op gelabelde ontwikkelings- of trainingsdata voordat deze wordt bevroren voor evaluatie. Deze statische aanpak beperkt de aanpasbaarheid wanneer testdistributies, faalmodi of tool-interacties verschillen van wat tijdens de ontwikkeling is gezien.

Bestaande adaptatiemechanismen, zoals fine-tuning of test-time training, wijzigen de gewichten van het model, terwijl self-debugging of reflectiemethoden vaak enkelvoudige responsen herzien of tekstuele ervaringen opslaan. Geautomatiseerd workflow-onderzoek vindt meestal plaats vóór de implementatie. Een cruciale openstaande vraag blijft: Kan een LLM-agent tijdens de evaluatie adapteren uitsluitend door zijn eigen ongelabelde executie-traces te gebruiken om zijn omringende uitvoerbare harness te wijzigen, zonder de modelgewichten bij te werken, zonder gouden labels te vereisen, en zonder een apart adaptatiemodel te trainen?

Methodologie: Test-Time Harness Evolution (TTHE)

TTHE pakt dit aan door de uitvoerbare harness te behandelen als de staat van test-time adaptatie. In plaats van te zoeken naar een vaste workflow op gelabelde data, verplaatst TTHE de harness-optimalisatie naar het evaluatieproces zelf, opererend op ongelabelde testbatches.

Kernmechanisme

TTHE houdt een populatie van kandidaat-harnesses bij en verfijnt deze via een agentic loop bestaande uit drie rollen, geïnstantieerd rond dezelfde bevroren LLM:

Solver: De agent die de taak uitvoert binnen de huidige harness.
Proposers: Agentic coding-agents die redeneren over executie-traces om de harness-code te herschrijven.
Judge: Een agentic selector die een verbeterde harness vastlegt op basis van uit executie afgeleide signalen.

De Evolutie-loop

Voor elke ongelabelde batch inputs $X_t$ :

Observatie: De huidige vastgelegde harness $H_t$ wordt uitgevoerd op $X_t$ , waarbij gedetailleerde executie-traces (prompts, tool calls, stdout/stderr, errors, runtime states) en lichtgewicht proxy-signalen worden gegenereerd.
Populatie-evolutie: TTHE evolueert $G$ parallelle takken over $R$ rondes. In elke ronde bewerken $G$ proposers hun respectievelijke ouder-harnesses tot kind-harnesses. Proposers lezen traces van andere takken voor context, maar bewerken hun eigen lineage. Dit waarborgt zowel lineage (persistentie van nuttige strategieën) als diversiteit (exploratie van verschillende bewerkingsrichtingen, bijv. conservatieve reparatie, exploratie, adversarieel).
Selectie: Een judge inspecteert de uiteindelijke set kandidaat-harnesses, hun traces en proxy-signalen om een enkele harness $H_{t+1}$ vast te leggen voor de volgende batch.
Meting: Gouden labels worden pas geraadpleegd na de selectie om de nauwkeurigheid te meten; ze komen nooit in de adaptatie-loop terecht.

Optimalisatie-signalen

Omdat gouden labels niet beschikbaar zijn tijdens de adaptatie, vertrouwt TTHE op executie-afgeleide proxy-signalen, die imperfect bewijs zijn in plaats van correctheid-oracles:

Executie-gezondheid: Of de output zonder fouten draait en een goed gevormd resultaat teruggeeft.
Round-Trip Consistentie: Of de output kan worden omgezet in een beschrijving die overeenkomt met de input (detectie van semantische drift).
Public-Test Pass Rate: Het deel van de publieke voorbeelden of repository-tests dat slaagt (onvolledig bewijs, aangezien verborgen tests nog steeds kunnen falen).

Het systeem vermijdt het samenvoegen van deze signalen tot een enkele scalaire beloning, maar stelt in plaats daarvan ruwe traces en signalen bloot aan de agentic proposer en judge om gaming en systematische herhaling van fouten te voorkomen.

Belangrijkste Bijdragen

Formulering van Test-Time Harness Evolution: Het artikel definieert een nieuw adaptatieparadigma waarbij de persistente uitvoerbare harness wordt aangepast tijdens de evaluatie vanuit ongelabelde traces, waarbij de modelgewichten vaststaan en gouden labels geïsoleerd zijn tot post-selectie meting.
Populatie-gebaseerde Generate-and-Judge Loop: De auteurs realiseren dit als een systeem waarbij de solver, proposers en judge verschillende rollen zijn rond dezelfde bevroren LLM, wat adaptatie mogelijk maakt uitsluitend door veranderingen in het omringende programma.
Empirische Validatie: De methode wordt gedemonstreerd over vijf uitvoering-gegronde domeinen (Text-to-SQL, competitief programmeren, software engineering, data-science coding en agentic tool-gebruik), waarbij inspecteerbare policies worden geproduceerd voor grounding, verificatie en reparatie.
Diagnostische Analyse: Het artikel biedt ablatie-studies over de zoekbudget, batchgrootte en model-backbones, en voert trace-audits uit om faalmodi te karakteriseren, waarbij specifiek "selection regret" (goede kandidaten die niet worden vastgelegd) en beperkte kandidaat-dekking worden geïdentificeerd.

Resultaten

TTHE werd geëvalueerd op uitdagende segmenten van vijf benchmarks: BIRD (Text-to-SQL), LiveCodeBench, SWE-bench Verified, DS-1000 en claw-eval (agentic tool-use).

Prestatiewinst: Gebruikmakend van een DeepSeek-v4-flash backbone, verbeterde TTHE de baseline ReAct harness aanzienlijk:
- BIRD: 12.0% $\to$ 50.0%
- LiveCodeBench: 30.0% $\to$ 38.3%
- SWE-bench Verified: 20.0% $\to$ 35.0%
- DS-1000: 38.0% $\to$ 44.0%
- claw-eval: 48.9% $\to$ 69.8% (gemiddelde genoteerde score)
Model-onafhankelijkheid: De winsten waren consistent over verschillende backbones (MiMo V2.5, Kimi K2.5), wat aangeeft dat de loop niet gebonden is aan een specifiek model.
Emergent Policies: De geëvolueerde harnesses introduceerden inspecteerbare gedragingen die niet aanwezig waren in de baseline, zoals strikte reproduce-first workflows, execute-and-self-debug loops voor SQL, en conditionele verificatie-en-reparatie policies voor coding.
Ablatie Inzichten:
- Zoekbudget: Prestaties zijn niet-monotoon met het zoekbudget; parallelle lineages ( $G=3$ ) presteren beter dan enkelvoudige lineages ( $G=1$ ) omdat ze het verlies van goede vroege kandidaten voorkomen.
- Batchgrootte: Prestaties pieken bij een gemiddelde batchgrootte ( $B=10$ ), wat een balans vindt tussen bewijs per beslissing en het aantal adaptatiestappen.
- Accumulatie: Het meenemen van de vastgelegde harness over batches levert een hogere nauwkeurigheid op dan het resetten naar de baseline voor elke batch.

Betekenis en Beperkingen

Het artikel stelt dat TTHE de test-time adaptatie voor LLM-agenten herdefinieert als evolutie over uitvoerbare controleprogramma's. Het demonstreert dat persistente, inspecteerbare verbeteringen kunnen worden bereikt zonder gewicht-updates of gouden labels.

De auteurs identificeren echter centrale technische knelpunten:

Betrouwbaarheid van Proxy-signalen: De kwaliteit van de executie-afgeleide signalen is cruciaal. Het systeem moet optimaliseren onder incomplete bewijslast waarbij een query succesvol kan worden uitgevoerd maar het verkeerde antwoord geeft.
Betrouwbaarheid van de Judge: Een aanzienlijk deel van de potentiële winst gaat verloren aan "selection regret", waarbij de agentic judge een plausibel maar incorrect programma vastlegt of er niet in slaagt een betere kandidaat uit de pool te selecteren. De judge is meetbaar misgekalibreerd en geeft vaak de voorkeur aan benchmark-incompatibele outputvormen.
Dekkinglimieten: Zelfs met een oracle over alle gegenereerde kandidaten blijven sommige taken onopgelost, wat duidt op intrinsieke limieten in de huidige zoekruimte-dekking.

De auteurs concluderen dat hoewel TTHE een praktisch mechanisme biedt voor het adapteren van agenten zonder modelgewichten te wijzigen, de robuustheid van een dergelijke evolutie sterk afhangt van de betrouwbaarheid van de proxy-signalen en het selectiemechanisme. Toekomstig werk is nodig om forward generalisatie via prequential scoring te vestigen en om het selectieknelpunt aan te pakken.