💻 computer science

AgenticSZZ: Temporal Knowledge Graph-Guided Agentic Bug-Inducing Commit Identification

AgenticSZZ is een nieuwe aanpak die Temporele Kennisgrafieken en LLM-agenten benut om de beperkingen van traditionele op git blame gebaseerde methoden te overwinnen door de identificatie van commits die bugs introduceren te herformuleren als een graafzoekprobleem, waardoor de detectienauwkeurigheid aanzienlijk wordt verbeterd door uitgebreide historische context en causaal redeneren.

Oorspronkelijke auteurs: Yu Shi, Hao Li, Bram Adams, Ahmed E. Hassan

Gepubliceerd 2026-05-12

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yu Shi, Hao Li, Bram Adams, Ahmed E. Hassan

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

De Nieuwe Kaart van de Detective: Hoe AgenticSZZ Softwarebugs Ontdekt

Stel je voor dat je een detective bent die een mysterie probeert op te lossen: Wie heeft de code verbroken? In de wereld van software is een "bug" een fout die ervoor zorgt dat een programma crasht of zich vreemd gedraagt. Om het te herstellen, moet je het exacte moment in de geschiedenis vinden waarop een ontwikkelaar per ongeluk die fout introduceerde. Dit moment wordt de Bug-Inducing Commit (BIC) genoemd.

Decennia lang hebben detectives een standaardtool gebruikt genaamd SZZ (vernoemd naar zijn makers). Denk aan SZZ als een vergrootglas dat naar het "misdaadplek" kijkt (de codefix) en vraagt: "Wie heeft deze specifieke regel code het laatst aangeraakt?" Het gebruikt een opdracht genaamd git blame om de vinger te wijzen naar de meest recente persoon die die regel heeft gewijzigd.

Het Probleem:
De auteurs van dit paper ontdekten een groot gebrek in deze oude methode. Ze keken naar meer dan 2.000 bugfixes uit de echte wereld en ontdekten dat 40% van de tijd het vergrootglas naar de verkeerde persoon wijst.

Waarom?

De Rode Haring: Soms is de persoon die de regel het laatst aanraakte alleen de lettertypekleur veranderd of een spatie toegevoegd (een "cosmetische wijziging"). De echte bug werd maanden geleden door iemand anders geïntroduceerd, maar de oude SZZ-tool kan niet voorbij de laatste persoon kijken.
Het Ontbrekende Bewijs: Soms raakte de fix geen enkele oude regel aan; het voegde gewoon nieuwe regels toe. In dit geval heeft het vergrootglas niets om naar te kijken, en geeft de tool het volledig op.

De Oplossing: AgenticSZZ

De auteurs, Yu Shi en zijn team van de Queen's University, bouwden een nieuw systeem genaamd AgenticSZZ. In plaats van alleen naar één regel code te kijken, bouwden ze een Tijdsreiskart (een Temporele Kennisgrafiek) en huurden ze een Super-Detective AI (een LLM Agent) in om erdoorheen te navigeren.

Hier is hoe het werkt, met eenvoudige analogieën:

1. De Kaart Bouwen (De Temporele Kennisgrafiek)

Stel je de geschiedenis van een softwareproject niet voor als een rechte lijn van tekst, maar als een gigantisch, 3D-spinnenweb.

De Knopen: Elke keer dat een ontwikkelaar zijn werk opslaat (een "commit"), is het een stip op het web.
De Draden: Het web verbindt deze stippen op twee manieren:
- Tijd: Wie kwam voor wie?
- Structuur: Wie veranderde dezelfde bestanden of functies?
De Uitbreiding: In tegenstelling tot de oude methode die alleen naar de directe omgeving kijkt, breidt AgenticSZZ de kaart uit. Het traceert het web terug vanaf de fix en terug vanaf de "laatste persoon die de regel aanraakte". Dit zorgt ervoor dat de kaart de "Rode Haringen" en de "Ontbrekende Bewijzen" bevat die de oude tool negeerde.

2. De Super-Detective (De LLM Agent)

Nu ze de kaart hebben, hebben ze iemand nodig die slim genoeg is om deze te lezen. Ze vroegen niet zomaar een computer om de lijst te scannen; ze huurden een AI Agent in, uitgerust met speciale hulpmiddelen.

Denk aan deze Agent als een detective met een gereedschapskist:

De Lijstmaker: "Laat me de topverdachten zien."
De Tijdsreiziger: "Laat me achteruit lopen langs het web om te zien wie anders dit bestand heeft aangeraakt."
De Feitencontroleur: "Lees het commit-bericht en de codewijzigingen om te zien of deze persoon de logica daadwerkelijk heeft verbroken."
Het Logische Brein: "Maakt deze verandering zin als de oorzaak van de bug?"

De Agent raadt niet zomaar. Het verkent de kaart, controleert het bewijs en redeneert door de geschiedenis heen om de echte dader te vinden, zelfs als die persoon ver terug in de tijdlijn zit of op een andere tak van het project.

De Resultaten: Een Beter Detective

Het team testte dit nieuwe systeem op drie enorme datasets (Linux-kernel, Apache-projecten en GitHub-repositories). Hier is wat ze vonden:

Succespercentage: AgenticSZZ vond de juiste bug-inducerende commit 16% tot 34% vaker dan de beste bestaande methoden.
Het Oplossen van het Onoplosbare: Het loste succesvol gevallen op die eerder onmogelijk waren, zoals wanneer de fix nieuwe code toevoegde (de "Blameless"-gevallen) of wanneer de bug werd geïntroduceerd door een commit die plaatsvond na de laatste persoon die de regel aanraakte, maar voor de fix.
Het "Sweet Spot" van AI: De auteurs testten verschillende AI-modellen om als detective te fungeren. Ze ontdekten dat de AI "slim genoeg" moet zijn om de baan te doen. Kleinere, goedkopere AI-modellen gaven te snel op of slaagden de belangrijke stappen over, waardoor ze de bug niet vonden. Alleen de grotere, capabelere modellen konden succesvol navigeren door het complexe web van geschiedenis.

De Conclusie

Het paper betoogt dat het vinden van softwarebugs niet gaat om het rangschikken van een lijst van verdachten (de oude manier); het gaat om het doorzoeken van een complex web van geschiedenis (de nieuwe manier).

Door een Tijdsreiskart (die de zoekruimte uitbreidt) te combineren met een Redenerende AI Agent (die verdachten intelligent filtert), lost AgenticSZZ een probleem op dat software-detectives al 20 jaar op de proppen heeft gesteld. Het bewijst dat je om de worteloorzaak van een bug te vinden, soms verder moet kijken dan de persoon die de code het laatst aanraakte.

Technische Samenvatting: AgenticSZZ

Probleemstelling

Het identificeren van de Bug-Inducerende Commit (BIC) is een fundamentele taak in softwareonderhoud, die defectvoorspelling, geautomatiseerde programmareparatie en historische buganalyse mogelijk maakt. De dominante aanpak gedurende twee decennia is het SZZ-algoritme en zijn varianten, die vertrouwen op git blame om verwijderde of gewijzigde regels in een Bug-Fixing Commit (BFC) terug te traceren naar de commit die ze voor het laatst heeft aangeraakt.

Deze aanpak lijdt echter aan fundamentele beperkingen met betrekking tot recall. Een voorlopige studie van 2.102 gevalideerde bugfix-commits door de auteurs onthult dat git blame alleen onvoldoende is voor bijna de helft van alle gevallen:

28% van de BIC's vereist het doorlopen van de commitgeschiedenis verder dan de directe blame-resultaten (als voorouders van blame-commits of als voorouders van de BFC).
14% van de gevallen is "blame-loos", waarbij de BFC alleen toegevoegde regels bevat zonder verwijderde/gewijzigde regels om op te blame-en, waardoor standaard SZZ niet toepasbaar is.
Zelfs binnen de 57% van de gevallen waar BIC's voorkomen in blame-resultaten, blijft het identificeren van de juiste BIC onder meerdere kandidaten uitdagend vanwege de hoge complexiteit in sommige projecten.

Bestaande verbeteringen van SZZ hebben zich gericht op het filteren van heuristieken, het detecteren van refactorings, of het rangschikken van blame-kandidaten met diep leren en LLM's, maar ze blijven beperkt door de zoekruimte die strikt wordt gedefinieerd door git blame.

Methodologie: AgenticSZZ

De auteurs stellen AgenticSZZ voor, de eerste aanpak die Temporele Kennisgrafieken (TKG's) toepast op analyse van software-evolutie. Het kerninzicht is het herformuleren van BIC-identificatie van een rangschikkingsprobleem over een statische lijst van blame-kandidaten naar een graafzoekprobleem over de temporele commitgeschiedenis.

De methodologie werkt in twee distincte fasen:

1. Constructie van Temporele Kennisgrafiek (TKG)

Het systeem construeert een grafiek die commits encodeert als knopen met temporele ordening en structurele verbindingen (gedeelde bestanden en functies). De zoekruimte wordt uitgebreid buiten directe blame-resultaten via twee traverseringsrichtingen:

Blame Voorouder Traversering: Startend bij blame-commits, loopt het systeem terug door de bestandsgeschiedenis om eerdere commits te vinden die de buglogica mogelijk hebben geïntroduceerd.
BFC Voorouder Traversering: Startend bij de BFC, loopt het systeem terug naar de blame-commits om tussentijdse commits te identificeren die correcte code mogelijk in buggerende code hebben getransformeerd.
Contextuitbreiding: Om "blame-loze" gevallen te behandelen en de kwaliteit van de startpunten te verbeteren, past het systeem een fallback-strategie toe door contextregels (2 regels voor en na) rondom toegevoegde code te blame-en.

Het grafschema omvat:

Knopen: Commits (gelabeld als BFC, blame, blame_ancestor, of bfc_ancestor), Bestanden en Functies.
Randen: PRECEDES (temporele ordening), MODIFIES_FILE, MODIFIES_FUNCTION, en DEFINED_IN.

2. Agente BIC Zoektocht

Een LLM-agent navigeert door de geconstrueerde TKG met behulp van vier gespecialiseerde tools om redeneren over causale relaties:

Kandidatenenumeratie (list_candidates): Haalt de top- $K$ kandidaten op, gerangschikt op basis van een fitheidsscore (met prioriteit voor blame > blame_ancestor > bfc_ancestor).
Structurele Traversering (traverse_graph): Volgt randen om commits te ontdekken die dezelfde code-entiteiten wijzigen.
Eigenschapsquery (query_node): Inspecteert commit-metadata (berichten, tijdstempels, overlappingen).
Causale Analyse (read_node_content): Leest code-diffs om te verifiëren of de wijzigingen van een kandidaat causaal gerelateerd zijn aan de bugfix.

De agent onderzoekt kandidaten iteratief, waarbij ze initiële rangschikkingen mogelijk overschrijft op basis van semantische redenering en causale verificatie, totdat een beslissing is bereikt of een staplimiet is bereikt.

Belangrijkste Bijdragen

Voorlopige Studie (RQ0): Een systematische karakterisering van BIC-locaties ten opzichte van blame-commits, waarbij wordt gekwantificeerd dat 28% van de gevallen geschiedenis-traversering vereist en 14% blame-loos is, waarmee de noodzaak voor uitgebreide zoekstrategieën wordt vastgesteld.
AgenticSZZ Framework: De eerste toepassing van TKG's op analyse van software-evolutie, waarbij BIC-identificatie wordt herformuleerd als een graafzoekprobleem. Dit maakt het identificeren van BIC's buiten de traditionele, door blame gedefinieerde kandidatenlijst mogelijk.
Uitgebreide Evaluatie: Een rigoureuze evaluatie op drie datasets (Linux, Apache, GitHub) waarbij AgenticSZZ wordt vergeleken met zeven SZZ-varianten en de state-of-the-art LLM4SZZ.
LLM-gevoeligheidsanalyse: Een onderzoek naar hoe verschillende open-weight LLM's de prestaties beïnvloeden, waarbij een capaciteitsdrempel wordt geïdentificeerd voor effectieve TKG-navigatie.

Resultaten

Evaluatie op 2.102 gevalideerde BFC-BIC-paren toont aan dat AgenticSZZ state-of-the-art prestaties bereikt:

Prestaties: AgenticSZZ bereikt F1-scores variërend van 0,47 tot 0,79 over de datasets. Het presteert beter dan de vorige state-of-the-art (LLM4SZZ) met 16,0% tot 34,2% in F1-score.
Statistische Significantie: Verbeteringen zijn statistisch significant (McNemar's test, $p < 0,001$ ) op drie van de vier dataset-splits. Zelfs de slechtst presterende run van AgenticSZZ presteert beter dan de beste run van LLM4SZZ.
Ablatiestudie:
- Zowel de TKG als de LLM-agent zijn wederzijds essentieel; TKG-only introduceert ruis zonder intelligente filtering, terwijl Agent-only wordt begrensd door de beperkte blame-zoekruimte.
- De combinatie van TKG-traversering en contextuitbreiding opent de "Voorouder"-categorie, wat een netto winst van 60 true positives over de datasets oplevert ten opzichte van LLM4SZZ.
- Contextuitbreiding wisselt ongeveer 48 "Blame" true positives in voor 106 extra "Voorouder" true positives, wat resulteert in een netto positieve winst op de meeste datasets.
LLM-gevoeligheid: Alleen modellen met 37B+ actieve parameters (DeepSeek-V3.2 en DeepSeek-V4-Pro) presteren consistent beter dan de simpele Blame-fallback-baseline. Kleinere modellen falen in het uitvoeren van voldoende multi-stap verificatie (door query_node en read_node_content-aanroepen over te slaan), wat effectief reduceert tot een minder betrouwbare heuristiek.
Architecturale Versterking: Een gecontroleerde vergelijking met DeepSeek-V4-Pro toont aan dat de TKG-architectuur de voordelen van sterkere LLM's versterkt. Het prestatieverschil tussen AgenticSZZ en LLM4SZZ breidt uit van 18,8% (met V3.2) naar 32,0% (met V4-Pro), terwijl de winsten van LLM4SZZ platlopen vanwege hun door blame-begrensde zoekruimte.

Betekenis en Claims

Het artikel claimt dat AgenticSZZ een nieuwe onderzoeksrichting opent voor temporeel en causaal redeneren in analyse van software-evolutie. Door BIC-identificatie te transformeren naar een graafzoekprobleem, overwint de aanpak de inherente recall-beperkingen van op git blame gebaseerde methoden.

De auteurs benadrukken dat de verbetering wordt gedreven door het TKG-gestuurde paradigma en niet louter door de keuze van een capabelere LLM. De TKG biedt een gestructureerde redeneerruimte die sterkere modellen in staat stelt effectief door complexe commitgeschiedenissen te navigeren, terwijl benaderingen die beperkt zijn tot lineaire blame-lijsten een prestatieplafond ondervinden, ongeacht de capaciteit van de onderliggende LLM. Het werk suggereert dat toekomstige vooruitgang in BIC-identificatie afhankelijk zal zijn van de integratie van gestructureerde zoekruimtes met agente redenering, mits de LLM voldoende capaciteit bezit om multi-stap verificatie uit te voeren.