Agente auto-construído: uma experiência baseada em LangChain4j

Pontos-chave

• Os pesquisadores permitiram que um assistente de código LLM projetasse e implementasse por conta própria um sistema de codificação multiagente, utilizando a documentação e a API do LangChain4j.

• Este agente de codificação autoconstruído corrigiu bugs reais, passou nos testes e expôs seu próprio fluxo de execução por meio do LangChain4j.

• Ao comparar dois modos de agente, o modo de fluxo de trabalho mais rigoroso eliminou a sobrecarga de coordenação causada pelo LLM, sendo 3 vezes mais rápido que o modo supervisor.

• Por meio da nova interface MonitoredAgent, é possível obter relatórios de chamadas do agente e a topologia do sistema com clareza.

• No experimento, o mesmo design de agente falhou em modelos antigos e baratos ao entrar em loops de chamada de ferramentas, enquanto os modelos novos concluíram a tarefa com sucesso.

Visão geral do experimento

Os pesquisadores realizaram um meta-experimento: entregaram a documentação do LangChain4j ao assistente de código e pediram que ele construísse uma "versão de si mesmo" com base nela. Especificamente, queriam projetar um sistema multiagente capaz de escrever, testar e depurar código como um engenheiro humano.

O fato de o LLM conseguir construir sua própria versão com base na documentação demonstra que a API do LangChain4j é clara e fácil de usar, e que o framework fornece capacidade de orquestração suficiente para que o sistema gerado execute tarefas reais de depuração de ponta a ponta.

O projeto também ajudou a testar as novas ferramentas de monitoramento do LangChain4j — ao deixar uma IA construir outra IA, é necessário enxergar o que está acontecendo internamente. Este artigo detalha o processo experimental e os resultados; o código do projeto pode ser obtido neste repositório.

"Codificando por atmosfera" um sistema de agentes

Para que o assistente de código construísse o primeiro agente codificador, os pesquisadores escreveram o seguinte prompt:

Aprenda a documentação e o código-fonte do framework de agentes LangChain4j e, com base neles, projete um agente codificador que seja um clone de você mesmo.

Após alguns minutos de reflexão, o assistente decidiu usar o padrão de supervisor do LangChain4j e propôs a arquitetura 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;
    }
}

O assistente também projetou e desenvolveu quatro subagentes, juntamente com suas mensagens de sistema e de usuário: o agente explorador explora o código existente, o agente planejador elabora um plano de ação, o agente implementador escreve o código conforme o plano, e o agente executor compila e executa o código. Cada subagente foi equipado com ferramentas adequadas: navegador de sistema de arquivos, editor de código, executor de código, etc.

O resultado da primeira iteração foi impressionante. Na realidade, assistentes de código "profissionais" geralmente seguem um padrão semelhante: executar as quatro etapas de exploração, planejamento, implementação e execução, e orquestrar no modo supervisor — o que corresponde à implementação gerada no experimento.

O fato de o assistente de código conseguir projetar e implementar tal sistema indica que ele possui certo conhecimento sobre seu próprio funcionamento interno e consegue traduzir esse entendimento em um design concreto de sistema de agentes.

Colocando o agente codificador para trabalharPara testar o codificador de agente projetado, os pesquisadores o fizeram escrever algum código com bugs e, em seguida, usaram o sistema recém-criado para corrigi-lo. O assistente gerou uma classe Calculator com quatro métodos com pequenos bugs:

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;
    }
}

Em seguida, gerou um teste que clonou a pasta contendo Calculator para um diretório temporário e executou o 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);
}

Ao executar o código, foi usado o modelo gpt-4o da OpenAI, pois é o modelo padrão do LangChain4j e suporta chamadas de ferramentas. No entanto, o resultado não foi bom; após alguns minutos, ocorreu um erro:

dev.langchain4j.agentic.agent.AgentInvocationException: Failed to invoke agent method: public abstract...

Comparação de padrões: Supervisor vs. Workflow

Como o padrão supervisor exige que o LLM tome decisões antes e depois de cada chamada de subagente, isso gera uma sobrecarga significativa de coordenação. Os pesquisadores optaram por experimentar o padrão de workflow mais rigoroso, que organiza os agentes em uma sequência fixa, chamando o LLM apenas quando necessário.

O padrão de workflow foi 3 vezes mais rápido que o padrão supervisor, pois eliminou a maior parte das trocas de contexto entre LLMs. Os dados experimentais mostraram que o padrão supervisor exigiu 7 chamadas de LLM para concluir a correção, enquanto o padrão de workflow precisou apenas de 2.

Impacto da escolha do modelo

O experimento também testou um modelo mais barato (como gpt-4o-mini), que ficou preso em um loop de chamadas de ferramentas, sem conseguir concluir a tarefa. Já o uso do modelo mais recente gpt-5-mini corrigiu todos os bugs com sucesso. Isso mostra que a qualidade do modelo é crucial para a confiabilidade do sistema de agente.

Monitoramento de chamadas de agente

A interface MonitoredAgent, recentemente introduzida no LangChain4j, pode gerar relatórios de chamadas de agentes, mostrando a entrada, saída, tempo gasto, etc., de cada chamada. Os pesquisadores usaram essa interface para analisar a topologia do sistema e o fluxo de trabalho.

Resumo

Este experimento demonstra uma capacidade interessante de metaprogramação: LLMs podem usar a documentação de frameworks existentes para construir sistemas de agentes autocorretivos. O padrão de workflow é mais eficiente que o padrão supervisor, e a escolha do modelo determina diretamente o sucesso ou fracasso do sistema. O LangChain4j oferece APIs e ferramentas de monitoramento suficientes para dar suporte a esse tipo de experimento.