Puntos clave
Los investigadores hicieron que un asistente de código LLM utilizara la documentación y API de LangChain4j para diseñar e implementar por sí mismo un sistema de codificación multiagente.
Este agente de codificación autoconstruido reparó con éxito errores reales, pasó las pruebas y expuso su propio flujo de ejecución a través de LangChain4j.
Al comparar dos modos de agente, se encontró que el modo de flujo de trabajo más estricto, al eliminar la sobrecarga de coordinación inducida por el LLM, era 3 veces más rápido que el modo supervisor.
A través de la interfaz MonitoredAgent recién introducida, se pueden obtener claramente informes de llamadas de agentes y la topología del sistema.
En los experimentos, el mismo diseño de agente cayó en un bucle de llamadas a herramientas fallido en modelos antiguos y económicos, mientras que los modelos nuevos completaron la tarea con éxito.
Resumen del experimento
Los investigadores llevaron a cabo un metaexperimento: entregaron la documentación de LangChain4j al asistente de código y le pidieron que construyera una "versión propia" basada en ella. Específicamente, deseaban diseñar un sistema multiagente que pudiera escribir, probar y depurar código como un ingeniero humano.
El hecho de que el LLM pudiera construir su propia versión a partir de la documentación demuestra tanto que la API de LangChain4j es lo suficientemente clara y fácil de usar, como que el marco proporciona la capacidad de orquestación suficiente para que el sistema generado pueda ejecutar tareas de depuración reales de principio a fin.
Este proyecto también ayudó a probar las nuevas herramientas de monitoreo de LangChain4j: cuando se hace que una IA construya otra IA, es necesario ver lo que sucede internamente. Este artículo detalla el proceso del experimento y sus resultados. El código del proyecto relacionado está disponible en este repositorio.
"Codificación atmosférica" de un sistema de agentes
Para que el asistente de código construyera el primer agente codificador, los investigadores escribieron el siguiente prompt:
Aprende la documentación y el código fuente del marco de agentes de LangChain4j, y basándote en él, diseña un agente codificador que sea un clon de ti mismo.
Después de unos minutos de reflexión, el asistente decidió usar el patrón supervisor (supervisor pattern) de LangChain4j y propuso la arquitectura inicial:
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;
}
}El asistente también diseñó y desarrolló cuatro subagentes, junto con sus mensajes de sistema y de usuario: el agente explorador exploraba el código existente, el agente planificador elaboraba un plan de acción, el agente implementador escribía el código según el plan, y el agente ejecutor compilaba y ejecutaba el código. Cada subagente estaba equipado con herramientas adecuadas: explorador del sistema de archivos, editor de código, ejecutor de código, etc.
Los resultados de la primera iteración fueron impresionantes. En la práctica, los asistentes de código "profesionales" suelen seguir un patrón similar: realizar exploración, planificación, implementación y ejecución, y orquestarlo de manera supervisora, lo cual coincide con la implementación generada en el experimento.
El hecho de que el asistente de código pudiera diseñar e implementar un sistema así indica que tiene cierto conocimiento de su propio funcionamiento interno y puede traducir esa comprensión en un diseño concreto de sistema de agentes.
Poniendo al agente codificador a trabajarPara probar el codificador de agente diseñado, los investigadores le pidieron que escribiera código con errores y luego usaran el sistema recién creado para corregirlos. El asistente generó una clase Calculator con cuatro métodos con errores sutiles:
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;
}
}Luego generó una prueba que clonaba la carpeta que contiene Calculator en un directorio temporal y ejecutaba el codificador de agente LangChain4j:
@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);
}Al ejecutar el código, se usó el modelo gpt-4o de OpenAI, ya que es el modelo predeterminado de LangChain4j y admite llamadas a herramientas. Sin embargo, los resultados no fueron ideales; después de unos minutos, apareció un error:
dev.langchain4j.agentic.agent.AgentInvocationException: Failed to invoke agent method: public abstract...