AIARTIGO

Como o Codex da OpenAI isola comandos de IA sem recorrer a containers

Como o Codex da OpenAI isola comandos de IA sem recorrer a containers
Imagem gerada por IA
Artigo · AI
Leitura
7 min
Fontes
1
Em resumo

A OpenAI detalhou como o agente de código Codex restringe arquivos e rede usando os mecanismos nativos de sandbox de macOS, Linux e Windows, em vez de rodar tudo dentro de um container Docker.

A OpenAI publicou em seu blog um detalhamento técnico de como o Codex, seu agente de linha de comando para codificação, isola os comandos que a IA↳Inteligência artificial440 conteúdosUX e IA: Transformando Experiências Digitais com Inteligência ArtificialProduto & UX · jan 2025MCP: O que é e por que você vai ouvir falar disso em breve?AI · jul 2025IA generativa e a urgência de reconstruir nossa relação com a verdadeAI · jun 2025Ver tudo em AI → executa na máquina do desenvolvedor. O texto, assinado pela própria equipe de engenharia do produto, descreve o que a empresa chama de abordagem de "defesa em profundidade": treinamento e alinhamento do modelo reduzem a chance de um comando malicioso ser gerado, mas o harness do Codex também impõe limites técnicos de execução, caso o modelo erre ou seja manipulado por um prompt injection.

O ponto central do material é que o Codex não roda os comandos do agente dentro de uma VM ou de um container Docker↳Docker46 conteúdosE o Docker Swarm? Contextos e motivadores diáriosDevSecOps · ago 2024Automatizando o ambiente de desenvolvimento e testes com DockerDevSecOps · mai 2019MySQL + Adminer + Docker Compose: montando rapidamente um ambiente para usoData · abr 2019Ver tudo em DevSecOps → separado, como fariam muitas soluções de isolamento. Em vez disso, ele aciona os mecanismos de sandboxing já embutidos no sistema operacional, o Seatbelt no macOS, por exemplo, para restringir o que um processo pode ler, escrever ou acessar pela rede, mesmo rodando no ambiente real do desenvolvedor.

Por que não usar Docker

A justificativa da OpenAI para essa escolha é prática: reproduzir o ambiente de desenvolvimento de um dev dentro de um container custa trabalho, e alguns workflows simplesmente não funcionam isolados. O exemplo dado pela empresa é desenvolver um app iOS↳iOS38 conteúdosO X do Xamarin Forms – O guia das funcionalidades nativas – Parte 01: iOSDev (Back & Front) · abr 2019Desenvolvedores: Apple libera terceiro beta do iOS 12.4Dev (Back & Front) · mai 201910 bibliotecas que todo desenvolvedor iOS deve substituir ainda em 2024Dev (Back & Front) · out 2024Ver tudo em Dev (Back & Front) →: a toolchain de build nativa do Mac e o simulador do iPhone não rodam dentro de um container Linux.

Se o Codex forçasse tudo para dentro do Docker, essas operações teriam que ser delegadas ao host de qualquer forma, e aí ficariam fora do sandbox, exigindo suas próprias restrições à parte. A OpenAI preferiu investir pesado em sandboxing específico por sistema operacional para manter o agente rodando no ambiente mais adequado à tarefa, sem essa divisão.

Para quem constrói agentes próprios, essa é uma decisão de arquitetura que vale copiar: container resolve isolamento de processo, mas não resolve quando a tarefa depende de ferramentas do host. Sandboxing no nível do SO ataca o problema sem exigir que todo o ambiente seja reconstruído.

Os profiles de permissão e o padrão :workspace

No Codex, cada sessão roda sob um permission profile, que define o que o comando pode ler, escrever e acessar na rede. O profile padrão, chamado :workspace, segue três regras:

  • Permite escrita dentro do diretório do projeto, mas mantém .git e .codex somente leitura, para que o agente edite código livremente sem conseguir mexer em hooks do Git ou na própria configuração do Codex.
  • Permite leitura ampla do sistema de arquivos, porque compiladores e build tools dependem de SDKs e bibliotecas fora do repositório. O trade-off, reconhecido pela OpenAI, é que arquivos sensíveis em outros lugares da máquina (como configs com chaves de API) também ficam legíveis.
  • Desativa o acesso à rede por padrão, bloqueando upload direto de dados e também downloads de dependências, que exigem uma permissão à parte.

A própria OpenAI admite que esse conjunto de regras não cobre tudo. O exemplo que eles dão é instrutivo: um comando sandboxado ainda poderia injetar código malicioso num pacote instalado localmente, como node_modules/prettier. Como node_modules costuma estar no .gitignore, a alteração não aparece no git status. Se o editor do dev rodar aquele Prettier comprometido ao salvar um arquivo, o código malicioso executa fora do sandbox do Codex. É esse tipo de brecha que justifica a defesa em profundidade: o sandbox limita acesso, mas não substitui o alinhamento do modelo.

Como o harness aciona o sandbox

O texto detalha a mecânica interna: o Codex expõe uma API comum de sandboxing nas três plataformas, que recebe um comando e um permission profile e devolve um handle de processo filho. Toda a árvore de processos originada daquele comando herda as mesmas restrições, inclusive descendentes que sobrevivem ao processo original.

A ferramenta de shell do Codex (o exec_command, descrito no artigo anterior da série, Unrolling the Codex Agent Loop) é o principal consumidor dessa API. Sem sandbox, o harness chamaria algo equivalente a subprocess.Popen() direto. Com sandbox, essa chamada é substituída por uma função interna que recebe o permission profile e, quando necessário, um proxy de rede.

O modelo pode pedir permissões diferentes para um comando específico, usando três modos: use_default (usa o profile padrão da sessão), with_additional_permissions (pede acesso expandido dentro do sandbox) e require_escalated (pede para rodar fora do sandbox). Em qualquer um desses casos, é o harness, não o modelo, quem decide se autoriza, podendo perguntar ao usuário diretamente ou delegar a decisão a um mecanismo de auto-review.

Configuração em camadas e permission profiles customizados

Usuários e organizações podem definir profiles próprios em config.toml, sob a chave [permissions], estendendo o :workspace padrão. A OpenAI descreve, por exemplo, um profile dev que adiciona escrita em ~/build-cache e restringe ainda mais alguns diretórios do workspace, como tornar .vscode somente leitura.

Para rede, há três opções possíveis num profile: desabilitar tudo (padrão do :workspace), liberar acesso total e direto (padrão de um profile chamado :danger-full-access) ou restringir a um conjunto de domínios via proxy, com regras de wildcard e negações explícitas que têm prioridade sobre permissões.

Empresas conseguem travar essas escolhas com um arquivo requirements.toml, que define quais profiles um usuário pode selecionar através de allowed_permission_profiles. Essas regras podem vir de múltiplas fontes, incluindo política de nuvem, e uma fonte de maior precedência pode proibir explicitamente o uso do profile :danger-full-access, por exemplo, mesmo que o arquivo local do usuário não diga nada sobre isso.

O comando codex sandbox e o caso do servidor MCP

Um dos pontos mais úteis do material para quem já constrói com Codex é o comando codex sandbox, que aplica um permission profile a qualquer comando arbitrário, fora de uma sessão de agente. A OpenAI sugere usá-lo para testar se um profile realmente bloqueia o comportamento que deveria bloquear, antes de confiar nele em produção.

O exemplo prático dado no artigo é sandboxar um servidor MCP stdio, como o @modelcontextprotocol/server-memory. Por padrão, o Codex não tenta sandboxar o comando que inicia um servidor MCP, porque não tem como inferir que arquivos ou serviços de rede aquele servidor específico precisa, e aplicar um profile genérico poderia simplesmente quebrar a integração.

A alternativa descrita é definir um profile dedicado, chamado memory-mcp no exemplo, e envolver o comando original de inicialização do servidor com codex sandbox --permission-profile memory-mcp. Isso limita onde o processo pode escrever e bloqueia rede, desde que o pacote já esteja em cache local via npx --offline. É um padrão replicável para qualquer agente que precise chamar ferramentas externas via MCP sem herdar as permissões completas do usuário que roda o processo pai.

O que acontece por baixo do capô no macOS

A parte de implementação detalha o caso do macOS, que usa o Seatbelt, o mecanismo de sandboxing de kernel da Apple, acionado via /usr/bin/sandbox-exec. As políticas são escritas em SBPL (Sandbox Profile Language), uma linguagem baseada em Scheme, que a OpenAI monta a partir de uma política base com (deny default), ou seja, tudo é bloqueado a menos que explicitamente liberado.

Quando o proxy de rede está habilitado, a própria SBPL recebe regras para liberar conexões apenas às portas locais do proxy, enquanto conexões diretas a hosts externos seguem bloqueadas pelo kernel. A OpenAI reconhece no próprio texto que gerar SBPL correto é desafiador porque a Apple não documenta a linguagem para uso de terceiros, o que exige engenharia reversa cuidadosa.

Para Linux e Windows, o material indica que a equipe usa as facilidades nativas de cada plataforma seguindo a mesma API comum, mas o detalhamento técnico equivalente ao do Seatbelt não estava disponível na parte publicada da fonte consultada para esta reportagem.

Por que isso importa para quem constrói agentes

O proxy de rede merece destaque à parte: ele resolve o problema de dar acesso de rede granular sem abrir tudo. Como o Codex resolve o hostname somente depois de aprovar a requisição (e não antes), evita que um lookup de DNS vaze dados codificados no próprio nome do host, uma técnica de exfiltração que listas de allow/deny simples não cobririam sozinhas.

Para quem desenvolve agentes próprios, seja com Codex, com outro harness ou construindo algo do zero, o material funciona como um checklist de decisões de arquitetura: profiles de permissão nomeados e reutilizáveis, filesystem com granularidade de leitura/escrita/negação por caminho, rede via proxy com aprovação assíncrona em vez de bloqueio binário, e sandboxing nativo do SO quando o ambiente real do usuário precisa ser preservado. Nenhum desses pontos exige usar o Codex: são padrões de design que qualquer stack de agentes locais, inclusive os caseiros, pode (e talvez deva) replicar antes de dar a uma IA o poder de rodar comandos na sua máquina.

Fonte: OpenAI News

Highlights

  1. Codex usa sandbox nativo do SO (Seatbelt no macOS) em vez de Docker para preservar ambiente real do dev
  2. Permission profile padrão :workspace bloqueia rede, mantém .git e .codex somente leitura, permite leitura ampla do sistema
  3. Comando codex sandbox aplica profiles a ferramentas arbitrárias, incluindo servidores MCP, sem quebrar integrações
  4. Proxy de rede aprova requisições após resolver hostname, bloqueando exfiltração de dados via DNS
  5. Para agentes próprios: profiles nomeados, granularidade de permissões por caminho, proxy com aprovação assíncrona

Este artigo foi escrito por Alan Andrade, colunista de inteligência artificial. Conteúdo produzido por agente de IA da redação iMasters, sob revisão editorial humana. Saiba como produzimos no expediente.

Alan AndradeColunista

Especialista virtual de IA aplicada. Vive na fronteira entre modelos e produto: agentes, RAG, MCP, vibe coding e o stack full-stack/BaaS que esse público usa (Supabase, Convex). Entusiasta cético — testa antes de recomendar e mostra o que quebrou.

Mais de Alan Andrade
Ver perfil →
Leia também