Governança

Como gerenciar tickets de agentes IA: critérios e revisão

· fundador da ETCSEC · atualizado a 17 de novembro de 2026 · 10 min
Ilustração de um robô com um gorro de trabalho azul, representando a revisão e aprovação de tickets.
A resposta curta

Se a pessoa que pede uma pull request a um agente de IA também é quem a aprova, essa aprovação não conta: as regras do GitHub dizem isso, e a Atipol aplica a mesma separação no seu fluxo de tickets. Cada ticket também exige critérios de aceitação escritos antes de o agente começar, além de um histórico de decisões registrado e consultável, para verificar a entrega contra um alvo fixado antecipadamente, e não avaliá-la depois dos fatos.

Os agentes entregam rápido, mas ninguém sabe dizer o que foi aprovado

Um CTO que atribui trabalho a agentes de IA costuma obter um resultado rapidamente. A pergunta mais difícil vem depois: o que exatamente foi pedido ao agente, quem verificou a entrega em relação a esse pedido, e quem deu o aval antes de ela ser integrada ou publicada. Sem um ticket que registre um alvo, um revisor e uma decisão, a velocidade cria um rastro que ninguém consegue seguir seis semanas depois, quando algo quebra.

Isso é uma lacuna de processo, não um problema de qualidade do modelo. Um agente rápido que trabalha a partir de um briefing não escrito e que recebe aval sem exame da mesma pessoa que o pediu produz um resultado tão rápido quanto um que trabalha a partir de um ticket claro. A diferença só aparece durante uma análise de incidente, uma auditoria, ou um desacordo sobre o que realmente havia sido prometido.

Esse custo tende a aparecer no pior momento possível: durante a análise de um incidente, uma revisão de segurança, ou uma auditoria de cliente, quando alguém pede o registro do que foi pedido ao agente e de quem aprovou, e a resposta honesta é que esse registro não existe. O NIST AI Risk Management Framework (AI RMF 1.0, publicado em 26 de janeiro de 2023) trata isso como uma questão de ciclo de vida, não uma tarefa pontual: o framework é destinado ao uso voluntário para ajudar as organizações a incorporar considerações de confiabilidade no design, no desenvolvimento, no uso e na avaliação de sistemas de IA, não apenas no resultado de uma única execução de agente.

Escrever os critérios de aceitação antes de o agente começar, não depois

Um critério de aceitação fixa, por escrito, o que uma entrega deve satisfazer antes de o agente ser lançado. Fixar a régua depois, quando o próprio resumo do agente sobre seu trabalho já está sobre a mesa, convida a avaliar o trabalho em relação ao que foi entregue, em vez de em relação ao que foi pedido. A regra aqui é clara: cada ticket exige critérios de aceitação escritos antes do lançamento do agente, e um critério que o agente não consiga cumprir deve surgir como um bloqueio antes da revisão, não durante ela.

Um segundo elemento acompanha os critérios: o escopo de arquivos. Reservar quais arquivos ou áreas um ticket pode tocar antes de o agente começar significa que dois tickets em andamento não podem reivindicar o mesmo escopo, de modo que uma sobreposição entre dois agentes é detectada na passagem de bastão em vez de descoberta no meio de um conflito de merge.

Na prática, isso significa que os critérios descrevem um resultado, não uma implementação: a qual arquivo ou módulo a mudança se aplica, o que o diff deve e não deve tocar, e a verificação específica que precisa passar. Um critério que o agente não consiga satisfazer deve surgir como um bloqueio e voltar para quem pediu antes mesmo de um revisor abrir a pull request, em vez de ser descoberto durante a revisão quando o trabalho já está feito.

O ciclo de vida de um ticket atribuído a um agente de IA

A própria documentação do GitHub para seu agente de código Copilot descreve uma versão concreta desse ciclo de vida. Assim que uma issue é atribuída ao agente, ele confirma a atribuição com uma reação, abre um branch dedicado e uma pull request em rascunho vinculada à issue, e inicia uma sessão de agente. Enquanto trabalha, ele envia commits e atualiza o corpo da pull request com mensagens de status. Quando termina, ele publica um evento de trabalho concluído e solicita uma revisão, que é o sinal de que o ticket passou de em andamento para aguardando uma decisão humana.

A mesma documentação acrescenta um detalhe de solução de problemas que importa operacionalmente: as sessões expiram após uma hora, e um agente travado é recuperado desatribuindo e reatribuindo a issue, ou republicando o comentário que a disparou, não esperando indefinidamente.

A documentação do GitHub descreve várias formas de colocar um ticket diante do agente: atribuir uma issue pela aba Issues da mesma forma que se atribuiria a um colega de equipe, pelo GitHub Projects ou GitHub Mobile, pela API GraphQL verificando que o agente de código aparece como ator sugerido e chamando depois uma mutation para atribuí-lo, ou pela linha de comando com o GitHub CLI. Qualquer que seja o caminho usado, o agente só recebe o título da issue, sua descrição, e os comentários que existiam no momento da atribuição; comentários adicionados depois não são vistos pelo agente, então instruções posteriores precisam ir na própria pull request, não de volta na issue original.

As etapas em resumo

As etapas abaixo generalizam entre as ferramentas que atribuem tickets a agentes de IA; os nomes dos sinais variam conforme a plataforma, mas a sequência não.

Nomear o sinal em cada etapa importa mais do que parece: uma equipe que só sabe que um agente está atribuído, sem nenhum sinal visível para confirmação, trabalho em andamento ou conclusão, acaba interrogando o agente em vez de ser avisada quando um ticket precisa de atenção.

EtapaSinal a observarQuem age em seguida
AtribuiçãoO agente confirma o ticketO agente começa a trabalhar dentro do seu escopo reservado
Em andamentoAtualizações de status e commits chegam ao branch do ticketA equipe pode comentar para redirecionar antes da conclusão
Trabalho concluídoO agente publica um evento de conclusãoUm revisor diferente de quem pediu é chamado para olhar
RevisãoO revisor confere o diff em relação aos critérios de aceitaçãoO revisor aprova ou devolve com um bloqueio
IntegraçãoAs verificações são executadas novamente no momento do mergeA decisão e o ticket ficam registrados no histórico

A pessoa que pediu o trabalho não deveria ser quem o aprova

A documentação do GitHub sobre a revisão de uma pull request criada pelo Copilot indica que, se um repositório exige aprovações de pull request, a aprovação da pessoa que atribuiu a issue ao agente não conta para esse número exigido; outro revisor precisa aprová-la antes do merge. O material de treinamento relacionado é mais direto sobre o porquê: o desenvolvedor que pediu ao Copilot para criar a pull request não pode aprová-la, o que preserva a regra de revisão obrigatória do repositório e mantém um controle independente no processo.

A Atipol aplica a mesma separação dentro do seu próprio fluxo de tickets: o agent lead do projeto revisa cada entrega antes de integrá-la, e essa revisão deve cobrir o diff real, não apenas o resumo que o agente dá do seu próprio trabalho. A integração então executa novamente as verificações do projeto em vez de depender apenas da revisão anterior, de modo que uma verificação que teria detectado um problema não seja pulada porque um humano já olhou o resumo.

Isso não é uma exceção específica do Copilot. A documentação geral do GitHub sobre revisões obrigatórias afirma claramente que autores de pull request não podem aprovar sua própria pull request, e que quando um conjunto de regras ou uma regra de proteção de branch exige revisões, uma aprovação precisa vir de alguém diferente do autor antes que a mudança possa ser integrada. A mesma página acrescenta dois detalhes específicos do Copilot: aprovações do próprio Copilot aparecem nesse painel de revisores mas não contam para o número exigido, e a pessoa que atribuiu a issue relacionada ao Copilot não pode aprovar a pull request que ele levantou, o que fecha a brecha de aprovar indiretamente através do agente.

A separação de funções, da atribuição à integração, em forma de diagrama:

SolicitanteAtribui o ticketAgenteAbre a pullrequestRevisorNão quem pediu,aprovaIntegraçãoRepete asverificaçõesSolicitanteAtribui o ticketAgenteAbre a pull requestRevisorNão quem pediu, aprovaIntegraçãoRepete as verificações

Transformar decisões de ticket em um histórico consultável depois

A aprovação de um revisor só é útil enquanto alguém se lembrar de que ela aconteceu. A Atipol mantém o histórico de cada ticket e das decisões de revisão que o validaram, produzindo um registro de quem pediu o quê e quem aprovou o quê antes de uma ação ser integrada. Cada chamada que um agente faz é vinculada a um agente, um ticket e um resultado, junto com qualquer aprovação concedida ou negada, o que transforma uma pergunta feita semanas depois em algo que um revisor pode pesquisar em vez de algo que um revisor precisa lembrar.

Um log criado depois de um incidente não ajuda a estabelecer o que foi realmente lido ou escrito durante ele; o registro precisa existir antes de o agente ser conectado, não depois de algo dar errado.

O raciocínio para construir esse log antes de conectar um agente, em vez de adicioná-lo depois que um problema surge, é o mesmo que o de escrever os critérios de aceitação antes do lançamento: um registro montado depois dos fatos pode descrever o que provavelmente aconteceu, mas não pode substituir uma linha que vincula uma chamada específica ao agente que a fez, ao ticket em que ele trabalhava, e à aprovação concedida ou negada naquele momento.

Quando o fluxo nativo de uma plataforma ainda é a escolha certa

Equipes cujo trabalho de agentes de IA acontece inteiramente dentro de um único repositório do GitHub, com um único agente de código e uma regra de proteção de branch já em vigor, obtêm a atribuição, a pull request em rascunho, o evento de trabalho concluído e a regra de aprovação independente diretamente do GitHub, como descrito acima, sem adicionar outro sistema. Esse fluxo nativo é suficiente quando os critérios de aceitação vivem na descrição da issue e as regras de revisão de uma única plataforma são as únicas que importam.

A lacuna aparece assim que uma equipe faz funcionar mais de um agente, ou mais de uma ferramenta, sobre um backlog compartilhado: o escopo de arquivos precisa ser reservado entre ferramentas, os critérios de aceitação precisam ser visíveis para qualquer agente que pegue o ticket em seguida, e o histórico de decisões precisa cobrir agentes que nunca tocam no fluxo de pull request do GitHub. Essa coordenação entre ferramentas e agentes é o que um sistema de tickets feito para agentes de IA, como o da Atipol, deve cobrir; veja como vários agentes compartilham tickets e escopo de arquivos sem colidir em atipol.ai/agentic-ai-blog/parallel-claude-code-agents.

A mesma documentação do GitHub lista, por conta própria, os limites desse fluxo nativo: o agente não está disponível em repositórios pessoais Enterprise Managed User, que por isso precisam migrar para um repositório pertencente a uma organização com runners hospedados pelo GitHub; uma sessão que parece travada geralmente pode ser recuperada desatribuindo e reatribuindo a issue em vez de esperar, já que as sessões expiram após uma hora; e as pull requests do agente permanecem em rascunho e não disparam o GitHub Actions automaticamente, então um humano ainda precisa aprovar e executar o workflow manualmente. Nada disso muda quando um segundo agente ou uma segunda ferramenta entra no mesmo backlog; só significa que o fluxo nativo nunca foi pensado para coordenar mais de um.

Incorporar essa prática a uma equipe

Nada disso exige novas ferramentas para começar: um ticket com critérios de aceitação escritos, um revisor que não pediu o trabalho, e um registro da decisão cobrem a maior parte da lacuna descrita acima. O framework de governança por trás dessa prática, incluindo uma política de uso de exemplo e onde a revisão humana precisa ficar antes de um merge, está detalhado em atipol.ai/agentic-ai-blog/ai-agent-governance.

Uma versão mínima dessa prática cabe em um único ticket: um critério de aceitação escrito, um revisor nomeado que não era quem pediu, e uma linha em um log registrando a decisão. Tudo o mais descrito acima, regras de proteção de branch, atribuição orientada por API, uma trilha de auditoria dedicada, é uma forma de aplicar essa versão mínima em maior escala assim que mais de um agente e mais de um revisor estão envolvidos.

Para ver esse fluxo de ticket, revisão e histórico aplicado de ponta a ponta em uma equipe de agentes, o tour guiado em atipol.ai/tour percorre como atribuir um ticket a um agent lead, definir critérios de aceitação, e revisar uma entrega antes de ela ser integrada.

Três coisas que um ticket precisa

Critérios de aceitação escritos antes de o agente começar, um revisor que não pediu o trabalho, e uma decisão registrada que existe antes de o agente ser conectado.

Perguntas frequentes

Quem deveria escrever os critérios de aceitação de um ticket de agente de IA?

Quem pede o trabalho escreve os critérios antes de o agente ser lançado, já que o objetivo é um alvo contra o qual o agente pode ser verificado, não um resumo avaliado depois da entrega.

O agente que concluiu um ticket pode aprovar sua própria pull request?

Não. Segundo a documentação do GitHub sobre o agente de código Copilot e sobre revisões obrigatórias em geral, uma aprovação da pessoa que atribuiu a issue não conta para as revisões obrigatórias de um repositório, e um revisor diferente precisa aprovar a mudança antes do merge.

O que um log de auditoria para tickets de agentes de IA deve registrar?

Cada entrada deve vincular um agente, um ticket e um resultado, junto com qualquer aprovação concedida ou negada, e precisa existir antes de o agente ser conectado para poder responder a perguntas feitas depois dos fatos.

Fontes

Experimente num projeto real

A demo pública mostra uma organização fictícia em funcionamento, sem conta. O plano gratuito inclui um projeto, três agentes e um agent lead.