Engenharia de loop no Jira

A maioria das equipes usa agentes de codificação de IA de forma interativa: enviar o prompt, aguardar a saída, revisar e repetir. A engenharia de loop move essa execução para agentes de nuvem em plano de fundo que rodam de forma assíncrona. Em vez de ocupar o terminal de quem desenvolve, o agente lida de forma independente com as tarefas operacionais.
Os agentes em segundo plano só funcionam quando o estado persiste entre as execuções. Como os modelos não têm memória entre as sessões, o loop precisa de um sistema de registro para acompanhar o progresso, avaliar as verificações de aprovação/reprovação e repassar o ticket. Esse estado pode ser o ticket que o agente já produziu. Isso faz com que a verdadeira pergunta seja menos sobre o agente e mais sobre onde o ticket reside, o que aponta direto para o seu sistema de registro. No Jira, esse registro já existe.
O que este guia aborda:
O que é engenharia de loop e como ela difere da engenharia de prompt
As partes do loop do agente, desde encontrar um ticket até decidir o próximo passo
Como executar um loop de agente no Jira, onde seus tickets já estão
O que é engenharia de loop?
Comece pelo próprio loop. Um loop é o ciclo que um agente repete por conta própria, sendo executado até atingir uma meta ou um limite. A engenharia de loop é a prática de construir e controlar esse loop, seu acionador e suas condições de saída. Você define a meta e contrói o ciclo. Em seguida, o agente pega o ticket, age, verifica o resultado e decide o que fazer depois.
Todo loop de trabalho combina duas coisas. A primeira é um ciclo que repete os mesmos quatro passos: encontrar, agir, verificar e decidir. A segunda é um registro durável do que aconteceu, porque o modelo não guarda nada entre as execuções. Cada execução grava seu estado nesse registro, e a próxima execução o lê de volta como contexto. Isso significa que cada passagem começa informada pela anterior, em vez de começar do zero. Onde esse registro fica determina se um loop pode continuar de onde parou. Não importa como o loop comece, seja por uma nova execução sua ou por um acionamento agendado, o ciclo em si permanece o mesmo.
Engenharia de loop vs. engenharia de prompt
A engenharia de prompt e a engenharia de loop não são concorrentes. Elas atuam em níveis diferentes. A engenharia de prompt molda o que um agente faz em um único turno. A engenharia de loop molda o sistema que executa vários turnos em direção a um objetivo. Você ainda escreve bons prompts dentro de um loop, mas o loop decide quando executá-los, verifica os resultados e continua.
A diferença aparece em quem faz o ticket entre as interações. Com a engenharia de prompt, você está no comando. Você envia uma instrução, lê a resposta e decide o próximo passo por conta própria. Com a engenharia de loop, o sistema assume o comando. Ele mantém o agente em execução, avalia cada resultado e só envolve você quando precisa de uma decisão.
Engenharia de prompt | Engenharia de loop | |
|---|---|---|
O que você projeta | Uma única instrução | O ciclo que executa muitas instruções |
Quem julga o resultado | Você, a cada turno | O loop, depois você quando for importante |
melhor para | Tarefas pontuais e respostas rápidas | Ticket contínuo e repetível rumo a uma meta |
O que é necessário para o ticket | Um prompt claro | Um acionador, uma verificação e um local para registrar o estado |
O harness é o ambiente no qual um único agente é executado, enquanto o loop é o ciclo que continua direcionando os agentes para o ticket. Para saber como fornecer as entradas corretas a um único agente, consulte a engenharia de contexto.
Quais são as partes de um loop de agente?
1. Descoberta: como um loop é acionado
Todo loop precisa de um acionador. O mais simples é uma pessoa executar o agente novamente até que o ticket seja concluído. Acionadores mais inteligentes removem essa dependência, como uma programação, um evento ou uma fila de itens abertos que inicia cada execução para que o loop continue funcionando sem você seguir.
2. Ação: o agente executa o ticket que está no seu escopo.
O agente executa a etapa que tem permissão para assumir, e nada além disso. O escopo é o que torna um loop seguro para ser executado sem supervisão.
3. Verificação: o loop avalia sua própria saída
O loop verifica sua própria saída antes de continuar, geralmente executando os testes ou o build. Se a verificação falhar, o loop tenta novamente ou para em vez de avançar. Um loop sem essa etapa produz mais saída, não uma saída melhor.
4. Registrar: o loop anota o que aconteceu
Após cada execução, o loop grava seu estado em um local durável: o que foi feito, o que falta fazer e o que falhou. É nessa parte que a maioria dos loops criados internamente erra, e é por isso que um sistema de registro compartilhado é importante.
5. Decida o próximo passo: iterar, concluir ou repassar
O loop lê seu próprio registro e roteia o ticket. Ele é executado novamente, fecha o ticket ou o transfere para uma pessoa quando há incerteza ou foge do escopo. O escalonamento é a porta de saída, e os padrões de human-in-the-loop abordam como essa transferência funciona.
Como o Jira executa e memoriza um loop de agente
Um loop precisa de um registro durável e de um lugar para servir de acionador, e ambos já existem onde sua equipe executa o ticket. No Jira, o ticket é o registro que sobrevive entre as execuções, e as regras de automação são o acionador que transforma uma Tarefa em um loop. Você reutiliza as regras de acesso e o histórico em que sua equipe já confia, em vez de manter um sistema separado.
Cada parte do ciclo corresponde a algo que o Jira já faz.
Parte do loop | Como o Jira faz isso |
|---|---|
Discovery | Uma regra de automação encontra trabalho aberto em um cronograma ou evento |
Ação | Você atribui o ticket a um agente de codificação, como o Jira Coding Agent. |
Cheque | Os testes passam ou o build é bem-sucedido |
Transferência | O agente abre um pull request |
Registro | O ticket e a visualização das sessões do agente na página Para você do Jira contêm o que aconteceu. |
Decidir a seguir | A Automação encaminha o resultado ou transfere para uma pessoa |
Duas coisas unem tudo isso. O ticket mantém o estado, e o Teamwork Graph o transforma no contexto que a próxima execução lê. Ele conecta o item ao código, às decisões e aos documentos ao seu redor. Quando uma execução precisa de uma pessoa, essa transferência segue padrões de human-in-the-loop. O próprio registro é a vantagem em relação a um script caseiro, pois é compartilhado, tem permissões e conta com suporte de auditoria. Pessoas e agentes trabalham a partir de um único sistema de registro, não dois.
Como fazer o build do seu primeiro loop de agente no Jira
Você não precisa de um redesign para começar. Escolha uma Tarefa recorrente, dê a ela um acionador e um lugar para registrar seu estado, e execute o ciclo em um ticket reversível primeiro. Aqui está a ordem que funciona.
1. Escolha uma tarefa recorrente e de baixo risco
Escolha tarefas previsíveis em que os critérios sejam objetivos e as alterações fáceis de verificar, como atualizar dependências, corrigir vulnerabilidades de segurança ou resolver violações de acessibilidade. Deixar que um agente em plano de fundo assuma a manutenção de rotina libera a equipe para focar em tickets de função complexos.
2. Configure o acionador
Crie uma regra de automação que encontre esse ticket em um cronograma ou evento. A regra é o que inicia cada execução, para que o loop comece sem que você precise seguir.
3. Atribua o ticket a um agente de codificação
Atribua o ticket a um agente de codificação, como o Jira Coding Agent. O agente atua como uma identidade conhecida, portanto, só acessa o que essa identidade tem permissão.
4. Adicione a verificação
Dê ao agente um teste objetivo — como uma suíte de testes, linter ou comando de build — para executar e se corrigir em seu próprio ambiente. Quando ele abre um pull request, a IC verifica o código, e a Automação do Jira encaminha o resultado ou escala as falhas.
5. Confirme o registro e depois amplie
Verifique o ticket e a visualização de sessões do agente para confirmar se a execução foi capturada. Assim que estiver tudo certo, adicione o próximo tipo de Tarefa, ainda em um ticket reversível. O resultado é um ciclo que encontra e conclui o ticket de rotina por conta própria, com os casos arriscados direcionados a você.
Perguntas frequentes sobre engenharia de contexto
O que é engenharia de loop para agentes de IA?
É a prática de projetar o ciclo automatizado que um agente executa por conta própria, para que ele trabalhe em direção a um objetivo sem que uma pessoa precise dar comandos a cada etapa.
Qual é a diferença entre a engenharia de loop e o human-in-the-loop?
A engenharia de loop projeta o ciclo que o agente executa por conta própria. O human-in-the-loop projeta onde uma pessoa aprova, revisa ou assume o controle.
Quais são as partes de um loop de agente?
Descoberta, ação, uma verificação, um registro e uma etapa de decisão do próximo passo, além de um registro durável que mantém o estado de uma execução para a outra.
Como impedir que um loop de agente seja executado para sempre?
Defina um estado de meta e um orçamento antecipadamente e dê ao loop uma condição de parada para que ele saia em caso de sucesso ou ao atingir o limite.
Você pode executar loops de agente de IA no Jira?
Sim. As regras de automação acionam o loop, um agente de codificação executa o ticket com escopo definido, e o ticket mantém o estado que a próxima execução lê como contexto.