💻 computer science

ARISE: A Repository-level Graph Representation and Toolset for Agentic Fault Localization and Program Repair

ARISE is een repository-niveau framework dat LLM-gebaseerde agenten verbetert voor foutlocatie en programmareparatie door een multi-granulariteits programmagraaf met intra-procedurele data-flow-edges en een bevraagbare slicing-API in te voeren, wat aanzienlijke verbeteringen oplevert in de nauwkeurigheid van de lokalisatie en de succespercentages van reparatie op de SWE-bench Lite-benchmark.

Oorspronkelijke auteurs: Shahd Seddik, Fatemeh Fard

Gepubliceerd 2026-05-06

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Shahd Seddik, Fatemeh Fard

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 detective bent die probeert een misdaad op te lossen in een enorme, uitgestrekte stad (de software-repository). De stad heeft duizenden gebouwen (bestanden), elk met honderden kamers (functies), en in die kamers staan talloze meubels en documenten (regels code).

Jouw taak is om het één specifieke document te vinden dat de leugen (de bug) bevat die ervoor zorgt dat het stroomnet van de stad uitvalt, en dat document vervolgens te herschrijven om het te repareren.

Het Probleem: Verdwalen in de Stad

In het verleden hadden detectives (AI-agenten) die deze zaken probeerden op te lossen, twee hoofdproblemen:

Ze hadden alleen een plattegrond van de gebouwen: Ze wisten welk gebouw naast welk lag, en welk gebouw een deur had die naar een ander leidde. Maar ze wisten niet hoe informatie binnen de kamers bewoog.
Ze moesten alles lezen: Om de leugen te vinden, moesten ze vaak hele boeken lezen of elke enkele pagina in een gebouw scannen, in de hoop toevallig op de aanwijzing te stuiten. Dit was traag, duur en leidde hen vaak naar de verkeerde kamer.

De Oplossing: ARISE (Het Gereedschapskistje van de Super-Detective)

De auteurs hebben een nieuw systeem ontwikkeld dat ARISE heet. Denk aan ARISE als het geven van een superkrachtige, interactieve 3D-kaart van de stad aan de detective, die niet alleen gebouwen toont, maar ook precies laat zien hoe een specifiek bewijsstuk (een variabele) van het ene document naar het andere beweegt binnen een kamer.

Hier is hoe ARISE werkt, opgesplitst in drie eenvoudige hulpmiddelen:

1. De Structurele Kaart (Niveau 1)

Dit is de "gebouwkaart". Hij vertelt de detective: "Dit bestand bevat deze klasse, die die functie aanroept." Het is alsof je weet dat de Bibliotheek verbonden is met de School. Dit helpt de detective om in te schatten welk gebouw ze moeten zoeken, maar het vertelt hen niet welke pagina in het boek verkeerd is.

2. Het "Volg het Geld"-Gereedschap (Niveau 2 - De Grote Innovatie)

Dit is het magische deel. In de oude tijden, als een detective een verdacht getal in een document vond, moest hij handmatig elke pagina ervoor en ernaar ombladeren om te zien waar dat getal vandaan kwam of waar het naartoe ging.

ARISE introduceert een hulpmiddel genaamd Data-Flow Slicing (Data-stroom snijden). Stel je een magische vergrootglas voor. Je richt het op een specifiek getal in een document en zegt: "Laat me alles zien dat dit getal heeft aangeraakt."

Terugwaartse Snede: Het glas markeert direct elke zin die dat getal heeft gegenereerd of gewijzigd.
Voorwaartse Snede: Het markeert elke zin die dat getal later heeft gebruikt.

In plaats van 50 pagina's te lezen, krijgt de detective een enkele, gemarkeerde lijst met slechts de 5 of 6 zinnen die echt belangrijk zijn. Dit is alsof je in staat bent om direct een specifieke waterdruppel van een kraan tot aan de gootsteen te volgen, en de rest van de leidingen te negeren.

3. Het Bewijsmapje (Niveau 3)

Zodra de detective de verdachte zinnen heeft gevonden, moet hij ze samenvoegen tot een rapport om de bug te repareren. Soms wordt het rapport te lang en raakt het brein van de detective (het AI-model) overbelast.
Dit hulpmiddel fungeert als een slimme bibliothecaris. Het neemt alle gemarkeerde zinnen, rangschikt ze op belangrijkheid en pakt ze in een net, beknopt "Bewijsmapje" dat perfect in de rugzak van de detective past (het geheugenlimiet). Dit zorgt ervoor dat de detective eerst de belangrijkste aanwijzingen ziet.

De Resultaten: Heeft Het Gewerkt?

De onderzoekers hebben dit nieuwe systeem getest op 300 echte "misdaden" (bugs) uit populaire softwareprojecten. Ze vergeleken ARISE met een standaarddetective (de SWE-agent) die alleen de basisgereedschappen had.

De Misdaadplek Vinden: De standaarddetective kon ongeveer 57% van de tijd het juiste gebouw (bestand) raden. ARISE had het 67% van de tijd goed.
De Exacte Kamer Vinden: De standaarddetective raakte de juiste kamer (functie) 43% van de tijd goed. ARISE steeg naar 60%.
De Exacte Zin Vinden: De standaarddetective vond de juiste regel code 26% van de tijd. ARISE verbeterde dit tot 41%.

Het allerbelangrijkste is dat, omdat de detective het exacte probleem sneller en nauwkeuriger kon vinden, ze de bug succesvol konden repareren in 22% van de gevallen, vergeleken met slechts 17% voor de standaarddetective.

Belangrijkste Leerpunten uit het Artikel

Structuur is niet genoeg: Alleen weten hoe bestanden verbonden zijn, is niet voldoende; je moet weten hoe data binnen de code beweegt.
Het "Magische Glas" is de sleutel: De grootste verbetering kwam van het Data-Flow Slicing-gereedschap. Het stelde de AI in staat om het giswerk over te slaan en direct naar de bron van het probleem te gaan.
Geen vertaler nodig: De onderzoekers probeerden een stap toe te voegen waarbij een kleinere AI de data samenvatte in gewoon Engels voor de hoofddetective. Ze ontdekten dat dit onnodig was. De hoofddetective (een groot AI-model) kon de ruwe, gestructureerde data prima lezen. Het toevoegen van de samenvattingsstap kostte alleen maar tijd en geld.
De Limiet: Het systeem is geweldig in het vinden van problemen binnen een enkele kamer. Echter, als het probleem begint in één kamer, wordt doorgegeven aan de kamer van een buur, en daar een crash veroorzaakt, raakt de detective soms in de war. Dit is het ene gebied dat de auteurs zeggen dat in de toekomst meer werk nodig heeft.

Kortom, ARISE geeft AI-agenten een manier om de "draad" van een variabele door code te volgen, en verandert een zoektocht naar een speld in een hooiberg in een rechtstreeks pad naar de oplossing.

Technische Samenvatting: ARISE – Een repository-level graafrepresentatie en toolset voor agentische foutlokalisatie en programmareparatie

Probleemstelling

Geautomatiseerde programmareparatie (APR) en foutlokalisatie op repository-niveau vereisen dat agenten complexe codebases navigeren die zich uitstrekken over meerdere bestanden, modules en pakketten. Hoewel bestaande agentische systemen (bijvoorbeeld SWE-agent) kunnen interageren met repositories, kampen ze vaak met fijne foutlokalisatie (het identificeren van specifieke functies en regels) vanwege een gebrek aan semantische precisie.

Huidige op grafen gebaseerde benaderingen modelleren doorgaans structurele relaties (bestanden, klassen, functies en hun call/import-afhankelijkheden), maar falen in het modelleren van intra-procedurele dataflow. Bijgevolg ontbreekt agenten het vermogen om te traceren hoe variabele waarden worden gedefinieerd en doorgegeven binnen een procedure. Deze beperking dwingt agenten om te vertrouwen op lexische gelijkenis of brede structurele traversie, wat onvoldoende is om de exacte statements te pinpointen die verantwoordelijk zijn voor een bug, vooral wanneer de fout complexe variabelegebruik binnen een functie omvat.

Methodologie

De auteurs presenteren ARISE (Agentic Repository-level Issue Solving Engine), een systeem dat het SWE-agent-framework uitbreidt met een gestructureerde, querybare programmagraaf en een tool-API met drie niveaus. De kerninnovatie is de integratie van dataflow-slicing als een eerste klas agent-primitief.

1. Multi-granulariteits Programmagraaf

ARISE construeert een gerichte, getypeerde eigenschapsgraaf ( $G = (V, E)$ ) die twee lagen van informatie verenigt:

Structurele Relaties: Knopen representeren directories, modules, klassen, functies, methoden en statements. Randen vangen containment, imports, inheritances en call-relaties op.
Dataflow-Relaties: De graaf wordt uitgebreid tot het statement-niveau. Voor elke functie/methode voert het systeem een intra-procedurele analyse uit om def-use-koppelingen (definitie-gebruik) te identificeren.
- Knopen: Statement-knopen corresponderen met top-level AST-statements.
- Randen: DataflowDefUse en DataflowUseDef-randen verbinden statements waar een variabele wordt gedefinieerd met statements waar deze wordt gebruikt (en vice versa).
- Scope: Deze analyse respecteert lexische scope (behandeling van global/nonlocal-declaraties) en behandelt veelvoorkomende Python-toewijzingspatronen (toewijzingen, geaugmenteerde toewijzingen, lustrdoelen, contextmanagers en parameters).

2. Tool-API met Drie Niveaus

De graaf wordt via een modulaire API blootgesteld aan de LLM-agent, waardoor de agent iteratief bewijs kan bevragen:

Niveau 1: Structurele Retrieval: Tools voor het zoeken naar entiteiten, traverseren van call/import-grafen en ophalen van code-spanningen. Dit reproduceert de mogelijkheden van eerdere structurele-grafsystemen (bijvoorbeeld RepoGraph, LocAgent).
Niveau 2: Dataflow-Slicing: De kernnoviteit. De tool get_dataflow_slice stelt de agent in staat variabelestromen te traceren. Gegeven een zaadje (bestand, regel, variabele) en een richting (achterwaarts, voorwaarts of bidirectioneel), retourneert het een gestructureerde lijst van statement-spanningen die de variabele definiëren of consumeren. Dit stelt de agent in staat in één query te beantwoorden "welke statements beïnvloeden deze variabele?".
Niveau 3: Contextbundeling: Tools (build_context_bundle, rank_suspect_regions) die het opgehaalde bewijs assembleren in een contextpakket dat beperkt is door het token-budget. Ze scoren code-spanningen op basis van TF-IDF-relevantie, structurele nabijheid en lidmaatschap van de slice, zodat de meest causaal relevante code aan de reparatie-subagent wordt gepresenteerd.

3. Agentlus

ARISE werkt op het SWE-agent-scaffold. De agent communiceert via een multi-turn-protocol met de repository, waarbij naar behoefte wordt gekozen voor het aanroepen van structurele tools, slicing-tools of bundeling-tools. Het systeem is ontworpen om framework-onafhankelijk te zijn, waardoor de graafbouwer en slicing-API als plug-in in elk tool-gebruikend agent kunnen worden ingebouwd.

Belangrijkste Bijdragen

Multi-granulariteits Programmagraaf: Een repository-graaf die structurele organisatie verenigt met intra-procedurele dataflow-informatie op statement-niveau, waardoor agenten waardenpropagatie direct kunnen bevragen.
Dataflow-Slicing als Agent-Primitief: De introductie van get_dataflow_slice als een querybare tool. In tegenstelling tot statische preprocessing kunnen agenten hiermee dynamisch variabeledefinities en -gebruik traceren tijdens het redeneren, en retourneren gestructureerde output waar modellen direct op kunnen redeneren.
Framework-onafhankelijke Toolset: Een ontkoppelde implementatie van de graafbouwer en slicing-API, ontworpen als een plug-and-play-plugin voor toekomstig APR-onderzoek zonder dat de onderliggende analyselogica opnieuw hoeft te worden geïmplementeerd.

Experimentele Resultaten

Het systeem werd geëvalueerd op SWE-bench Lite (300 echte GitHub-issues verspreid over 11 Python-repositories) met Qwen2.5-Coder-32B-Instruct als ruggengraat.

Lokalisatieprestaties

Vergeleken met de ongewijzigde SWE-agent-baseline:

Function Recall@1: Verbetering met 17,0 punten (van 43,0% naar 60,0%).
Line Recall@1: Verbetering met 15,0 punten (van 26,0% naar 41,0%).
File Recall@1: Verbetering met 10,0 punten.
Ablatie-insights:
- Het toevoegen van Niveau 1 (Structureel) bood een basisverbetering ten opzichte van SWE-agent.
- Het toevoegen van Niveau 2 (Dataflow-Slicing) leverde de grootste enkele stapsgewijze winst op (+7,0 punten in Function Recall@1), wat bevestigt dat dataflow-traceren cruciaal is voor fijne foutlokalisatie.
- Het toevoegen van Niveau 3 (Contextbundeling) bood verdere incrementele winsten.
- ARISE-Coarse (schema van Niveau 1 + Niveau 2 maar zonder dataflow-randen) presteerde vergelijkbaar met alleen Niveau 1, wat bewijst dat de verbetering voortkomt uit de graafdata zelf, en niet louter uit de aanwezigheid van een extra tool.
- ExplainSlice (het toevoegen van samenvattingen in natuurlijke taal aan slices) leverde geen meetbare verbetering op, wat aangeeft dat grote code-modellen (schaal 32B) direct kunnen redeneren over gestructureerde slice-output zonder bemiddeling in natuurlijke taal.

Reparatieprestaties

Pass@1: ARISE-Full behaalde 22,0% (66/300), een verbetering van 4,7 procentpunten ten opzichte van de SWE-agent-baseline (17,3%).
Correlatie: Er is een sterke, monotoon toenemende Spearman-correlatie tussen Function Recall@1 en Pass@1 naarmate er preciezere tools worden toegevoegd (van 0,38 bij SWE-agent naar 0,53 bij ARISE-Full). Dit bevestigt dat lokaliseringskwaliteit de bindende beperking is voor reparatiesucces in deze setting.

Betekenis en Claims

Het artikel stelt dat de primaire bottleneck in repository-level APR niet alleen de redeneercapaciteit van de LLM is, maar hoe relevant context wordt gelokaliseerd en gestructureerd.

Dataflow als Retrieval-Primitief: De auteurs betogen dat het blootleggen van intra-procedurele def-use-slices als een eerste klas tool effectiever is dan vertrouwen op structurele topologie alleen. Dit verkleint de zoekruimte, waardoor agenten kunnen kiezen voor een hypothese op functieniveau op basis van één achterwaartse slice in plaats van brede call-grafen te traverseren.
Gestructureerd versus Natuurlijke Taal: De resultaten daagden de aanname uit dat gestructureerde analyse moet worden samengevat in natuurlijke taal voor LLM's. Op de schaal van 32B parameters consumeren modellen gestructureerde slice-output direct, waardoor samenvattingslagen overbodig en kostbaar zijn.
Beperkte Beperkingen: De auteurs erkennen dat het huidige systeem intra-procedureel is. Het kan variabelestromen niet traceren over call-grenzen heen (inter-procedureel), wat verantwoordelijk is voor 45% van de resterende fouten (fouten met het verkeerde bestand). Zij identificeren het uitbreiden naar inter-procedurele slicing als de primaire richting voor toekomstig werk. Bovendien is de aanpak momenteel specifiek voor Python vanwege de afhankelijkheid van AST-knooptypen.

Kortom, ARISE demonstreert dat het uitbreiden van agentische workflows met precieze, querybare dataflow-grafen de foutlokalisatie aanzienlijk verbetert en bijgevolg de succespercentages van geautomatiseerde programmareparatie verhoogt.