Technische Samenvatting: BLAgent: Agentic RAG voor Buglocalisatie op Bestandsniveau

Probleemstelling

Buglocalisatie blijft een kritieke knelpunt in softwareonderhoud, met name voor downstreamtaken zoals oorzaakanalyse, triage en Geautomatiseerde Programmareparatie (APR). Hoewel reparatiesystemen op basis van Large Language Models (LLM) vooruitgang hebben geboekt, wordt hun effectiviteit fundamenteel beperkt door de kwaliteit van de localisatie op bestandsniveau. In hiërarchische pijplijnen leiden onnauwkeurige bestandsselecties tot fouten die zich voortplanten naar volgende fasen (bijvoorbeeld localisatie op statement-niveau of het genereren van patches), wat vaak reparatiefalen veroorzaakt.

Bestaande Retrieval-Augmented Generation (RAG)-benaderingen voor code vertrouwen vaak op statische retrievering en naïeve tekstgebaseerde chunking, waardoor ze de structurele complexiteit van code of het redeneren dat nodig is om defecte bestanden nauwkeurig te identificeren, niet kunnen vastleggen. Bovendien ontbreekt het aan puur op embedding gebaseerde methoden de redeneervermogens om functionele relevantie te beoordelen, terwijl bestaande agent-gebaseerde benaderingen vaak onbeperkte grafgebaseerde traversie toepassen, wat verbodszware rekenkosten met zich meebrengt.

Methodologie: BLAgent Framework

De auteurs stellen BLAgent voor, een nieuw agent-gebaseerd RAG-framework dat is ontworpen voor buglocalisatie op bestandsniveau. Het systeem integreert drie kernelementen om nauwkeurigheid en kosten in evenwicht te brengen:

1. Repository-codering met Path-geaugmenteerde AST-gebaseerde Chunking

In plaats van naïeve tekstverdeling, maakt BLAgent gebruik van CodeSplitter om bronbestanden te segmenteren op basis van Abstract Syntax Tree (AST)-grenzen (bijvoorbeeld functies, klassen, logische blokken). Dit zorgt voor semantische behoud, waardoor fragmentatie van codeconstructies wordt voorkomen.

• Path Augmentatie: Elk codechunk wordt voorafgegaan door zijn relatieve bestandspad (bijvoorbeeld src/utils/math.py). Dit creëert een directe afstemmingskanaal tussen pad-achtige signalen in bugrapporten (bijvoorbeeld tracebacks, moduleverwijzingen) en de codechunks, waardoor vocabulaireverschillen tussen natuurlijke taalbeschrijvingen en code-identifiers worden aangepakt.

2. Query-transformatie vanuit twee perspectieven

Om de semantische kloof tussen bugrapporten en code te overbruggen, decomposeert BLAgent elk bugrapport in twee complementaire queries met behulp van LLM's:

• Structurele Transformatie ($T_0$): Richt zich op statische, syntactische aspecten, en extrahert identifiers, modules, functienamen en traceback-context.
• Gedragsmatige Transformatie ($T_1$): Richt zich op runtime-gedrag, en legt waargenomen symptomen, verwachte versus feitelijke uitvoer en triggerende condities vast.
  Beide queries worden onafhankelijk gebruikt om kandidaatbestanden op te halen uit een vectordatabase. De resulterende kandidaatsets worden samengevoegd (gededupliceerd) om een compacte pool (beperkt tot 15 bestanden) voor de agent te vormen.

3. Tweefasige Agent-gebaseerde Herordening

BLAgent voert beperkt redeneren uit over de opgehaalde kandidaatset via een tweefasig proces:

• Fase 1: Skelet-gebaseerde Agent Scoring (SAS): Een ReAct-gebaseerde agent inspecteert iteratief de structurele skeletten (klassen, functiesignaturen, docstrings) van kandidaatbestanden. Het wijst relevantiescores (0–10) toe op basis van hypothesen over welke bestanden wijziging vereisen. Deze fase werkt efficiënt binnen contextlimieten door volledige broncodeverwerking te vermijden.
• Fase 2: Evidentie-geankerde Herordening (EAR): Om gelijke standen op te lossen en implementatieniveau-relevantie te verifiëren, ondergaan de top-$M$ ( ingesteld op 5) bestanden uit Fase 1 een single-shot inferentie. De context wordt bijgesneden om alleen de globale structuur van het bestand en de volledige implementatie van de door de retriever geïdentificeerde methoden op te nemen. De LLM voert een definitieve rangschikking uit op basis van deze onderbouwde evidentie.

Belangrijkste Bijdragen

1. Agent-gebaseerde RAG voor Localisatie: BLAgent introduceert een beperkt redeneerframework dat retrievering integreert met iteratief, tool-geaugmenteerd redeneren, waardoor de hoge kosten van onbeperkte graftraversie worden vermeden.
2. AST-bewuste, Path-geaugmenteerde Chunking: Het artikel toont aan dat het behoud van syntactische grenzen en het verrijken van chunks met bestandspaden de retriever-recall aanzienlijk verbetert in vergelijking met standaard tekstgebaseerde of code-bewuste chunking.
3. Query's vanuit twee perspectieven: Het framework toont aan dat het decomponeren van bugrapporten in structurele en gedragsmatige queries complementaire retrieversignalen biedt, waardoor de recall van de initiële kandidaatpool wordt versterkt.
4. Kostenefficiënt Ontwerp: Door redeneren te beperken tot een compacte, door retrievering gefilterde kandidaatset en code-skeletten te gebruiken, bereikt BLAgent hoge nauwkeurigheid met aanzienlijk lager tokenverbruik en API-kosten in vergelijking met grafgebaseerde agent-gebaseerde baselines.

Experimentele Resultaten

Het framework werd geëvalueerd op de SWE-bench-Lite-dataset (300 real-world Python-bugs).

• Localisatienauwkeurigheid:
  • Met een open-source model (GPT-OSS-120B) bereikte BLAgent een Top-1 nauwkeurigheid van 78,6% en een MRR van 0,851.
  • Met een gesloten bronmodel (Claude-4.6-Sonnet) bereikte het een Top-1 nauwkeurigheid van 86,7% en een MRR van 0,900.
  • Deze resultaten presteren beter dan state-of-the-art baselines, waaronder LocAgent (een grafgebaseerde agent-gebaseerde aanpak) en Agentless (een APR-framework met localisatie), vaak met aanzienlijke marges.
• Kostenefficiëntie: BLAgent is meer dan 18× goedkoper dan de sterkste baseline (LocAgent) bij gebruik van hetzelfde gesloten bronmodel, waarbij alle 300 instanties voor ongeveer $27 totaal worden voltooid, terwijl LocAgent een budget van $300 opgaf na slechts 182 instanties.
• Impact op Geautomatiseerde Programmareparatie (APR): Bij integratie in het Agentless APR-framework verbeterde BLAgent de end-to-end probleemoplossingsrate met meer dan 20% (van 27,6% naar 34,0% met meerderheidsstemming).
• Generaliseerbaarheid: De architectuur werd succesvol uitgebreid naar localisatie op functieniveau met één promptwijziging, waarbij state-of-the-art resultaten werden bereikt zonder structurele wijzigingen in de pijplijn.

Betekenis en Claims

Het artikel beweert dat BLAgent een nieuwe state-of-the-art vestigt voor buglocalisatie op bestandsniveau door effectieve combinatie van retrievering en agent-gebaseerd redeneren. De primaire betekenis ligt in het aantonen dat:

1. Localisatie een doorslaggevende factor is: Nauwkeurige localisatie op bestandsniveau vertaalt zich direct naar meetbare winsten in het succes van end-to-end geautomatiseerde reparatie.
2. Beperkt redeneren superieur is aan onbeperkte traversie: Agent-gebaseerd redeneren dat is beperkt tot een hoogwaardige, door retrievering gefilterde kandidaatset, presteert beter dan complexe grafgebaseerde benaderingen in zowel nauwkeurigheid als kosten.
3. Retrieverkwaliteit de prestaties begrenst: De effectiviteit van de agent-gebaseerde pijplijn wordt fundamenteel beperkt door de recall van de initiële dense retriever; daarom zijn verbeteringen in chunking en query-transformatie cruciaal.
4. Kostenefficiënte schaalbaarheid: Hoge prestaties localisatie kan worden bereikt met open-source modellen en efficiënt contextbeheer (skeletten), waardoor geavanceerde buglocalisatie toegankelijk wordt zonder de verbodszware kosten van propriëtaire modellen of graftraversie.

De auteurs concluderen dat hoewel nauwkeurige localisatie noodzakelijk is, het niet voldoende is voor perfecte reparatie, aangezien downstream-falen (localisatie op functie- of lijnniveau en patchgeneratie) nog steeds significante knelpunten blijven. BLAgent biedt echter een robuuste, kostenefficiënte basis voor het aanpakken van de upstream localisatie-uitdaging in LLM-gebaseerd softwareonderhoud.