Wichtige Erkenntnisse
Forscher ließen den LLM-Code-Assistenten mithilfe der LangChain4j-Dokumentation und API ein Multi-Agenten-Codierungssystem selbst entwerfen und implementieren.
Dieser selbst entwickelte Codierungs-Agent hat erfolgreich echte Fehler behoben, Tests bestanden und seinen eigenen Ausführungsablauf über LangChain4j offengelegt.
Im Vergleich zweier Agentenmodi zeigte sich, dass der strengere Workflow-Modus durch Eliminierung von durch LLM verursachtem Koordinationsaufwand dreimal schneller war als der Supervisor-Modus.
Über die neu eingeführte MonitoredAgent-Schnittstelle können Agentenaufrufberichte und Systemtopologie klar abgerufen werden.
Im Experiment scheiterte das gleiche Agentendesign auf älteren, günstigeren Modellen in einer Tool-Call-Schleife, während das neuere Modell die Aufgabe erfolgreich abschloss.
Experimentübersicht
Die Forscher führten ein Meta-Experiment durch: Sie gaben dem Code-Assistenten die LangChain4j-Dokumentation und baten ihn, auf Basis der Dokumentation eine „eigene Version" zu erstellen. Konkret sollte ein Multi-Agenten-System entworfen werden, das wie ein menschlicher Ingenieur Code schreiben, testen und debuggen kann.
Dass das LLM in der Lage war, auf Basis der Dokumentation eine eigene Version zu erstellen, zeigt sowohl, dass die LangChain4j-API klar und benutzerfreundlich ist, als auch, dass das Framework ausreichende Orchestrierungsfähigkeiten bietet, sodass das generierte System reale Debugging-Aufgaben Ende-zu-Ende ausführen kann.
Das Projekt half auch dabei, die neuen Überwachungswerkzeuge von LangChain4j zu testen – wenn man eine KI eine andere KI bauen lässt, muss man sehen können, was im Inneren vor sich geht. Dieser Artikel beschreibt detailliert den Versuchsablauf und die Ergebnisse. Der zugehörige Projektcode ist in diesem Repository verfügbar.
„Atmosphärisches Codieren“ eines Agentensystems
Um den Code-Assistenten den ersten Agenten-Codierer bauen zu lassen, verfassten die Forscher den folgenden Prompt:
Lerne die Dokumentation und den Quellcode des LangChain4j-Agenten-Frameworks und entwirf darauf basierend einen Agenten-Codierer, der eine Kopie deiner selbst ist.
Nach einigen Minuten Überlegung entschied sich der Assistent für das Supervisor-Pattern von LangChain4j und schlug die folgende Anfangsarchitektur vor:
public interface SupervisorCoderSystem {
@SupervisorAgent(description = """
一个多智能体编码助手，可以探索代码库、规划实现、编写/编辑代码、运行构建/测试。
它编排专门的子智能体来完成编码请求。
""", subAgents = {
ExplorerAgent.class,
PlannerAgent.class,
ImplementerAgent.class,
ExecutorAgent.class
})
@Override
String code(@K(UserRequest.class) String request,
@K(WorkingDirectory.class) String workingDirectory);
@SupervisorRequest
static String request(@K(UserRequest.class) String userRequest,
@K(WorkingDirectory.class) String workingDirectory) {
return "将'" + workingDirectory + "'作为工作目录，完成以下用户请求：" + userRequest;
}
}Der Assistent entwarf und entwickelte außerdem vier Sub-Agenten sowie deren System- und Benutzernachrichten: Der Erkundungs-Agent durchsucht vorhandenen Code, der Planungs-Agent erstellt einen Aktionsplan, der Implementierungs-Agent schreibt den Code gemäß dem Plan und der Ausführungs-Agent kompiliert und führt den Code aus. Jeder Sub-Agent wurde mit passenden Werkzeugen ausgestattet: Dateisystem-Browser, Code-Editor, Code-Ausführer usw.
Das Ergebnis der ersten Iteration war beeindruckend. In der Realität folgen „professionelle“ Code-Assistenten normalerweise einem ähnlichen Muster: Sie führen die vier Schritte Erkundung, Planung, Implementierung und Ausführung durch und orchestrieren sie auf Supervisor-Art – was mit der im Experiment generierten Implementierung übereinstimmt.
Dass der Code-Assistent in der Lage war, ein solches System zu entwerfen und zu implementieren, zeigt, dass er ein gewisses Verständnis seiner eigenen internen Arbeitsweise hat und dieses Verständnis in ein konkretes Agentensystem-Design umsetzen kann.
Den Agenten-Codierer an die Arbeit setzenUm den entwickelten Agent-Coder zu testen, ließen die Forscher ihn fehlerhaften Code schreiben und dann mit dem neu erstellten System reparieren. Der Assistent generierte eine Calculator-Klasse, die vier Methoden mit subtilen Fehlern enthielt:
public class Calculator {
public int sum(List<Integer> numbers) {
int total = 0;
for (int i = 0; i <= numbers.size(); i++) { // Bug: 应该是 i < numbers.size()
total += numbers.get(i);
}
return total;
}
public double average(List<Integer> numbers) {
if (numbers.isEmpty()) return 0;
return sum(numbers) / numbers.size(); // Bug: 整数除法，应转为double
}
public int max(List<Integer> numbers) {
if (numbers.isEmpty()) throw new IllegalArgumentException("列表不能为空");
int max = 0; // Bug: 如果所有数都是负数，会返回0
for (int n : numbers) {
if (n > max) max = n;
}
return max;
}
public long factorial(int n) {
if (n < 0) throw new IllegalArgumentException("n必须非负");
long result = 1;
for (int i = 1; i < n; i++) { // Bug: 应包含n，即 i <= n
result *= i;
}
return result;
}
}Anschließend wurde ein Test erstellt, bei dem der Ordner mit Calculator in ein temporäres Verzeichnis geklont und der LangChain4j-Agent-Coder ausgeführt wurde:
@Test
void workflow_should_fix_buggy_calculator() throws Exception {
var coder = CoderAgenticSystem.supervisorCoder(coderModel());
Path source = Path.of("src/test/resources/buggy-project");
Path workDir = Path.of("/tmp/buggy-calculator");
String result = coder.code(
"测试当前失败，因为Calculator.java存在Bug。请修复它。",
workDir.toAbsolutePath().toString());
assertThat(result).isNotBlank();
System.out.println("结果: " + result);
}Beim Ausführen des Codes wurde das Modell gpt-4o von OpenAI verwendet, da es das Standardmodell von LangChain4j ist und Tool-Aufrufe unterstützt. Das Ergebnis war jedoch nicht zufriedenstellend; nach wenigen Minuten trat ein Fehler auf:
dev.langchain4j.agentic.agent.AgentInvocationException: Failed to invoke agent method: public abstract...