A Rubric-Supervised Critic from Sparse Real-World Outcomes

Dit artikel introduceert een rubric-gestuurd critic-model dat, getraind op schaarse real-world feedback en waarneembare interactiepatronen, de prestaties van coderingsagenten aanzienlijk verbetert door betere herordening, vroegtijdige stopzetting en effectievere data-curatie mogelijk te maken.

De kern

Stel je voor dat je een zeer slimme, maar soms wat onhandige assistent hebt die voor je werkt in de digitale wereld. Hij schrijft code, lost problemen op en bouwt software. In de "schoolboeken" (de academische benchmarks) wordt deze assistent getoetst op één ding: werkt de oplossing? Als de computer zegt "ja, de test slaagt", krijgt hij een A.

Maar in het echte leven is het verhaal heel anders. Daar werkt de assistent niet alleen; hij werkt samen met een mens. En daar is "werken" niet hetzelfde als "een test laten slagen".

Dit paper beschrijft hoe we een nieuwe soort "criticus" (een beoordelaar) hebben gebouwd die beter begrijpt wat er in de echte wereld gebeurt, zelfs als we maar heel weinig feedback krijgen.

Hier is de uitleg in simpele taal, met een paar creatieve vergelijkingen:

1. Het Probleem: De "Stille" Werkplek

In de echte wereld geven mensen zelden expliciet aan: "Goed gedaan!" of "Fout!".

• De "Stille" Klant: Soms zegt de klant niets, maar verandert hij de code van de assistent later wel. Soms merge hij een pull request (een soort werkstuk), maar dat betekent niet dat alles perfect was.
• De "Vertraagde" Feedback: Als een klant wel feedback geeft, is dat vaak pas aan het einde van een lange sessie. Het is alsof je pas na het eten hoort of de kok de zout heeft vergeten.
• Het Resultaat: We hebben duizenden gesprekken met de assistent, maar voor slechts een heel klein beetje daarvan weten we of het uiteindelijk "geslaagd" was. De rest is een zwart gat aan data.

2. De Oplossing: De "Criticus" met een Checklist

De auteurs zeggen: "Laten we niet wachten tot de klant zegt 'goed' of 'slecht'. Laten we kijken naar hoe de assistent werkt."

Ze hebben een Criticus getraind die niet kijkt naar het eindresultaat, maar naar 24 specifieke gedragingen (noem ze "Critic Rubrics").

De Analogie: De Vloerbaas
Stel je een bouwplaats voor.

• De oude manier (benchmarks) kijkt alleen of het dak erop ligt. Als het dak er ligt, is het goed.
• De nieuwe Criticus is een ervaren vloerbaas die de hele dag meekijkt. Hij heeft een checklist met 24 punten:
  • Heeft de metselaar de instructies van de architect begrepen?
  • Heeft hij de bakstenen goed gemengd?
  • Heeft hij de ladder veilig geplaatst?
  • Is de klant duidelijk gefrustreerd geraakt?

Zelfs als we niet weten of het dak er uiteindelijk perfect op ligt (want de klant zegt het niet), kunnen de vloerbaas en zijn checklist wel zeggen: "Hé, deze metselaar heeft de bakstenen verkeerd gemengd en de klant was gefrustreerd. Dit ziet er niet goed uit."

3. Hoe werkt het? (De "Semi-Geleerde" Methode)

Het slimme aan dit systeem is dat het twee dingen tegelijk leert:

1. De Dikke Checklist (Rubrics): De Criticus leert om die 24 gedragingen te zien in elke interactie. Omdat we de gesprekken zelf kunnen lezen, hebben we hierover veel data.
2. De Dunne Feedback (Resultaten): De Criticus leert ook om te kijken naar de zeldzame momenten waarop we wel weten of het werk goed was (bijvoorbeeld: "Deze code is overgenomen in het systeem").

De Magie: Omdat de Criticus de "Checklist" zo goed heeft geleerd, kan hij ook de "Dunne Feedback" veel beter interpreteren. Hij gebruikt de gedragingen als een brug om te begrijpen waarom iets wel of niet werkt, zelfs als er weinig eindresultaten zijn om op te leren.

4. Waarom is dit zo geweldig? (De Toepassing)

Deze Criticus is niet alleen een theorie; hij doet drie dingen die ons tijd en geld besparen:

• De "Beste van 8" (Best-of-K):
  Stel, de assistent bedenkt 8 verschillende manieren om een probleem op te lossen. De Criticus kijkt naar die 8 opties en zegt: "Deze 7 zien er rommelig uit (veel fouten op de checklist), maar deze ene ziet er strak uit." Zo kiezen we direct de beste, zonder dat we ze allemaal hoeven uit te proberen.

  • Resultaat: 15,9% meer succes op de moeilijke taken.

• Vroegtijdig Stoppen (Early Stopping):
  Als de assistent begint met een oplossing die de Criticus al "slecht" vindt (bijvoorbeeld: "Hij begrijpt de opdracht niet"), stopt de Criticus het proces direct.

  • Resultaat: We verspillen 83% minder rekenkracht (en dus minder geld en energie) omdat we stoppen met slechte pogingen voordat ze klaar zijn.

• Beter Leren (Data Curation):
  Wanneer we de assistent opnieuw willen trainen, kiezen we niet zomaar willekeurige gesprekken uit. We laten de Criticus de "beste" gesprekken selecteren.

  • Resultaat: De assistent leert sneller en slimmer van de juiste voorbeelden.

Samenvatting

Vroeger keken we alleen naar of de assistent "winnend" was (testen geslaagd). Nu hebben we een slimme observator die kijkt naar het proces.

Het is alsof we van een school die alleen naar het cijfer op het eindtoets kijkt, zijn gegaan naar een school die ook naar de huiswerkstijl, de samenwerking en de houding kijkt. Zelfs als de eindtoets niet altijd beschikbaar is, weten we nu al of de leerling goed bezig is.

Dit maakt AI-agenten in de echte wereld betrouwbaarder, goedkoper en slimmer, omdat ze leren van de subtiele signalen van menselijke interactie, niet alleen van harde testresultaten.

Technische samenvatting

Probleemstelling

Huidige academische benchmarks voor coderingsagenten (zoals SWE-bench) vertrouwen op verifieerbare beloningen (bijv. het slagen van unit-tests) om succes te meten. Dit werkt goed voor autonome taken, maar spiegelt de realiteit van softwareontwikkeling niet nauwkeurig weer. In echte wereldscenario's werken agenten met mensen in de lus ("human-in-the-loop"). Hier zijn succesindicatoren:

• Schaars (Sparse): Gebruikers geven zelden expliciete feedback over de kwaliteit van elke interactie.
• Vertraagd (Delayed): Feedback komt vaak pas aan het einde van een sessie of via een pull request (PR), niet direct na een specifieke actie.
• Ruig (Noisy): Een gemergde PR betekent niet per se dat elke stap van de agent correct was; gebruikers kunnen handmatig correcties aanbrengen.

Dit creëert een "credit assignment" probleem: het is moeilijk om te bepalen welke specifieke acties van de agent hebben geleid tot succes of mislukking, wat het trainen van betrouwbare evaluatiemodellen (critics) bemoeilijkt.

Methodologie

De auteurs stellen een methode voor om een critic-model te leren dat werkt met deze schaarse en ruwe data, door gebruik te maken van een semi-supervised leerframework.

1. Data-Modellering: Segmenten

In plaats van hele conversaties als één eenheid te behandelen, worden interacties opgesplitst in segmenten. Een segment is een zelfstandige eenheid van werk: van een gebruikersverzoek tot de actie finish van de agent, voordat de volgende gebruikersinput arriveert.

• Hiërarchie: PR (Pull Request) $\rightarrow$ Commits $\rightarrow$ Segmenten.
• Outcome Proxies:
  • PR Merge: Een binaire indicator of de code is geaccepteerd (coarse, noisy).
  • Code Survival: Een fijner graad signaal dat meet welk percentage van de door de agent geschreven code behouden blijft in de uiteindelijke gemergde diff. Dit is een betere proxy voor segment-succes.

2. Critic Rubrics (De Kerninnovatie)

Om het probleem van schaarse labels op te lossen, introduceren de auteurs Critic Rubrics: een taxonomie van 24 gedragskenmerken die direct uit de interactietrace afgeleid kunnen worden, zonder dat de uiteindelijke uitkomst bekend hoeft te zijn.

• Categorieën:
  • Agent-gedragsproblemen: Bijv. intentie verkeerd begrijpen, instructies negeren, onvoldoende testen/debuggen, scope creep.
  • Gebruiker-volgsignalen: Bijv. correcties, frustratie, verzoeken om terugdraaien (reversion).
  • Infrastructuurproblemen: Externe fouten vs. fouten veroorzaakt door de agent.
• Annotatie: Deze rubrics worden geschaald geannoteerd met een krachtig LLM (o3) op alle segmenten, waardoor dichte supervisie ontstaat voor 100% van de data, in tegenstelling tot de 4-6% met outcome-labels.

3. Trainingsframework

Ze trainen een critic-model (gebaseerd op Qwen3-4B) met een semi-supervised, multi-task doel:

1. Dichte supervisie: Voorspel de 24 rubric-kenmerken voor elk segment (beschikbaar voor alle data).
2. Schaarse supervisie: Voorspel het succes (bijv. code survival) voor de kleine subset met outcome-labels.
   Dit zorgt ervoor dat het model leert omgedrag te herkennen dat correleert met succes, zelfs op data zonder eindresultaat.

Belangrijkste Resultaten

• Transfervermogen: Critic-modellen die uitsluitend op academische benchmarks zijn getraind, presteren slecht (nabij willekeurig) op real-world data. Real-world supervisie is essentieel voor generalisatie.
• Fijne-granulariteit: Training op Code Survival presteert beter dan op PR Merge, omdat het een meer gedetailleerd en toerekenbaar signaal biedt.
• Inference-time Scaling:
  • Best-of-K Reranking: Het gebruik van de critic voor het selecteren van de beste trajecten uit 8 opties leidt tot een +15,9% verbetering op SWE-bench vergeleken met willekeurige selectie.
  • Early Stopping: Het model kan mislukte trajecten vroegtijdig stoppen, wat leidt tot een 83% reductie in rekenkosten (gemiddeld 1,35 pogingen in plaats van 8) met een prestatieverbetering van +17,7%.
• Robuustheid: Modellen getraind met rubrics generaliseren beter over verschillende LLM-backbones (bijv. Claude Sonnet vs. Opus) dan modellen die alleen op succeslabels zijn getraind, wat wijst op het leren van fundamentele gedragspatronen in plaats van artefacten van een specifiek model.
• Data Curation: Het selecteren van trainingsdata op basis van critic-scores voor Supervised Fine-Tuning (SFT) verbetert de prestaties van de agent, terwijl willekeurige selectie geen verbetering oplevert.

Bijdragen en Significance

1. Overbrugging van de Kloof: Het paper biedt een praktische oplossing om agenten te trainen en evalueren in real-world settings, waar verifieerbare tests ontbreken.
2. Rubric-Supervisie: De introductie van gedragsrubrics als dichte supervisie transformeert ongelabelde productie-data in waardevolle leerdata. Dit maakt semi-supervised learning mogelijk voor evaluatiemodellen.
3. Efficiëntie: De methode maakt computationeel efficiëntere agenten mogelijk door vroegtijdig stoppen en slimme data-selectie, wat cruciaal is voor schaalbaarheid.
4. Open Source: De auteurs publiceren het critic-model, de definitie van de rubrics en de code voor het verwerken van data, wat de gemeenschap in staat stelt om vergelijkbare evaluatoren te bouwen voor hun eigen agenten.

Conclusie:
Dit werk demonstreert dat het leren van evaluatoren ("critics") uit ruwe, real-world interactiedata mogelijk is door gebruik te maken van gedragsrubrics als tussenliggende supervisie. Dit leidt tot robuustere, efficiëntere en generaliserende agenten die beter presteren in de complexe, mens-gestuurde omgeving van echte softwareontwikkeling.