Process-Centric Analysis of Agentic Software Systems

Deze paper introduceert Graphectory, een grafgebaseerde methode voor het analyseren van het proces van agente softwaresystemen, die niet alleen inzicht geeft in hun redeneerstrategieën, maar ook door middel van realtime monitoring en interventies de oplossingskansen aanzienlijk verbetert.

De kern

Stel je voor dat je een zeer slimme, maar soms wat ongeduldige robot hebt die je helpt om complexe taken te doen, zoals het repareren van een kapotte computercode. In de wereld van software noemen we deze robots agenten.

Tot nu toe keken we alleen naar het resultaat: "Is de code gerepareerd? Ja? Dan is de robot goed. Nee? Dan is hij slecht."

Maar deze paper, geschreven door onderzoekers van de Universiteit van Illinois en IBM, zegt: "Wacht even, dat is niet genoeg." Het is alsof je een kok alleen beoordeelt op of het eten op je bord ligt, zonder te kijken of hij de keuken in brand heeft gestoken, of dat hij urenlang heeft gezocht naar een mes terwijl hij het al in zijn hand had.

Hier is wat ze hebben bedacht, vertaald naar een simpel verhaal:

1. Het Probleem: De "Zwarte Doos"

De onderzoekers merkten op dat we vaak niet weten hoe een robot tot een oplossing komt. Soms lukt het door pure geluk, soms door slimme strategie, en soms door een enorme hoeveelheid onnodige pogingen. De huidige manier van kijken (alleen naar het eindresultaat) verbergt deze details.

2. De Oplossing: "Graphectory" (De Landkaart van de Reis)

Om dit op te lossen, hebben ze een nieuw hulpmiddel bedacht dat ze Graphectory noemen.

• De Analogie: Stel je voor dat je een wandeling maakt door een groot, complex bos.
  • De oude manier was: "Ben je bij de top aangekomen? Ja? Top!"
  • De Graphectory-manier is: Het maken van een dynamische landkaart van je hele wandeling. Deze kaart toont niet alleen waar je bent, maar ook:
    • Heb je in cirkels gelopen? (Onnodig heen en weer lopen).
    • Heb je een verkeerd pad genomen en toen teruggekeerd? (Strategische fouten).
    • Heb je eerst naar de top gekeken, toen naar de rivier, en toen weer naar de top? (Verwarring).
    • Heb je de juiste route gevolgd?

Graphectory zet de stappen van de robot om in een visueel netwerk (een grafiek) dat laat zien hoe de robot denkt, zoekt en handelt.

3. De Taal van de Reis: "Langutory"

Graphectory kan best complex zijn. Daarom hebben ze ook Langutory bedacht.

• De Analogie: Als Graphectory de gedetailleerde landkaart is, dan is Langutory de samenvatting in mensentaal.
  • In plaats van "Stap 1: Kijk naar bestand A, Stap 2: Kijk naar bestand B...", zegt Langutory: "De robot was eerst aan het zoeken (Locatie), toen aan het repareren (Patching), en toen aan het testen (Validatie)."
  • Dit maakt het makkelijk om te zien of de robot een logisch plan volgt of dat hij in de war raakt.

4. Wat hebben ze ontdekt? (De "Vindingen")

Ze hebben 4.000 wandelingen (reparaties) van verschillende robots geanalyseerd. Hier zijn de belangrijkste lessen:

• Succes is niet alles: Soms repareren robots een probleem, maar doen ze het zo inefficiënt dat het 10 keer langer duurt dan nodig. Ze lopen in cirkels of proberen dezelfde fout 10 keer te maken voordat ze het eindelijk snappen.
• Moeilijkere taken = Meer chaos: Hoe moeilijker het probleem is, hoe meer de robots dwalen. Ze zoeken dieper, maar raken ook sneller in de war.
• Slimme robots zijn soms "over-slim": De allersterkste modellen (zoals de nieuwste AI's) maken soms meer fouten in hun proces dan de iets mindere modellen. Ze denken te diep na, zoeken overal naar, en raken daardoor verstrikt in hun eigen gedachten, terwijl een simpelere robot direct de oplossing ziet.
• De "Verkeerde Paden": Ze vonden specifieke patronen van fouten, zoals:
  • Zoom-out: De robot kijkt in een verkeerd bestand, realiseert zich dat het fout is, gaat terug, en kijkt dan weer in een ander verkeerd bestand.
  • Draaien in de rondte: De robot probeert een fout te repareren, faalt, probeert het exact hetzelfde nog eens, faalt weer, en blijft zo hangen.

5. De "Live-Coach": Online Monitoring

Het coolste deel van de paper is dat ze Graphectory niet alleen gebruiken om na de reis te kijken, maar tijdens de reis.

• De Analogie: Stel je voor dat je een live-coach hebt die naast de robot loopt.
  • Zodra de coach ziet dat de robot in cirkels loopt of een verkeerd pad op gaat, roept hij: "Stop! Je loopt in de rondte. Kijk eens naar die andere deur!"
  • De coach kan de robot zelfs een stap terug laten zetten (terugdraaien) en een nieuwe richting geven.
• Het Resultaat: Door deze live-coaching konden ze de robots beter laten preteren (meer problemen oplossen) en sneller laten werken (minder stappen nodig). Het kostte bijna geen tijd, maar het resultaat was enorm.

Conclusie

Deze paper zegt eigenlijk: "Kijk niet alleen naar of de robot het werk afmaakt. Kijk naar hoe hij het doet."

Door de reis van de robot te analyseren met Graphectory en Langutory, kunnen we:

1. Zien waar robots onnodig veel tijd verspillen.
2. Begrijpen waarom ze vastlopen.
3. Ze in real-time helpen om slimmer en sneller te werken.

Het is een stap van "Is het goed?" naar "Hoe kunnen we het beter maken?" en dat is essentieel voor de toekomst van slimme software.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Process-Centric Analysis of Agentic Software Systems" in het Nederlands.

Probleemstelling

Agente softwaresystemen, aangedreven door Large Language Models (LLMs), worden steeds vaker ingezet voor complexe taken zoals softwareontwikkeling. Traditionele evaluatie van deze systemen is echter uitkomstgericht (outcome-centric): de prestatie wordt uitsluitend beoordeeld op basis van het eindresultaat (bijv. is de bug gerepareerd of niet?).

Deze benadering heeft twee belangrijke tekortkomingen:

1. Het negeert de intermediaire stappen (trajecten) die leiden tot het resultaat. Succes kan het gevolg zijn van toeval in plaats van systematisch redeneren, terwijl mislukkingen vaak worden veroorzaakt door inefficiënte patronen die niet zichtbaar zijn in het eindresultaat.
2. Ruwe trajecten zijn lineaire sequenties van acties die de semantische relaties, zoals uitvoeringsflow en probleemoplossingsstrategieën, niet effectief vastleggen. Dit maakt het moeilijk om systematisch patronen van inefficiëntie of terugkerende fouten te analyseren op grote schaal.

Methodologie: Graphectory en Langutory

De auteurs introduceren een nieuwe structuur voor het analyseren van agenten, genaamd Graphectory, en een bijbehorende abstractie, Langutory.

1. Graphectory (Grafische Representatie)
Graphectory is een cyclische gerichte graaf $G = (V, TE \cup SE)$ die de temporale en semantische relaties in een agent-traject encodeert:

• Knopen ($V$): Vertegenwoordigen individuele acties van de agent (gebaseerd op het ReAct-principe). Elke knop bevat metadata zoals het actie-type, de logische fase (bijv. lokalisatie, patchen, validatie), het navigatieniveau en de uitkomst.
• Temporele Randen ($TE$): Koppelen acties in de chronologische volgorde van uitvoering.
• Structurele Randen ($SE$): Koppelen acties die opereren op "subsumerende" entiteiten binnen de probleemruimte (bijv. van een map naar een bestand, of van een bestand naar een codeblok). Dit vangt navigatie en context op.
• Fase-labeling: Acties worden automatisch gelabeld met logische fasen: Localization (bug vinden), Patching (code aanpassen), Validation (testen) en General.

2. Langutory (Abstractie)
Om grafen vergelijkbaar te maken, introduceren de auteurs Langutory: een menselijk leesbare abstractie van Graphectory.

• Het comprimeert opeenvolgende identieke fasen in een string (bijv. $L_5P_5LPV$ betekent 5 stappen lokalisatie, 5 stappen patchen, 1 stap lokalisatie, etc.).
• Dit maakt het mogelijk om strategieën snel te vergelijken en afwijkingen van het verwachte plan (bijv. het overslaan van validatie) te detecteren.

3. Metriek en Analyse
Op basis van deze structuren worden nieuwe procesgerichte metriek ontwikkeld, zoals:

• Node Count & Temporal Edge Count: Maat voor de totale inspanning en lengte van het traject.
• Loop Count: Het aantal keren dat een agent een eerder uitgevoerde actie herhaalt (wijst op vastlopen).
• Structural Breadth: Hoe breed de agent navigeert in de projectstructuur.
• Pattern Detection: Systematische zoektocht naar "anti-patronen" (bijv. RepeatedView, ZoomOut, EditReversion) die inefficiëntie aangeven.

4. Online Monitoring en Interventie
Het systeem kan Graphectory en Langutory in real-time construeren tijdens de uitvoering van de agent. Bij detectie van inefficiëntie (bijv. een lange lus of een plan-overtreding) wordt de agent een diagnostisch bericht gestuurd. In ernstige gevallen (zoals een plan-overtreding) kan de laatste actie worden teruggedraaid (rollback) om de agent een nieuwe strategie te laten kiezen.

Experimenten en Dataset

• Setup: Analyse van 4000 trajecten van twee dominante agenten (SWE-agent en OpenHands) die 500 GitHub-issues oplossen (SWE-Bench Verified).
• Modellen: Vier verschillende LLMs als ruggengraat: DeepSeek-V3, DeepSeek-R1, Devstral-small, en Claude Sonnet 4.
• Analyse: De auteurs voerden zowel offline analyse uit (na voltooiing) als online monitoring met interventie.

Belangrijkste Resultaten

1. Correlatie tussen Proces en Succes

• Mislukte runs vertonen consistent complexere Graphectories met meer terugkerende lussen (loops) en inefficiënte patronen dan geslaagde runs.
• Probleemcomplexiteit: Naarmate problemen moeilijker zijn (gebaseerd op menselijke schatting), worden de trajecten van agenten complexer en uitgebreider, wat overeenkomt met menselijk gedrag.
• Modelsterkte: Sterkere LLMs (zoals Claude Sonnet 4) genereren complexere grafen met bredere exploratie en meer validatiestappen, wat leidt tot hogere succespercentages, maar soms ook tot inefficiëntie door over-exploratie.

2. Strategieanalyse

• Geslaagde trajecten volgen vaak een coherente flow: Lokalisatie $\rightarrow$ Patchen $\rightarrow$ Validatie.
• Mislukte trajecten tonen vaak chaotische patronen, zoals terugkeren naar eerdere fasen zonder vooruitgang of het overslaan van cruciale stappen (zoals validatie).
• Sterkere modellen passen hun strategie dynamisch aan bij moeilijkere problemen, terwijl zwakkere modellen eerder vastlopen in repetitieve patronen.

3. Inefficiëntie Patronen (Anti-patronen)
De studie identificeerde specifieke anti-patronen, zoals:

• RepeatedView: Het herhaaldelijk bekijken van hetzelfde bestand zonder aanpassing.
• ZoomOut: Het navigeren van een dieper niveau naar een hoger niveau in de mapstructuur (teken van verkeerde lokalisatie).
• UnresolvedRetry: Meerdere mislukte pogingen om hetzelfde bestand te bewerken.
• Interessant genoeg komen deze inefficiënties ook voor in geslaagde runs, wat aantoont dat succes niet altijd gelijkstaat aan efficiëntie.

4. Effectiviteit van Online Interventie
De implementatie van online monitoring en interventie (OMI) leverde significante verbeteringen op voor problematische instanties:

• Oplossingspercentage: Steeg met 6,9% tot 23,5% over verschillende modellen.
• Trajectlengte: Significante verkorting van de trajecten (minder stappen).
• Oscillatie: Vermindering van cyclisch/terugkerend gedrag met meer dan 90%.
• Kosten: De monitoring en interventie voegden bijna geen overhead toe (< 10 ms per stap).

Bijdragen en Significantie

De belangrijkste bijdragen van dit werk zijn:

1. Graphectory: Een nieuwe, gestructureerde grafische representatie voor agente trajecten die semantische relaties vastlegt.
2. Langutory: Een compacte abstractie die vergelijking en patroonherkenning mogelijk maakt.
3. Procesgerichte Metriek: Een reeks nieuwe maatstaven om de kwaliteit van het probleemoplossingsproces te kwantificeren, los van het eindresultaat.
4. Systematische Analyse: Een grote schaal studie (4000 trajecten) die diepe inzichten geeft in hoe agenten redeneren en waar ze vastlopen.
5. Online Interventie: Een bewezen methode om agenten in real-time te corrigeren, wat leidt tot efficiëntere en succesvollere systemen.

Significantie:
Dit artikel markeert een verschuiving in de evaluatie van agente systemen van puur "werk of werkt niet" naar een diepgaand begrip van hoe het werk wordt gedaan. Het biedt software-ontwikkelaars en onderzoekers de tools om inefficiënties te diagnosticeren en systemen te bouwen die niet alleen effectief, maar ook robuust en efficient zijn. De openbaarmaking van de dataset en tools (Graphectory/Langutory) stimuleert verdere research in procesgerichte evaluatie van AI-agenten.