RefAgent: A Multi-agent LLM-based Framework for Automatic Software Refactoring

Die Studie stellt RefAgent vor, ein Multi-Agenten-Framework auf Basis von Large Language Models, das durch spezialisierte Agenten für Planung, Ausführung und Testen Software-Refaktorierungen automatisiert und dabei im Vergleich zu Einzelagenten sowie traditionellen Tools signifikant höhere Erfolgsquoten bei der Code-Qualität und der Beseitigung von Code-Smells erzielt.

Das Wesentliche

Hier ist eine einfache Erklärung des Papers „RefAgent" auf Deutsch, verpackt in eine anschauliche Geschichte.

Das Problem: Der verstaubte Hausbau

Stell dir vor, du hast ein riesiges, altes Haus (ein Softwareprogramm), das du bewohnst. Im Laufe der Jahre haben viele verschiedene Leute darin gearbeitet. Manche haben Wände verschoben, ohne zu schauen, ob die Leitungen noch passen. Andere haben Möbel in den Weg gestellt oder Fenster zugemauert.

Das Haus steht noch, aber es ist unordentlich, schwer zu renovieren und wenn du versuchst, ein neues Zimmer hinzuzufügen, bricht vielleicht das ganze Dach zusammen. In der IT nennen wir das „technische Schulden" oder „Code-Smells" (Code-Gestank).

Früher mussten Menschen (Programmierer) dieses Chaos manuell aufräumen. Das ist mühsam, fehleranfällig und dauert ewig. Einfache Roboter (alte Software-Tools) konnten nur sehr einfache Dinge tun, wie z. B. eine Farbe ändern, aber sie verstanden den ganzen Kontext des Hauses nicht.

Die Lösung: RefAgent – Ein Team aus Spezialisten

Die Autoren dieses Papers haben eine neue Idee entwickelt: RefAgent.

Stell dir RefAgent nicht als einen einzelnen Super-Roboter vor, sondern als ein gut organisiertes Bauteam, bei dem jeder eine spezielle Aufgabe hat. Alle Mitglieder dieses Teams nutzen eine extrem intelligente KI (ein „Large Language Model" oder LLM), die wie ein genialer Architekt denkt, aber sie arbeiten zusammen, statt alle gleichzeitig zu reden.

Das Team besteht aus vier Hauptakteuren:

1. Der Planer (Context-Aware Planner):

   • Rolle: Der erfahrene Bauleiter.
   • Aufgabe: Er läuft durch das Haus, schaut sich die Pläne an und sagt: „Hier ist die Treppe zu schmal, und hier hängen die Leitungen falsch." Er erstellt einen genauen Plan, was geändert werden muss, bevor jemand einen Hammer schwingt. Er achtet darauf, dass die Änderungen mit dem Rest des Hauses harmonieren.

2. Der Umsetzer (Refactoring Generator):

   • Rolle: Der geschickte Handwerker.
   • Aufgabe: Er nimmt den Plan des Bauleiters und führt die Arbeiten aus. Er baut die Treppe um, zieht neue Leitungen. Aber er ist vorsichtig: Er fragt ständig nach, ob alles passt.

3. Der Bauleiter-Prüfer (Compiler Agent):

   • Rolle: Der Sicherheitsinspektor für die Struktur.
   • Aufgabe: Nach jeder Änderung prüft er: „Ist das Haus noch stabil? Stehen die Wände noch?" Wenn etwas wackelt (ein Fehler im Code), schickt er den Handwerker sofort zurück, um es zu reparieren.

4. Der Test-Prüfer (Tester Agent):

   • Rolle: Der Qualitätskontrolleur.
   • Aufgabe: Er stellt sicher, dass das Haus funktioniert. Wenn der Handwerker eine Tür umgebaut hat, prüft der Tester: „Kann man sie noch öffnen? Geht das Licht noch an?" Er nutzt sogar Roboter, die extra Test-Läufe simulieren (EvoSuite), um sicherzugehen, dass nichts kaputt geht.

Der geheime Trick: Der Kreislauf des Lernens

Das Besondere an RefAgent ist, dass es nicht einfach nur „einfach so" arbeitet. Es nutzt einen Feedback-Kreislauf.

Stell dir vor, der Handwerker baut eine Wand. Der Sicherheitsinspektor sagt: „Achtung, die Wand steht schief!" Der Handwerker korrigiert es. Der Qualitätskontrolleur sagt: „Okay, aber jetzt klemmt die Tür." Der Handwerker korrigiert es erneut.

Dieser Prozess läuft bis zu 20 Mal für jede Änderung. Das Team reflektiert über seine Fehler, lernt daraus und verbessert sich Schritt für Schritt, bis alles perfekt sitzt. Ein einzelner Roboter würde wahrscheinlich nach dem ersten Fehler aufgeben oder etwas Falsches bauen. Dieses Team gibt nicht auf.

Was haben sie herausgefunden?

Die Forscher haben RefAgent an acht echten, großen Software-Projekten getestet (wie bei einem echten Hausbau-Check). Die Ergebnisse waren beeindruckend:

• Sicherheit: Das Haus ist nach der Renovierung immer noch bewohnbar. 90 % der Tests bestanden (das Haus steht noch).
• Ordnung: Der „Code-Gestank" wurde um mehr als die Hälfte (52,5 %) reduziert. Das Haus ist jetzt viel aufgeräumter.
• Qualität: Dinge wie Wiederverwendbarkeit (man kann Räume leichter umbauen) haben sich um fast 9 % verbessert.
• Vergleich: Wenn man nur einen einzelnen Roboter (ein einfaches KI-Tool) benutzt, scheitern die meisten Versuche oder das Haus wird instabil. Das Team (RefAgent) ist deutlich besser.

Fazit

RefAgent ist wie ein autonomes, selbstkorrigierendes Bauteam aus KI-Experten. Es denkt voraus, arbeitet in Schichten, prüft ständig die Sicherheit und lernt aus Fehlern.

Es zeigt, dass die Zukunft der Software-Entwicklung nicht darin liegt, einen einzigen super-smarten Roboter zu haben, sondern ein Team aus spezialisierten Agenten, die zusammenarbeiten, komplexe Aufgaben zu lösen, die für einen einzelnen zu schwer wären. Es macht Software sauberer, sicherer und leichter zu warten – ganz ohne dass ein Mensch den ganzen Tag über den Code wischen muss.

Technische Zusammenfassung

Hier ist eine detaillierte technische Zusammenfassung des Papers „RefAgent: A Multi-agent LLM-based Framework for Automatic Software Refactoring" auf Deutsch.

1. Problemstellung

Software-Systeme werden mit der Zeit komplexer und schwerer zu warten. Refactoring (das Umstrukturieren von Code ohne Änderung des externen Verhaltens) ist eine Standardpraxis, um technische Schulden abzubauen und die Codequalität zu erhalten.

• Herausforderungen bestehender Ansätze:
  • Manuelles Refactoring: Ist fehleranfällig, zeitaufwendig und skaliert schlecht bei großen Änderungen.
  • Suchbasierte Ansätze (Search-Based): Formulieren Refactoring als Optimierungsproblem, ändern aber oft radikal das Design, bieten keine Garantien für die Erhaltung des Verhaltens und sind bei großen Projekten rechnerisch zu teuer.
  • Einzige LLMs (Large Language Models): Herkömmliche LLMs basieren oft auf statischen Prompts. Sie neigen zu Halluzinationen, haben Schwierigkeiten, den Kontext großer Codebasen zu verstehen, und können komplexe, mehrstufige Workflows (Planung, Kompilierung, Testen, Korrektur) nicht autonom bewältigen.

Das Ziel ist es, einen vollständig automatisierten Ansatz zu finden, der dynamisch auf Kontexte reagiert, komplexe Workflows koordiniert und dabei die Verhaltenskorrektheit (Behavior Preservation) garantiert.

2. Methodik: Das RefAgent-Framework

RefAgent ist ein Multi-Agenten-System, das spezialisierte LLM-Agenten nutzt, um den gesamten Refactoring-Prozess von der Planung bis zur Validierung autonom durchzuführen. Das Framework simuliert die sequenzielle Natur menschlicher Refactoring-Arbeit.

Das System besteht aus vier Hauptkomponenten (Agenten), die in einem iterativen Feedback-Loop (bis zu 20 Iterationen) arbeiten:

1. Context-Aware Planner Agent (Planer):

   • Aufgabe: Identifiziert Refactoring-Möglichkeiten und erstellt einen strukturierten Plan.
   • Mechanismus: Nutzt Tools wie jdeps zur Analyse von Abhängigkeiten und DesigniteJava zur Berechnung von Qualitätsmetriken (z. B. zyklomatische Komplexität, Kopplung).
   • Output: Ein detaillierter Refactoring-Plan (JSON), der spezifische Codebereiche und Anweisungen für die nachfolgenden Agenten enthält.

2. Refactoring Generator Agent (Generator):

   • Aufgabe: Setzt den Plan des Planners um und generiert den refaktorisierten Java-Code.
   • Mechanismus: Erhält den Originalcode, den Plan und Kontextinformationen (abhängige Klassen). Er passt den Prompt dynamisch an, falls Fehler von Compiler- oder Tester-Agenten gemeldet werden, behält aber den ursprünglichen Plan als Leitprinzip bei.

3. Compiler Agent (Kompilierer):

   • Aufgabe: Validiert die syntaktische Korrektheit des generierten Codes.
   • Mechanismus: Führt den Code mit dem Maven Compiler aus. Bei Fehlern analysiert er die Fehlermeldungen, fasst sie zusammen und sendet sie an den Generator-Agenten zur Korrektur. Dieser Loop läuft bis zu 20 Mal.

4. Tester Agent (Tester):

   • Aufgabe: Gewährleistet die Verhaltenserhaltung (Behavior Preservation).
   • Mechanismus:
     • Sucht nach existierenden Entwickler-Tests mittels jdeps.
     • Generiert zusätzliche Regressionstests mit EvoSuite (für maximale Codeabdeckung), falls keine Entwickler-Tests vorhanden sind.
     • Führt Tests mit Maven Test aus. Bei Fehlern wird der Generator-Agent zur Korrektur aufgefordert.
     • Wenn nach 20 Iterationen Tests fehlschlagen, wird die Änderung verworfen und der ursprüngliche Code beibehalten.

Datensatz: Die Evaluation erfolgte an 8 Open-Source-Java-Projekten (z. B. JClouds, Apache Accumulo, SkyWalking). Es wurden drei LLM-Modelle getestet: GPT-4o, StarCoder2-15B und DeepSeekCoder-33B.

3. Wichtige Beiträge

• Erster Multi-Agenten-Ansatz für End-to-End-Refactoring: RefAgent ist das erste Framework, das spezialisierte Agenten nutzt, um Planung, Transformation, Kompilierung und Testen in einem autonomen Workflow zu vereinen.
• Kontextbewusstsein und Werkzeugnutzung: Im Gegensatz zu statischen Prompts nutzt RefAgent dynamisch externe Tools (Dependency Analysis, Code Smell Detection, Test-Generierung), um den Kontext zu erweitern und Fehler zu beheben.
• Iterative Selbstverbesserung: Durch den Feedback-Loop (Compiler/Tester -> Generator) kann das System Fehler erkennen und Korrekturen vornehmen, was die Erfolgsrate deutlich erhöht.
• Umfassende Evaluation: Der Ansatz wird nicht nur gegen menschliche Entwickler, sondern auch gegen Such-basierte Tools (RefGen) und Single-Agent-Ansätze verglichen.

4. Ergebnisse

Die Evaluation ergab folgende zentrale Metriken (Mediane über alle Projekte und Modelle):

• Qualitätsverbesserung:
  • Code Smells: Reduktion um 52,5 % (Median).
  • Qualitätsattribute (QMOOD): Verbesserung der Wiederverwendbarkeit (Reusability) um 8,6 %.
• Zuverlässigkeit:
  • Unit-Test-Pass-Rate: 90 % (Median). Dies zeigt, dass das Verhalten des Codes erhalten bleibt.
  • Kompilierungs-Pass-Rate: 87–88 %.
• Vergleich mit Baselines:
  • Gegenüber Single-Agent: RefAgent verbessert die Unit-Test-Pass-Rate um 64,7 % und die Kompilierungsrate um 40,1 % im Vergleich zu einem einzelnen LLM ohne Multi-Agenten-Orchestrierung.
  • Gegenüber Entwicklern: RefAgent identifiziert Refactoring-Möglichkeiten mit einer F1-Score von 79,15 % (im Vergleich zu menschlichen Entwicklern).
  • Gegenüber Such-basierten Tools (RefGen): F1-Score von 72,7 %.
• Ablationsstudie:
  • Die Entfernung des Kontext-Retrievals führte zu einem signifikanten Leistungsabfall, was die Wichtigkeit von Abhängigkeitsanalysen unterstreicht.
  • Die iterative Verfeinerung (bis zu 20 Durchläufe) war entscheidend, um die Pass-Raten zu stabilisieren und zu maximieren.

5. Bedeutung und Ausblick

RefAgent demonstriert, dass Multi-Agenten-Architekturen die Grenzen aktueller Single-LLM-Ansätze im Bereich Software-Engineering überwinden können.

• Robustheit: Durch die Aufteilung der Aufgaben (Planung vs. Ausführung vs. Validierung) werden Halluzinationen reduziert und die Fehlerkorrektur automatisiert.
• Praktische Anwendbarkeit: Das System kann große Codebasen autonom bearbeiten, ohne dass Entwickler manuell in jeden Schritt eingreifen müssen, während die Funktionalität durch automatische Tests gesichert wird.
• Zukunft: Die Autoren schlagen vor, zukünftig Mechanismen für „Human-in-the-Loop" zu integrieren, um bei kritischen Entscheidungen menschliches Feedback einzuholen, und die Balance zwischen Qualitätsverbesserung und Design-Verständlichkeit weiter zu erforschen.

Zusammenfassend bietet RefAgent einen vielversprechenden Weg, um Software-Refactoring von einem manuellen, fehleranfälligen Prozess in einen zuverlässigen, automatisierten Workflow zu verwandeln, der die Codequalität signifikant steigert.