Technische Samenvatting: Harness-R1

Probleemstelling

Large Language Model (LLM) agenten die worden ingezet in dynamische omgevingen, accumuleren interactietrajecten die zowel succesvolle ervaringen als systematische fouten bevatten (bijv. verkeerd gebruik van tools, verlies van status, protocolovertredingen). Terwijl huidige benaderingen voor het verbeteren van agenten zich primair richten op het bijwerken van de modelgewichten via fine-tuning of reinforcement learning, blijft de "agent harness"—de uitvoerbare runtime-code die context construeert, tools bemiddelt, acties valideert en herstel beheert—doorgaans statisch.

Het aanpassen van deze harness is cruciaal omdat identieke modelgewichten zeer verschillende capaciteiten kunnen opleveren onder verschillende harness-configuraties. Directe modificatie van de harness is echter onbetrouwbaar. Vaste regels (bijv. Self-Refine) verslechteren vaak de prestaties, en het prompten van grote frontier-modellen om de harness te bewerken resulteert in instabiele winsten omdat deze modellen optimaliseren voor tekstuele plausibiliteit in plaats van geverifieerd taaksucces. De kernuitdaging is het ontwikkelen van een methode die leert een bestaande uitvoerbare runtime te bewerken op basis van geobserveerde agentfouten, waarbij de bewerkingen worden gevalideerd door werkelijke prestatieverbeteringen in plaats van theoretische redenering.

Methodologie: Harness-R1

Harness-R1 introduceert een trainingsparadigma dat het bewerken van de harness behandelt als een online reinforcement learning (RL) probleem voor een speciaal daarvoor bestemde "harness engineer"-model, terwijl de doel-agent bevroren blijft. Het systeem werkt via een failure-to-edit-to-rerun loop:

1. Probleemformulering

• Bevroren Doel (Frozen Target): De doel-agent $A$ (model + basis runtime) blijft vast.
• Failure Packets: Een batch taken $B$ wordt uitgevoerd, en een deterministische extractor compileert mislukte episodes tot "failure packets" ($s_B$) die taakbeperkingen, actie-observatie fragmenten en uitkomsten bevatten.
• De Engineer ($H_\theta$): Een toegewijd 9B-model fungeert als de editor. Het leest een failure packet en genereert een uitvoerbare overlay (patch) $P$.
• Executable Hooks: De patch $P$ omhult de levenscyclus van de agent op vier specifieke punten zonder de modelgewichten te wijzigen:
  1. Episode Initialisatie: Richt context en status in.
  2. Pre-Decision: Verrijkt de context met begeleiding/beperkingen.
  3. Pre-Action: Valideert, herschrijft of blokkeert voorgestelde acties.
  4. Post-Feedback: Inspecteert observaties en triggert herstel.
• Beloningssignaal (Reward Signal): De gepatchte doel-agent voert de dezelfde batch taken opnieuw uit. De beloning is het verschil in prestaties ($\Delta_B$) tussen de gepatchte en ongepatchte runs. Dit creëert een transductief, same-batch objectief waarbij de beloning niet-differentieerbaar is en pas na uitvoering observeerbaar wordt.

2. Trainingspipeline

Harness-R1 maakt gebruik van een tweefasig trainingsproces:

• Cold-Start Supervised Fine-Tuning (SFT): Een sterk teacher-model stelt bewerkingsresponsen voor op basis van failure packets. Deze worden gevalideerd tegen de bevroren doel-agent; alleen uitvoerbare, niet-regressieve patches worden behouden om een dataset te vormen voor het initialiseren van het policy van de engineer.
• Outcome-Grounded Group Relative Policy Optimization (GRPO):
  • De engineer samplet $K$ kandidaat-patches voor een failure packet.
  • Elke kandidaat wordt gevalideerd en geïnstalleerd; de bevroren doel-agent voert de taakbatch opnieuw uit.
  • Beloningen worden genormaliseerd binnen de groep van $K$ kandidaten om voordelen (advantages) te berekenen.
  • De parameters van de engineer worden bijgewerkt om de token-gemiddelde clipped surrogate objective te maximaliseren, waarbij wordt geoptimaliseerd voor de gerealiseerde nuttigheid van de patches.

Belangrijkste Bijdragen

1. Formulering: Het artikel formuleert fout-geconditioneerde, lifecycle-brede harness-bewerking als een online RL-probleem voor een specifieke engineer, onderscheidend van modelgewicht-updates.
2. Harness-R1 Framework: Het stelt een systeem voor dat cold-start SFT combineert met outcome-grounded GRPO. In tegen tegenstelling tot eerder werk dat editors gebruikt voor programmazoektochten of kandidaat-selectie, werkt Harness-R1 de policy van de editor direct bij op basis van de executie-uitkomsten van zijn patches op een bevroren doel.
3. Co-evolutie: De methode demonstreert dat een harness engineer en een doel-agent kunnen co-evolueren. Een engineer getraind op een vanilla target verbetert deze, en een opnieuw getrainde engineer kan een doel verbeteren dat al directe fine-tuning heeft ondergaan.

Experimentele Resultaten

De methode werd geëvalueerd op drie interactieve benchmarks: WebShop (webnavigatie), ALFWorld (belichaamde tekstgebaseerde taken) en DBBench (database query's).

• Prestatiewinst (Vanilla Target): Voor een bevroren Qwen3.5-9B agent verhoogde Harness-R1 het gemiddelde succespercentage van 44,3% naar 53,6% (+9,3 procentpunt). Dit presteerde beter dan prompt-gebaseerde strategieën (bijv. Self-Refine, die de prestaties verlaagden) en frontier-modellen geprompt als editors (bijv. GLM-5.2 met 48,8%).
• Prestatiewinst (Fine-Tuned Target): Na directe fine-tuning van de doel-agent (waardoor de baseline steeg naar 59,2%), verhoogde een doel-specifieke Harness-R1 engineer het succes verder naar 64,2% (+5,0 punten), wat aantoont dat harness-optimalisatie effectief blijft zelfs nadat de modelgewichten zijn bijgewerkt.
• Generalisatie:
  • Cross-Model: De geleerde bewerkingspolicy werd overgedragen naar 20 ongeziene doel-modellen (variërend van 1B tot 70B parameters binnen de Llama, Gemma en Qwen families), wat positieve winsten opleverde op elk doel zonder per-doel her-tuning.
  • Cross-Taak: Met schaarse foutbewijslast (10 fouten) genereerde de engineer patches die helder-gehouden taken verbeterden met +8,9 punten, wat aanzienlijk beter is dan grote frontier-modellen die negatieve of instabiele resultaten vertoonden op helder-gehouden data.
• Ablatie: Het verwijderen van specifieke lifecycle hooks (bijv. pre-action mediatie of post-feedback herstel) verminderde de prestaties, wat bevestigt dat de winsten verdeeld zijn over de levenscyclus van de agent en afhankelijk zijn van de specifieke omgeving.

Betekenis en Claims

Het artikel stelt dat harness-constructie een leerbare capaciteit is die traditionele gewicht-updates complementeert. De primaire betekenis ligt in het verschuiven van het optimalisatietarget van de interne besluitvorming van de agent (gewichten) naar de externe runtime-mechanismen (harness).

• Betrouwbaarheid boven Plausibiliteit: De auteurs argumenteren dat het prompten van grote modellen om code te bewerken onbetrouwbaar is omdat het optimaliseert voor "er correct uitzien". Harness-R1 leert van gerealiseerde uitkomsten, wat zorgt voor edits die daadwerkelijk nuttig zijn.
• Adaptiviteit: In tegenstelling tot vaste strategieën (bijv. Self-Refine) die uniforme regels toepassen, genereert Harness-R1 bewerkingen geconditioneerd op specifieke foutmodi, waardoor het zich aanpast aan de unieke zwakheden van de doel-agent.
• Co-evolutie: De resultaten suggereren een pad naar agenten die continu verbeteren na implementatie, niet alleen door het model te hertrainen, maar door de runtime-omgeving te evolueren die eromheen staat. Het artikel concludeert dat deze aanpak een robuust pad biedt voor verbetering van de agent na implementatie door de engineer en de doel-agent te laten co-evolueren.