Limites e proteções de execução do agente

  • 5 minutos

Os agentes podem executar ações em repositórios, mas essas ações são executadas dentro de limites e proteções da plataforma. Em GitHub, o agente de nuvem do Copilot funciona em um ambiente alimentado por GitHub Actions, cria alterações em um branch, preparando-as para revisão.

Ele não finaliza as alterações por conta própria. Você decide se essas alterações devem se tornar uma solicitação de pull.

Nesta unidade, você aprenderá:

  • Quais limites são colocados em ações do agente
  • Como as restrições de branch e repositório protegem as bases de código
  • Como o fluxo de trabalho e os controles de ambiente afetam as alterações controladas pelo agente
  • Como a revisão humana continua a fazer parte do processo

Limites de repositório e filial

Copilot agente de nuvem só tem acesso ao repositório em que está funcionando. Ele não pode acessar outros repositórios.

Suas alterações são feitas em um branch separado, não diretamente no branch padrão, como principal. Isso garante que todas as modificações sejam isoladas antes da revisão.

Controle de solicitação de pull

Quando o agente de nuvem Copilot conclui seu trabalho, ele prepara as alterações para revisão, mas não cria ou mescla automaticamente um pull request.

Você decide se deseja:

  • Criar uma solicitação de pull
  • Examinar as alterações geradas
  • Solicitar atualizações ou descartar o trabalho

Isso mantém a decisão final no controle humano.

Controles de fluxo de trabalho

O trabalho do agente é executado em fluxos de trabalho alimentados por GitHub Actions.

As configurações do repositório e da organização podem controlar:

  • Quais fluxos de trabalho são permitidos
  • Quais ações podem ser executadas
  • O que o GITHUB_TOKEN tem permissão para fazer

Esses controles limitam o que o agente pode executar por meio de fluxos de trabalho.

Proteções de execução e padrões de resiliência.

Além dos limites no nível da plataforma, os fluxos de trabalho controlados por agente devem incluir proteções para lidar com falhas, evitar erros repetidos e garantir a responsabilidade.

Tratamento de erros

Os fluxos de trabalho devem lidar explicitamente com falhas durante a execução do agente.

São elas:

  • Falha rápida quando uma etapa encontra erros
  • Registrar mensagens de erro significativas em log
  • Impedindo alterações parciais ou inconsistentes

Exemplo:

```
- run: | 
        npx @github/copilot-cli -p "Run task" 
continue-on-error: false
```

Isso garante que os erros interrompam a execução em vez de continuar silenciosamente.

Repetições

As novas tentativas ajudam a lidar com falhas temporárias, como problemas de rede ou erros transitórios.

Você pode implementar tentativas novamente:

  • Executar novamente as etapas com falha
  • Usando lógica de repetição em scripts
  • Estruturar fluxos de trabalho para permitir a re-execução segura

Padrão de exemplo:

```
- name: Run agent task with retry 
run: | 
        for i in 1 2 3; 
            do npx @github/copilot-cli -p "Run task" && break 
            sleep 5 
        done
```

Isso permite que o fluxo de trabalho se recupere de problemas temporários sem intervenção manual.

Reversões

Se um agente produzir alterações incorretas ou não seguras, os mecanismos de reversão garantirão que essas alterações não afetem a base de código principal.

A reversão tem suporte natural por meio de:

  • Isolamento baseado em ramificação
  • Análise de solicitação de pull antes da mesclagem

As estratégias de reversão extra incluem:

  • Fechando ou descartando o pull request
  • Revertendo confirmações se as alterações forem mescladas

Caminhos de escalonamento

Quando um agente não consegue concluir uma tarefa ou encontra incertezas, o escalonamento garante que um humano possa intervir.

Isso pode ser implementado por:

  • Exigir revisão de pull request
  • Atribuindo revisores automaticamente
  • Usando as etapas de fluxo de trabalho para notificar mantenedores

A escalada garante que decisões críticas sejam sempre tratadas pelos humanos.

Rastreabilidade e responsabilidade

Todas as ações do agente devem ser rastreáveis e auditáveis.

GitHub fornece isso por meio de:

  • Registro de fluxo de trabalho
  • Histórico de commit
  • Discussões de solicitação de pull

Para melhorar a rastreabilidade:

  • Usar mensagens de confirmação claras
  • Mantenha as alterações restritas a um branch
  • Examinar todas as ações por meio de solicitações de pull

Isso garante que todas as ações do agente possam ser inspecionadas, compreendidas e atribuídas.

Essas proteções discutimos para garantir que a execução do agente seja:

  • Resiliente: pode lidar com falhas e novas tentativas
  • Controlado: impede alterações não seguras
  • Auditável: todas as ações são visíveis e rastreáveis
  • Governada por humanos: escalonamento garante supervisão

Proteções de ambiente

Se as alterações geradas pelo agente forem usadas em implantações, os ambientes fornecerão proteções extras.

Os ambientes podem:

  • Exigir aprovações antes que os trabalhos continuem
  • Restringir o acesso a segredos
  • Controlar destinos de implantação

Isso garante que as operações confidenciais não sejam executadas automaticamente.

Visibilidade da sessão

A execução do agente é visível enquanto está em funcionamento.

É possível:

  • Monitorar o progresso por meio de logs
  • Inspecionar as ações do agente
  • Fornecer prompts de acompanhamento para ajustar o comportamento

Essa visibilidade permite que você permaneça no controle durante todo o processo.

Comportamento do gatilho e limites de fluxo de trabalho

Os fluxos de trabalho disparados usando o GITHUB_TOKEN têm restrições.

A maioria das ações executadas com esse token não dispara execuções extras de fluxo de trabalho, o que ajuda a evitar loops não intencionais ou execução repetida.

Outros métodos de autenticação, como tokens de aplicativo GitHub ou PATs (tokens de acesso pessoal), podem disparar execuções extras de fluxo de trabalho dependendo da configuração. Embora isso habilite padrões de automação mais flexíveis, ele também requer um design cuidadoso para evitar execuções recursivas ou loops de automação não intencionais.

Permitir ações do agente de maneira segura

Os agentes podem executar ações como:

  • Criando ramificações
  • Atualizando código
  • Preparando alterações para revisão
  • Ativando fluxos de trabalho por meio de eventos de repositório

Essas ações são controladas por meio de:

  • Isolamento baseado em ramificação
  • Validação de fluxo de trabalho
  • Revisão de solicitação de pull
  • Permissões de fluxo de trabalho

Combinando esses controles, as ações do agente podem ser habilitadas sem permitir o acesso irrestrito ao repositório ou ao ambiente de execução.

Conclusão principal

A execução do agente em GitHub é controlada por meio do escopo do repositório, isolamento de ramificação, permissões de fluxo de trabalho, proteções de ambiente e pontos de decisão humana. Os agentes preparam alterações, mas você continua responsável por revisá-las e finalizá-las.