Agentes são úteis porque nos ajudam a automatizar o trabalho ao realizar ações no mundo real. Mas conseguir que agentes realizem trabalhos valiosos de forma confiável exige mais do que apenas um bom modelo: requer uma arquitetura cuidadosamente projetada e adequada a um conjunto de tarefas.
O algoritmo central do agente é simples: dar contexto ao LLM e deixá-lo chamar ferramentas em um loop até que a tarefa seja concluída. Este é o loop mais fundamental. Mas está longe de ser o único loop que impulsiona os agentes. @swyx escreveu recentemente um ótimo artigo sobre "loopcraft: a arte de empilhar loops", a ideia de que você pode empilhar e estender loops para construir agentes mais eficazes.
Veja como pensamos sobre essa pilha e como instrumentar cada nível com os primitivos do LangChain.
Loop 1: O Agente
Em sua essência, um agente é apenas um modelo chamando ferramentas em um loop até que uma tarefa seja concluída.
Isso é o que o create_agent do LangChain oferece. Escolha qualquer modelo, conecte ferramentas e você terá um loop de agente funcional. As ferramentas são o que dão ao agente o poder de agir no mundo real.
Pegue nosso agente de documentação interna como exemplo (que usaremos como exemplo motivador para o restante deste blog). No primeiro nível do loop, ele recebe uma solicitação de melhoria na documentação, o modelo planeja e rascunha as alterações, e usa ferramentas para clonar repositórios, ler arquivos, escrever documentação, abrir um pull request, etc.
Nível 2: Loop de Verificação
O loop do agente faz o trabalho, mas nem sempre produz resultados corretos ou consistentes na primeira tentativa. Quando a consistência é importante, muitas vezes é útil envolvê-lo em um loop de verificação que confere a saída e envia feedback de volta ao modelo quando algo está aquém.
O loop de verificação adiciona um avaliador: algo que verifica a saída do agente em relação a uma rubrica e, se falhar, envia o resultado de volta com feedback. Os avaliadores podem ser determinísticos ou agentivos (LLM como juiz é um exemplo clássico aqui).
O RubricMiddleware lida com esse padrão, ou você pode configurá-lo com um hook after_agent no create_agent.
Para o exemplo do nosso escritor de documentação, o avaliador executa testes após cada tentativa, verificando se todos os links funcionam, se todos os testes de CI passam e se o diff está limitado ao que foi realmente solicitado. Nenhuma revisão manual é necessária para capturar esses tipos de erro.
Uma desvantagem: adicionar verificação aumenta a latência e o custo por execução. Vale a pena quando a qualidade é mais importante que a velocidade, que é a maioria dos casos de uso em produção.
Nível 3: Loop Orientado a Eventos
Uma das partes mais importantes do desenvolvimento de agentes é a camada de integrações: conectar seu agente ao seu ecossistema para que ele possa ser executado em segundo plano.
O loop orientado a eventos conecta seu agente ao seu ecossistema. Um evento é disparado — um novo documento chega, um agendamento é acionado, um webhook é recebido — e o agente é executado. O agente não é algo que você invoca manualmente; é um componente sendo executado continuamente dentro de um sistema maior.
O LangSmith Deployment oferece suporte à infraestrutura de gatilhos, incluindo suporte para agendamentos cron e webhooks. Um exemplo popular de crons em ação são os "heartbeats" no openclaw, que transformam seu agente em um assistente proativo e sempre ativo.
Nosso agente de documentação é alimentado pelo Fleet, nosso construtor de agentes sem código. Os canais e agendamentos do Fleet lidam com gatilhos orientados a eventos e estilo cron. Usamos um canal para disparar o agente de documentação sempre que uma mensagem é enviada em nosso canal do Slack #docs-plz.
Nível 4: Loop de Subida de Encosta
Os três primeiros loops automatizam o trabalho. O quarto (e, sem dúvida, o mais importante) automatiza a melhoria!
Cada execução de um agente produz um trace: um registro do que o modelo fez, as ferramentas que chamou, o feedback do avaliador, etc. Esses traces contêm sinais de alto valor sobre o que está funcionando e o que não está. O loop de subida de encosta executa um agente de análise sobre esses traces e usa as descobertas para reescrever a arquitetura com uma configuração melhorada. Isso pode incluir ajustes no prompt/ferramentas ou ajustes no avaliador.
No LangSmith, você pode usar o Engine, nosso agente de análise de traces, para instrumentar este quarto loop.
Finalizando a analogia do agente de documentação, executamos o Engine sobre os traces do agente de documentação para detectar quaisquer problemas. Quando vários traces sinalizam um problema potencial, um issue é aberto solicitando alterações no prompt ou ferramenta ofensora.
O movimento chave aqui é que a seta de retorno não apenas volta ao topo — ela alcança o interior e atualiza o loop do agente diretamente. Cada ciclo do loop externo torna os loops internos mais eficazes.
Olhando para o futuro:
a configuração de prompts e ferramentas são as coisas mais simples de melhorar, mas não são as únicas opções. Para equipes que executam modelos de peso aberto, o loop de subida de encosta pode alimentar o ajuste fino por RL, usando resultados de traces ou avaliações como sinal de treinamento para melhorar o próprio modelo. Contexto auxiliar como memória e habilidades recuperadas pode ser melhorado da mesma forma. O loop é o padrão; o que ele otimiza depende de você.
Supervisão e Expertise Humana
Automação não significa remover os humanos do loop. Em todos os níveis, existem pontos naturais onde a supervisão humana agrega valor. Um avaliador automatizado pode verificar se os links funcionam; é preciso um humano para perceber que o enquadramento está errado para o público. Esse tipo de julgamento, conquistado através de contexto, experiência e bom gosto, é exatamente onde a revisão humana mostra seu valor.
Alguma expertise deve ser codificada nos próprios prompts/ferramentas, mas para ações sensíveis, a revisão humana ao vivo é essencial (pense em transações financeiras, operações de banco de dados, etc). O LangChain torna simples instrumentar esses pontos de contato em cada loop:
- No loop do agente, exija entrada humana antes de ações/chamadas de ferramentas sensíveis.
- No loop de verificação, um humano pode atuar como avaliador para fluxos de trabalho sensíveis.
- No loop da aplicação, um humano pode aprovar saídas antes de serem retornadas ao usuário final.
- No loop de subida de encosta, as melhorias na arquitetura podem passar por revisão humana antes da implantação.
Todos os frameworks de código aberto do LangChain tornam a adição de um "humano no loop" um primitivo de primeira classe.
Juntando Tudo
Caso você prefira uma visão mais tabular, aqui está como esses quatro loops se empilham:
Loop | O que faz | Impacto | Primitivo LangChain |
|---|---|---|---|
1: Loop do Agente (modelo + ferramentas) | O modelo chama ferramentas repetidamente até que uma tarefa seja concluída | Automatizar trabalho | create_agent, qualquer modelo suportado pelo LangChain |
2: Loop de Verificação (agente + avaliador) | O agente é executado, a saída é avaliada contra uma rubrica, repetida com feedback se falhar | Garantir qualidade | RubricMiddleware |
3: Loop de Eventos (verificação + sistema) | Eventos acionam execuções do agente que atualizam um sistema real | Trabalhar em escala | LangSmith Deployment / Canais do Fleet |
4: Loop de Subida de Encosta (sistema + engine) | Traces de produção alimentam um agente de análise que melhora a configuração da arquitetura | Melhoria contínua | LangSmith Engine |
Isto é o que a engenharia de loops — ou loopcraft, como @swyx chama — realmente parece na prática. Líderes de IA como Steipete, Boris e Andrej chegaram todos à mesma conclusão: o potencial dos agentes está nos loops que você constrói ao redor deles.
Temos pensado nos loops 1 e 2 por um tempo. Mas o foco deve mudar para os loops 3 e 4, onde o valor se acumula ao incorporar agentes em seu ecossistema que melhoram continuamente em resposta aos seus critérios.
Satya define os stakes organizacionais: empresas que constroem ciclos de aprendizado cedo, onde o julgamento humano e o capital de token se combinam, construirão uma vantagem difícil de replicar.
Agradecimentos
Obrigado a @Vtrivedy10, @masondrxy, @hwchase17 e @huntlovell pela revisão cuidadosa.
