Engenharia de loops (loop engineering): como projetar agentes de IA que trabalham até terminar

Pedir algo para uma IA uma vez e aceitar a resposta é como contratar alguém e proibir que essa pessoa revise o próprio trabalho. Profissionais bons fazem, conferem, corrigem e só entregam quando está certo. Os agentes de IA que realmente funcionam em empresas fazem o mesmo, e o nome da disciplina que projeta esse comportamento é engenharia de loops.

O que é engenharia de loops

É o desenho de sistemas em que um agente de IA repete um ciclo até cumprir uma meta:

1. Agir: executar um passo, como consultar um sistema, escrever um texto ou lançar um registro.
2. Observar: ler o resultado real da ação, como o retorno de uma API, uma mensagem de erro ou a saída de um teste.
3. Corrigir: comparar com o objetivo, ajustar o plano e decidir o próximo passo.

O ciclo termina quando o objetivo é atingido, quando um limite é alcançado ou quando o agente precisa de uma pessoa.

Se o conceito de agente ainda for novo, comece por o que são agentes de IA e a diferença entre chatbot e agente.

Por que o loop importa mais que o modelo

Modelos de linguagem erram. A diferença entre um agente frágil e um confiável raramente é o modelo escolhido; é se o sistema percebe o erro e se recupera. Um loop bem projetado:

• Transforma uma taxa de acerto razoável em entregas consistentes, porque falhas são detectadas e refeitas.
• Usa informação real (o sistema respondeu, o teste passou) em vez da "impressão" do modelo.
• Permite tarefas longas, com dezenas de passos, sem que um erro no início contamine o fim.

Os 7 componentes de um loop bem projetado

1. Objetivo verificável

"Melhore o relatório" não é objetivo; "gere o relatório com os 12 indicadores, todos batendo com o ERP" é. Se não dá para verificar, o agente não sabe quando parar.

2. Ferramentas

As ações que o agente pode executar: consultar CRM, ler documentos, rodar testes, enviar e-mail. Ferramentas bem definidas, com nomes claros e escopo mínimo, reduzem erros. Protocolos como o MCP padronizam essa camada.

3. Observação fiel

O agente precisa ver o resultado real de cada ação, inclusive mensagens de erro completas. Esconder falhas do agente é garantir que ele repita o erro.

4. Verificador

É o coração do loop. Quanto mais objetivo, melhor:

• Verificação determinística: testes automatizados, validação de schema, soma que precisa bater, campo obrigatório preenchido.
• Verificação por outro modelo: um "revisor" com critérios explícitos avalia o trabalho do "executor".
• Verificação humana: para decisões com impacto financeiro, jurídico ou em clientes.

5. Memória e estado

O agente precisa saber o que já tentou, o que funcionou e o que falta. Em loops longos, o contexto cresce e degrada o desempenho; por isso bons loops resumem o progresso e guardam o estado fora da conversa (arquivos, banco de dados, checklist).

6. Critérios de parada e limites

• Número máximo de iterações.
• Orçamento de tokens, tempo e custo por tarefa.
• Detecção de repetição: a mesma ação falhando do mesmo jeito três vezes.
• Saída obrigatória: entregar o resultado parcial com um relatório ou escalar para uma pessoa.

7. Pontos de controle humano

Nem tudo deve ser autônomo. Defina quais ações exigem aprovação (pagamentos, exclusões, envios para clientes) e faça o agente preparar e pausar nesses pontos.

Como fica um loop na prática

Estrutura simplificada de um agente que concilia pagamentos recebidos com títulos em aberto:

objetivo  = "conciliar todos os pagamentos do extrato de hoje"
limites   = { iteracoes: 30, custo_max: orçamento_da_tarefa }
estado    = carregar_progresso()

enquanto não objetivo_atingido(estado):
    se estourou(limites) ou sem_progresso(estado):
        escalar_para_humano(estado); parar

    passo      = agente.planejar(objetivo, estado)
    resultado  = executar_ferramenta(passo)       # ERP, banco, planilha
    avaliacao  = verificar(resultado)             # valores batem? título existe?

    se avaliacao.exige_aprovacao:
        pedir_aprovacao(passo, resultado); aguardar

    estado = registrar(estado, passo, resultado, avaliacao)

entregar_relatorio(estado)

Repare que a maior parte do código não é "IA": é verificação, limites, registro e controle. É exatamente esse o trabalho da engenharia de loops.

Padrões de loop mais usados

Exemplos em empresas

• Financeiro: conciliar extratos até que todos os lançamentos estejam casados ou sinalizados para análise.
• Vendas: enriquecer uma lista de leads até que cada empresa tenha segmento, porte e contato validados.
• Operações: ler pedidos em PDF e lançar no ERP até que todos os itens batam com o catálogo.
• Desenvolvimento: corrigir um erro até que a suíte de testes passe, sem desabilitar testes.
• Gestão: montar o relatório mensal até que todos os números conferam com as fontes.

Os erros mais comuns

• Loop infinito: sem limite de iterações, o agente tenta para sempre e a conta chega. Veja quanto custa um agente de IA.
• "Trapacear" o verificador: se o critério é "os testes passam", o agente pode apagar o teste. Proteja o verificador e deixe explícito o que é proibido.
• Erro que se acumula: um dado errado no passo 2 vira premissa até o passo 20. Verifique cedo e com frequência.
• Contexto inchado: históricos longos fazem o agente esquecer o objetivo. Resuma e guarde estado fora da conversa.
• Autonomia demais cedo demais: comece com aprovação humana e amplie conforme os números mostram confiabilidade.
• Nenhuma observabilidade: sem registro de cada passo, é impossível entender por que o agente errou.

Métricas de um bom loop

• Taxa de conclusão: tarefas que atingem o objetivo sem intervenção.
• Iterações por tarefa: sobe quando instruções ou ferramentas estão ruins.
• Custo e tempo por tarefa concluída.
• Taxa de escalonamento: quantas vezes o agente precisou de uma pessoa, e por quê.
• Erros que passaram pelo verificador: a métrica mais importante para ajustar a verificação.

Como começar

1. Escolha um processo com resultado verificável (números que batem, campos completos, testes).
2. Escreva o critério de "pronto" antes de escrever qualquer instrução para a IA.
3. Construa o verificador primeiro; depois o agente.
4. Defina limites de iteração, custo e as ações que exigem aprovação.
5. Registre tudo e revise os primeiros 50 ciclos com a equipe.

O roteiro para escolher o processo certo está em como implementar IA na empresa.

Conclusão

O salto dos assistentes que respondem para os agentes que entregam não veio só de modelos melhores: veio de loops melhores. Objetivo claro, verificação objetiva, limites e humanos nos pontos certos transformam um modelo que às vezes erra em um sistema que conclui o trabalho. É assim que a Yggra projeta seus agentes de IA; agende um diagnóstico para descobrir quais processos da sua empresa podem rodar nesse formato.

Perguntas frequentes