Technische Samenvatting: Schalen van Harness-intelligentie via Just-in-Time Harness Evolutie

1. Probleemstelling

De capaciteit van een LLM-agent wordt niet uitsluitend bepaald door de gewichten van het basismodel, maar wordt gezamenlijk gedefinieerd door de agent harness — het operationele steigerwerk bestaande uit geheugenbeheer, planningsstrategieën, actieprotocollen en tool/skill-orkestratie. Hoewel een sterk model kan falen onder een ongepast harness, kan een robuust harness alleen potentieel ontsluiten als het model in staat is dit te interpreteren en te volgen.

Huidige benaderingen voor harness-optimalisatie vertrouwen voornamelijk op Ahead-of-Time (AOT) methoden. Deze systemen behandelen het harness als een duurzaam artefact dat geoptimaliseerd wordt over een ervaringstroom om te generaliseren naar toekomstige taken. Echter, AOT-benaderingen worstelen met instantie-afhankelijkheid: verschillende taken (bijv. breed zoeken versus terminale taken versus diep onderzoek) vereisen fundamenteel verschillende harness-priors. Het optimaliseren van een enkel AOT-harness over heterogene eisen is omslachtig, vereist grote ontwerpplekken en trajectaccumulatie, en faalt vaak in het matchen van de specifieke structuur van een nieuw probleem. Het artikel stelt dat harness-ontwerp moet verschuiven van een handmatige, statische engineeringtaak naar een Just-in-Time (JIT) capaciteit, waarbij een getrainde meta-agent on-the-fly een taakspecifiek harness synthetiseert.

2. Methodologie: JIT-Agent

De auteurs stellen JIT-Agent voor, een compacte meta-agent die is ontworpen om taakadaptieve harnesses te synthetiseren, te repareren en te evolueren voor willekeurige off-the-shelf agentic LLM's.

2.1 Formalisering: Het Vier-Module Protocol

Om harness-generatie haalbaar en gestructureerd te maken, formaliseert het artikel de agent harness als een composabel, machine-genereerbaar artefact dat wordt beheerst door een vast vier-module protocol $\Pi = (M, P, A, F)$:

1. Geheugen ($M$): Comprimeert de historie naar een weergave ($v_t$) van de gerealiseerde historie.
2. Planning ($P$): Converteert de weergave naar een lokale instructie ($d_t$).
3. Capaciteits-orkestratie ($F$): Selecteert en sequentieert relevante tools/skills ($C_t$) op basis van de instructie.
4. Actie ($A$): Consumeert de samengestelde context om de controller-toestand bij te werken en de volgende actie uit te zenden ($e_t$).

Deze factorisatie transformeert heterogene programma's naar vergelijkbare coördinaten binnen een protocol-conforme ruimte ($H_\Pi$). De auteurs introduceren HarnessFactory, een uniforme codebase die 13 representatieve hedendaagse scaffolds implementeert (bijv. ReAct, Plan-and-Execute, Recursive agents) onder deze gemeenschappelijke interface om te dienen als een zaadbank ($B_0$).

2.2 Trainingspipeline

JIT-Agent wordt getraind via een driefasige pipeline om Harness Intelligentie (adaptiviteit, betrouwbaarheid en evolueerbaarheid) te bereiken:

• Fase I: Taak-geconditioneerde Customisatie

  • Doel: Het model leren om een taakspecificatie en een kleine referentiecontext te mappen naar een protocol-conform harness.
  • Methode: Een bevroren, sterker teacher-model synthetiseert taak-adaptieve harnesses. De trainingsdata bevat zowel supervised fine-tuning (SFT) op valide generaties als preference learning. De preference-objective ($L_{pref}$) optimaliseert voor harnesses die de taakbeloning verbeteren zonder de efficiëntie (latentie of kosten) te verslechteren, gebruikmakend van een Pareto-stijl preference regel.

• Fase II: Repareren van Harnesses

  • Doel: Betrouwbaarheid waarborgen door te leren herstellen van synthese-fouten.
  • Methode: Gefaalde generaties (compilerfouten, interface-mismatches, runtime-exceptions) worden omgezet in begrensde repair-trajecten. Een teacher stelt gestructureerde revisies ($\Delta$) voor om de harness te repareren. Het model wordt getraind om deze repair-transities te imiteren, waarbij het leert om execution feedback te gebruiken om protocol-valide executie te herstellen binnen een kort horizon (maximaal 2 rondes).

• Fase III: Evolutionary Group-Decoupled Policy Optimization (Evo-GDPO)

  • Doel: Online evolutie mogelijk maken waarbij het model leert harnesses voor te stellen die de huidige architectuur-frontier overtreffen.
  • Methode: Tijdens de training stelt het model een groep kandidaat-harnesses voor. Deze worden geëvalueerd tegenover een incumbent (het beste harness in de huidige bank voor die taak). Het beloningssignaal wordt ontkoppeld in drie kanalen:
    1. Beloning (Reward): Primair signaal; kandidaten moeten de incumbent's beloning evenaren of overtreffen.
    2. Latentie & Kosten: Efficiëntiesignalen die geactiveerd worden als de beloning behouden blijft.
  • De policy wordt bijgewerkt met een PPO-stijl objective gedreven door een genormaliseerde, geaggregeerde advantage die beloont voor het overtreffen van de frontier terwijl de efficiëntie behouden blijft. De harness bank ($B_n$) wordt conservatief bijgewerkt, waarbij alleen ontwerpen worden behouden die de frontier voortstuwen.

2.3 Inferentie Architectuur

JIT-Agent ondersteunt twee inferentie-modi:

• Statische Inferentie: Genereert $N$ harnesses parallel, selecteert er één, en voert deze uit. Nuttig voor het maximaliseren van kandidaat-diversiteit zonder het aantal environment rollouts te verhogen.
• Streaming Inferentie: Ontworpen voor taakstromen. Het model haalt referenties op uit een evoluerende bank, genereert een harness, voert deze uit, en werkt de bank bij op basis van feedback. Dit maakt het mogelijk dat ervaring over taken heen wordt getransfereerd zonder modelparameters tijdens deployment bij te werken.

3. Belangrijkste Resultaten

Het artikel evalueert JIT-Agent over negen benchmarks die diep onderzoek, dagelijks werk, planning en workspace-taken dekken, gebruikmakend van backbones waaronder GLM-5.2, DeepSeek-V4-Flash, Qwen3.6 en Mimo-V2.5.

• Prestatiewinst: Het vervangen van standaard scaffolds door JIT-gegenereerde harnesses levert consistente verbeteringen op.

  • GLM-5.2: Gemiddelde verbetering van +7,7 punten over negen benchmarks. Opvallende winsten zijn +20,2 op DeepPlanning-Travel en +4,3 op OdysseyBench.
  • DeepSeek-V4-Flash: Gemiddelde verbetering van +8,8 punten. Het overtreft GPT-5.6 op DeepSearchQA (+9,1).
  • Generalisatie: JIT-Agent verbetert de prestaties over alle geteste modelfamilies (DeepSeek, Qwen, Mimo) en varianten (Flash/Pro), wat aangeeft dat de capaciteit overdraagbaar is naar andere modelgewichten.

• Concurrentie met Vaste Harnesses:

  • JIT-gegenereerde harnesses zijn qua prestaties competitief met volwassen runtimes zoals OpenCode en Claude Code.
  • Op DeepSeek-V4-Flash overtreft JIT-Agent het sterkste vaste harness (NanoBot) met +4,7 punten op DeepSearchQA en +4,0 punten op xBench-DS.

• Kostenefficiëntie:

  • JIT-Agent behaalt het laagste tokenverbruik en de laagste API-kosten in alle gecontroleerde settings.
  • Vergeleken met het goedkoopste vaste harness, vermindert het de kosten per geval met 14,9–54,1% (gemiddeld 36,0%) terwijl de prestaties verbeteren. Bijvoorbeeld, op DeepSeek-V4-Flash xBench-DS daalde het tokengebruik van 527K naar 212K terwijl de prestaties stegen van 78,0 naar 82,0.
  • Pareto-frontier analyse laat zien dat JIT-Agent de werkpunten verschuift naar de boven-linkerzijde (hogere prestaties, lagere kosten), wat bewijst dat de winsten niet komen door langere trajecten maar door betere orkestratie.

• Test-Time Evolutie:

  • Streaming JIT (die de harness bank bijwerkt over een taakstroom) presteert consequent beter dan Static JIT (onafhankelijke generaties) in cumulatieve nauwkeurigheid, wat de waarde aantoont van leren uit execution feedback.

4. Betekenis en Claims

Het artikel claimt te hebben vastgesteld dat Harness Intelligentie een nieuwe, trainbare en overdraagbare dimensie van agent-capaciteit is die orthogonaal staat aan model scaling.

• Paradigmaverschuiving: Het werk verplaatst harness engineering van "Ahead-of-Time" (het optimaliseren van een statisch artefact) naar "Just-in-Time" (het synthetiseren van een taakspecifiek steigerwerk on-the-fly).
• Model-als-Harness: Het demonstreert dat een getrainde meta-agent operationele scaffolds kan genereren die zwakkere of efficiëntere backbones in staat stellen om sterkere modellen met vaste harnesses te evenaren of te overtreffen.
• Schaalbaarheid: Door het harness te formaliseren als een composabel protocol en een generator te trainen om het te evolueren, suggereert het artikel een pad naar het schalen van agent-capaciteit door de optimalisatie van de executie-omgeving zelf, in plaats van enkel door modelparameter scaling.
• Toekomstige Richting: De auteurs beschouwen dit als een stap naar Model-Harness Co-Design, waarbij foundation models uiteindelijk de capaciteit kunnen internaliseren om hun eigen executiesystemen te construeren, te herzien en te evolueren.

Het artikel concludeert dat harness intelligentie niet louter een implementatiedetail is, maar een eerste-orde determinant van agent-prestaties, in staat om substantiële capaciteit te herstellen die anders dure backbone scaling zou vereisen.