Os novos riscos de segurança do ciclo de vida do desenvolvimento agentivo

Principais conclusões

• O ciclo de vida do desenvolvimento agentivo é o processo pelo qual agentes de IA planejam, criam, modificam, testam e lançam software ao interagir com ferramentas, bases de código e ambientes

• Agora, os riscos surgem antes de o código chegar ao repositório. Com isso, a principal questão de segurança deixa de ser "Este código é seguro?" e passa a ser "Podemos confiar no sistema que o criou?"

• Os agentes introduzem riscos em três pontos: o que usam, o que fazem e o que geram

• A segurança tradicional de aplicações protege o artefato; no desenvolvimento agentivo, é preciso proteger o processo que o cria.

• Controles contínuos nos fluxos de trabalho dos agentes oferecem limites confiáveis para que desenvolvedores e agentes avancem com agilidade.

Durante anos, a segurança de aplicações partiu de uma premissa simples: o software percorre um ciclo de vida, e a segurança inspeciona os artefatos à medida que eles avançam do desenvolvimento à produção. Desenvolvedores planejam, escrevem o código, fazem commit, testam, analisam e lançam o software. Todos os controles criados — incluindo revisões de pull request, bloqueios de CI/CD e análises após o commit — pressupunham que uma pessoa estaria entre cada etapa, tomando decisões que uma ferramenta poderia verificar depois.

Os agentes de IA estão derrubando essa premissa: o software já não é apenas escrito por pessoas e verificado posteriormente. Cada vez mais, ele é montado, modificado e executado por sistemas autônomos que podem agir antes que qualquer controle tradicional veja o resultado. O "desenvolvedor" nem sempre é uma pessoa. Às vezes, é o próprio sistema que está criando o software.

Essa mudança tem um nome que vale a pena conhecer: ciclo de vida do desenvolvimento agentivo. E ela altera o ponto em que os riscos entram no seu software, mudando também o que você precisa proteger.

O que é o ciclo de vida do desenvolvimento agentivo?

O ciclo de vida do desenvolvimento agentivo é o processo pelo qual agentes de IA planejam, criam, modificam, testam e lançam software ao interagir com ferramentas, bases de código, fontes de dados e ambientes de desenvolvimento.

O SDLC tradicional é liderado por pessoas, baseado em artefatos e orientado por pontos de controle. O trabalho avança em etapas, e a segurança inspeciona o resultado de cada uma. O ciclo de vida do desenvolvimento agentivo é diferente: é dinâmico, contínuo, orientado por ações e conduzido por agentes. Um agente pode interpretar um objetivo, selecionar uma ferramenta, modificar arquivos, executar um script, chamar uma API, adicionar uma dependência e gerar código pronto para produção — muitas vezes, em uma única sequência ininterrupta.

Isso não substitui o SDLC; na verdade, se sobrepõe a ele e o acelera. Os agentes ainda produzem código, dependências, configurações, APIs e mudanças na infraestrutura. A diferença é que fazem isso por meio de fluxos de trabalho muito mais difíceis de observar e governar do que quando um desenvolvedor digita em um IDE.

Por que o desenvolvimento agentivo muda o modelo de risco

A segurança tradicional de aplicações pressupõe que os riscos estão nos artefatos, como código-fonte, dependências open source, contêineres, infraestrutura como código e APIs. Isso continua valendo, mas o desenvolvimento agentivo amplia a superfície de ataque para incluir o sistema que produz esses artefatos. A questão de segurança deixa de ser "Este código é seguro?" e passa a ser "Podemos confiar no sistema que o criou?". É uma pergunta diferente, e a maioria dos programas de segurança ainda não está preparada para respondê-la.

Os três pontos de controle do ciclo de vida do desenvolvimento agentivo

Uma forma útil de entender esse novo ciclo de vida é observar os três pontos em que os agentes introduzem riscos: as entradas que usam, as ações que executam e as saídas que geram. Se os riscos surgem continuamente, você precisa considerá-los em três pontos: o que os agentes usam, o que fazem e o que geram.

1. O que os agentes usam

Os agentes não começam do zero: recorrem a servidores MCP, skills, APIs, ferramentas externas, fontes de dados e integrações de desenvolvimento para realizar o trabalho. Essas entradas podem passar a fazer parte da cadeia de suprimentos de software, mesmo sem terem sido declaradas como dependências tradicionais. Além disso, muitas vezes são selecionadas e acionadas durante a execução, sem nenhuma revisão.

Entre os riscos estão servidores MCP não aprovados, skills vulneráveis ou maliciosas, ferramentas externas de procedência incerta e ferramentas de IA que ninguém monitora. Isso não é hipotético: uma pesquisa da Snyk identificou 76 skills maliciosas confirmadas entre 3.984 analisadas, e cerca de um terço dos servidores MCP públicos apresenta falhas exploráveis.

Se você não sabe o que os agentes estão usando, não tem como saber quais riscos estão entrando no fluxo de trabalho de desenvolvimento.

2. O que os agentes fazem

Os agentes não se limitam a sugerir uma mudança e esperar: eles executam scripts, consultam sistemas internos, modificam arquivos e chamam APIs na velocidade das máquinas.

Isso introduz riscos por meio da execução insegura de comandos, do acesso não autorizado a sistemas ou dados, da exposição de dados em chamadas de ferramentas, de ataques de injeção de prompt nos fluxos de trabalho de desenvolvimento e de sequências de ações imprevisíveis. Um exemplo real é o de um agente de programação que ignorou repetidas instruções de "congelamento", excluiu um banco de dados de produção e depois inventou registros para encobrir o erro. O agente avançou no raciocínio a partir de um pequeno obstáculo, usando as permissões que tinha.

É preciso governar o comportamento dos agentes em tempo real, pois as ações podem acontecer mais rápido do que uma revisão humana consegue intervir.

3. O que os agentes geram

Os agentes geram o código e as dependências que passam a fazer parte do seu software. Mesmo quando o resultado parece funcionar, o código gerado por IA pode conter vulnerabilidades, padrões inseguros ou configurações incorretas por padrão.

A segurança tradicional de aplicações pressupõe que o código pode ser revisado depois de escrito. Mas, no desenvolvimento agentivo, o resultado é criado na velocidade das máquinas e pode passar de sugestão a commit antes que a equipe de segurança saiba o que mudou ou por quê. O risco não é apenas que o código gerado por IA possa ser inseguro. É também que resultados inseguros sejam introduzidos mais cedo, replicados mais rapidamente e lançados antes que os pontos de controle tradicionais consigam detectá-los.

Analisar o código após o commit já não é suficiente: é preciso validar o que os agentes geram no momento da criação.

Por que os pontos de controle tradicionais de segurança de aplicações não são suficientes

Nada disso significa que a segurança tradicional de aplicações deixou de ser importante. Você ainda precisa analisar código, dependências, contêineres e infraestrutura. Essa base é mais importante do que nunca, porque a IA não substitui sua cadeia de suprimentos de software: ela a acelera.

Mas os pontos de controle tradicionais foram criados para um mundo em que as pessoas tomavam a maioria das decisões de desenvolvimento, o código era o principal artefato a ser inspecionado e os riscos muitas vezes podiam ser detectados no commit, na compilação ou na implantação. A segurança já não pode depender apenas de inspeções posteriores: ela precisa fazer parte do próprio fluxo de trabalho agentivo. A segurança tradicional de aplicações protege o artefato. Agentic Development Security protege o processo que o cria.

O que é necessário para proteger o ciclo de vida do desenvolvimento agentivo

Proteger esse ciclo de vida não significa atrasar os desenvolvedores com outra rodada de revisão nem proibir ferramentas de IA. Significa estabelecer limites confiáveis para que as equipes possam adotá-las com segurança. Na prática, isso exige controles que funcionem dentro dos fluxos de trabalho em que os agentes atuam.

As equipes de segurança precisam descobrir quais agentes, ferramentas, skills e servidores MCP estão em uso; avaliar se essas entradas são confiáveis; controlar o que os agentes podem acessar e executar; aplicar políticas durante os fluxos de trabalho dos agentes; validar código e dependências gerados em tempo real; e manter um registro de auditoria das atividades de desenvolvimento conduzidas por agentes.

O ponto em comum é a supervisão contínua, com a segurança atuando perto o bastante dos agentes para avaliar os riscos antes que se tornem um artefato em um commit, uma ação executada ou uma vulnerabilidade implantada.

O ciclo de vida mudou. A segurança precisa mudar com ele.

O ciclo de vida do desenvolvimento agentivo não é apenas um SDLC mais rápido. É uma forma diferente de criar software, na qual sistemas autônomos podem recorrer a ferramentas, executar ações e gerar resultados continuamente. Essa mudança traz questões de segurança que os controles baseados em pontos de verificação nunca foram projetados para responder sozinhos.

Para expandir com segurança o desenvolvimento impulsionado por IA, as equipes precisam de visibilidade e controle ao longo de todo o ciclo de vida: o que os agentes usam, o que fazem e o que geram. O objetivo não é desacelerar a adoção da IA. É estabelecer limites confiáveis para que desenvolvedores e agentes avancem com agilidade, enquanto a segurança atua continuamente em segundo plano.

Quer entender melhor como os agentes de IA vão além dos controles tradicionais? Baixe o guia prático hoje mesmo.