DEV Community

Cover image for Codex Sandbox vs Docker Sandboxes: duas formas de isolar um agente de programação
Lucas
Lucas

Posted on Originally published at apidog.com

Codex Sandbox vs Docker Sandboxes: duas formas de isolar um agente de programação

Na questão Codex sandbox vs Docker Sandboxes, a diferença está em onde os comandos do agente são executados. O sandbox do Codex mantém os comandos na sua própria máquina e os limita com ferramentas do sistema operacional (Seatbelt no macOS, bubblewrap mais seccomp no Linux, MXC no Windows). O Docker Sandboxes move o agente para uma microVM com kernel, sistema de arquivos, Docker Engine e rede próprios. Escolha o sandbox do Codex quando precisar de toolchains nativas; escolha o Docker Sandboxes quando quiser uma fronteira rígida em torno de tudo o que o agente faz.

Experimente o Apidog hoje

Codex sandbox vs Docker Sandboxes em resumo

Sandbox do Codex Docker Sandboxes
Onde os comandos são executados Seu ambiente atual Uma microVM por sandbox
Mecanismo de isolamento Seatbelt (macOS), bubblewrap + seccomp-bpf (Linux), MXC (Windows) Hypervisor, kernel separado por sandbox
Configurado com Perfis de permissão no config.toml CLI sbx e políticas
Rede padrão Desativada no perfil :workspace Proxy que nega por padrão, com uma lista de permissões padrão
Ferramentas nativas do host Sim (Xcode, simuladores, SDKs locais) Não, apenas o que está dentro da VM
Agentes cobertos Codex (e qualquer comando via codex sandbox) Claude Code, Codex, Copilot, Cursor, Devin, Kiro, OpenCode e outros
Política de equipe Requisitos gerenciados via requirements.toml Docker AI Governance (assinatura paga à parte)
Preço Faz parte do Codex CLI sbx e computação local gratuitas; a nuvem é pay-as-you-go

O que é o sandbox do Codex?

O sandbox do Codex é a camada que limita o que os comandos executados pelo Codex no seu computador podem ler, gravar e acessar. Ele não move o trabalho para um contêiner nem para uma VM. Em vez disso, envolve cada comando, e cada processo filho que ele gera, nos recursos de sandbox do próprio sistema operacional, usando regras definidas em um perfil de permissões.

O perfil :workspace integrado é o padrão para um repositório Git. Ele permite gravações dentro do workspace, mantendo .git e .codex como somente leitura, permite leituras amplas em outros locais (compiladores precisam de SDKs fora do repositório) e desativa o acesso à rede. Você pode estendê-lo no config.toml. Este exemplo é citado do post da OpenAI:

default_permissions = "dev"

[permissions.dev]
description = "Development with extra read-only protections."
extends = ":workspace"

[permissions.dev.filesystem]
"~/build-cache" = "write"

[permissions.dev.filesystem.":workspace_roots"]
".devcontainer" = "read"
".vscode" = "read"
"**/*.env" = "deny"
"secrets" = "deny"
Enter fullscreen mode Exit fullscreen mode

O comando codex sandbox executa qualquer programa sob um perfil, fora de uma sessão de agente. É assim que você testa um perfil ou envolve um servidor MCP stdio que o Codex, de outra forma, iniciaria sem sandbox:

codex sandbox --permission-profile dev -- bash -c 'cat > .vscode/settings.json'
Enter fullscreen mode Exit fullscreen mode

No macOS, essa gravação falha com Operation not permitted. Para perfis prontos para copiar, consulte a documentação de perfis de permissão.

O que são Docker Sandboxes?

O Docker Sandboxes executa agentes de programação com IA em microVMs isoladas, na sua máquina ou na infraestrutura de nuvem gerenciada pela Docker. Cada sandbox recebe seu próprio kernel, daemon do Docker, sistema de arquivos e rede. O agente tem privilégios totais dentro da VM, incluindo sudo e um Docker Engine privado, mas acessa apenas os recursos do host que você compartilha.

Você o controla com a CLI sbx, que não precisa do Docker Desktop. Sandboxes locais exigem macOS 14 ou superior em Apple silicon, Windows 11 com Hypervisor Platform, ou Ubuntu 24.04 ou superior com KVM. Do guia de primeiros passos:

cd ~/my-project
sbx run --name my-sandbox claude   # or: sbx run codex
sbx policy ls
sbx policy allow network registry.npmjs.org
sbx stop my-sandbox
sbx rm my-sandbox
Enter fullscreen mode Exit fullscreen mode

O diretório do seu projeto é montado na VM no mesmo caminho absoluto. Uma montagem direta é de leitura e gravação, então o agente edita sua árvore de trabalho in loco. Com --clone, o repositório do host é montado como somente leitura e o agente trabalha em um clone Git privado. As credenciais permanecem no host: a documentação de arquitetura do Docker diz que "os valores brutos das credenciais nunca entram na VM".

Diagrama lado a lado: o sandbox do Codex envolve comandos no SO do host com um perfil de permissões, enquanto o Docker Sandboxes executa o agente inteiro dentro de uma microVM com kernel e proxy de rede próprios

Força do isolamento: política do SO vs um kernel separado

O Codex restringe processos no kernel do host. No macOS, ele gera um perfil Seatbelt que parte de (deny default). No Linux, ele constrói uma visão do sistema de arquivos com bubblewrap, desassocia os namespaces de rede, IPC e PID, e aplica um filtro seccomp-bpf com no_new_privs definido. No Windows, está migrando para a biblioteca MXC (Microsoft eXecution Container) da Microsoft. Os limites são reais e impostos pelo kernel, mas o agente compartilha seu kernel e enxerga sua máquina através de um filtro.

O Docker coloca um hypervisor entre o agente e seu host. Cada sandbox tem um kernel separado e seu próprio Docker Engine "sem caminho para o daemon do host". Um bug de kernel ou uma regra mal configurada dentro da VM não entrega seu laptop ao agente.

Ambos deixam lacunas que documentam com honestidade:

  • O perfil padrão do Codex mantém leituras amplas ativadas, então um arquivo de configuração em outro local contendo uma chave de API pode continuar legível. A OpenAI também alerta que um agente pode adulterar um arquivo ignorado como node_modules/prettier, que seu editor executa depois, fora do sandbox.
  • A montagem direta do Docker é de leitura e gravação, então hooks do Git, configuração de CI e um Makefile editados pelo agente podem ser executados depois no seu host. Servidores MCP stdio locais também rodam fora da VM do sandbox.

Nenhum dos dois elimina a necessidade de revisar as alterações do agente. Se você vem lutando contra o sandbox do Codex, nosso guia sobre como contornar o sandbox do Codex cobre o meio-termo mais seguro.

Ferramentas nativas e custo de configuração

O argumento da OpenAI contra contêineres é concreto. Se você colocasse o Codex em sandbox dentro do Docker enquanto desenvolve um app para iOS, "o Codex não conseguiria executar a toolchain de build do iOS, composta por executáveis nativos do Mac, nem iniciar o simulador do iPhone". Delegar essas etapas de volta ao host as colocaria fora do sandbox novamente.

Por isso, o sandbox do Codex custa quase nada para configurar: seu shell, SDKs e caches ficam onde estão.

O Docker Sandboxes exige mais logo de cara. A VM parte de um template (docker/sandbox-templates:codex para o Codex), e você adiciona ferramentas com kits ou instalando-as dentro dela. Sandboxes não leem configurações de nível de usuário, como ~/.codex, apenas configurações de nível de projeto no diretório de trabalho. Em troca, você obtém um ambiente limpo e reproduzível que funciona igual para todos os agentes, e uma carga de trabalho em contêiner pode rodar com segurança dentro do Docker Engine privado da VM.

Para um serviço que já é compilado em um contêiner, esse custo é pequeno. Para Xcode ou um SDK desktop licenciado, é grande.

Controle de rede em comparação

Ambos roteiam o tráfego por um proxy que verifica domínios, e ambos começam fechados.

O Codex tem três modos: rede desativada (o padrão do :workspace), acesso total (:danger-full-access) ou um proxy que aplica regras de domínio por perfil:

[permissions.dev.network]
enabled = true

[permissions.dev.network.domains]
"*.openai.com" = "allow"
"localhost" = "allow"
"evil.example" = "deny"

[features]
network_proxy = true
Enter fullscreen mode Exit fullscreen mode

Negativas explícitas vencem permissões, e uma solicitação a um domínio não listado pode ser pausada para sua aprovação. O proxy só resolve um hostname depois que ele é permitido, embora a OpenAI observe que wildcards amplos ainda podem permitir exfiltração via DNS.

O Docker roteia todo o TCP de saída da VM por um proxy no host, bloqueia UDP e ICMP por padrão, e gerencia regras com sbx policy. Sua página do modelo de segurança alerta que "os domínios permitidos por padrão incluem wildcards amplos", então execute sbx policy ls antes de confiar nos padrões.

Política de equipe: requisitos gerenciados vs Docker AI Governance

Equipes precisam de uma política que os usuários não possam afrouxar sem que ninguém perceba.

O Codex usa requisitos gerenciados. Um administrador distribui um requirements.toml, a partir de um arquivo de sistema como /etc/codex/requirements.toml ou de uma política na nuvem, que limita quais perfis os usuários podem escolher:

default_permissions = ":read-only"

[allowed_permission_profiles]
":read-only" = true
":danger-full-access" = false
Enter fullscreen mode Exit fullscreen mode

O Docker vende essa camada como Docker AI Governance: políticas de rede e sistema de arquivos do sandbox, políticas de ferramentas MCP escritas em Cedar e aplicadas no MCP Gateway do Docker, e registros de auditoria de cada decisão, que você pode manter localmente ou enviar para a nuvem. A documentação do Docker lista a política em nível de organização como uma assinatura paga à parte. A vantagem é ter uma política única para todos os agentes que sua equipe usa, não apenas para o Codex.

Quando usar cada um

Não há um único vencedor. Ajuste a fronteira ao trabalho:

  1. Use o sandbox do Codex quando você desenvolve para macOS ou iOS, depende de SDKs exclusivos do host, ou quer configuração zero e o Codex é seu único agente.
  2. Use o Docker Sandboxes quando você roda vários agentes, quer um kernel separado entre o agente e seu laptop, ou deixa o agente executar tarefas longas sem supervisão com Docker por dentro.
  3. Use os dois quando quiser o Codex dentro de uma fronteira rígida. A página do Codex no Docker mostra sbx run codex iniciando codex --dangerously-bypass-approvals-and-sandbox por padrão: a microVM se torna o muro e as aprovações do próprio Codex ficam de lado. Tenha esse trade-off em mente antes de escolher.

Fluxo de decisão para escolher entre o sandbox do Codex e o Docker Sandboxes com base em ferramentas nativas, número de agentes e necessidades de isolamento

Teste sua API em qualquer um dos sandboxes com o Apidog CLI

Seja qual for o muro que você escolher, seu agente ainda precisa provar que suas alterações funcionam contra uma API real. O Apidog CLI oferece a ele comandos para casos de teste e execuções com saída JSON que ele consegue ler. Configure uma vez:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install
Enter fullscreen mode Exit fullscreen mode

Depois, abra a rede para exatamente dois hosts: sua API e api.apidog.com, a base de API padrão da CLI. No Codex, adicione ambos à tabela [permissions.<name>.network.domains] do perfil. No Docker Sandboxes, execute sbx policy allow network api.apidog.com mais o host da sua API.

Dê ao seu agente um único prompt:

Using Apidog CLI, create a test case in project <projectId> for
POST /orders on endpoint <endpointId> that asserts a 201 status and an
"id" field in the body. Run it against environment <envId> and summarize
any failures.
Enter fullscreen mode Exit fullscreen mode

O agente lê o schema, valida seu payload e executa o caso:

apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog test-case run --project <projectId> --endpoint <endpointId> -e <envId> -r cli,json
Enter fullscreen mode Exit fullscreen mode

Se uma execução falhar com erro de rede, o sandbox fez seu trabalho: verifique qual host a lista de permissões deixou de fora. Para o passo a passo completo do Codex, consulte Apidog CLI no Codex, e troque -r cli,json por -r junit quando a mesma execução migrar para um pipeline de CI. O plano Free do Apidog cobre até 4 usuários.

FAQ

O sandbox do Codex é um contêiner? Não. O Codex restringe comandos no seu ambiente atual com Seatbelt no macOS, bubblewrap e seccomp-bpf no Linux, e MXC no Windows. Não há imagem de sistema de arquivos separada nem VM.

O Docker Sandboxes são apenas contêineres? Não. A documentação do Docker os descreve como microVMs com isolamento por hypervisor e um kernel separado por sandbox. Cada um executa seu próprio Docker Engine, então o agente pode compilar e rodar contêineres dentro dele.

Posso rodar o Codex dentro do Docker Sandboxes? Sim. sbx run codex inicia o Codex em uma microVM. Por padrão, ele é iniciado com --dangerously-bypass-approvals-and-sandbox, então a VM, e não o sandbox do Codex, é a fronteira.

O Docker Sandboxes é gratuito? A Docker afirma que a CLI sbx e a computação local do sandbox são gratuitas, inclusive para uso comercial. Sandboxes na nuvem usam uma assinatura pay-as-you-go, as cobranças do provedor de modelo são à parte, e o gerenciamento de políticas em nível de organização é uma assinatura paga à parte.

Algum dos sandboxes cobre servidores MCP? Não por padrão. O Codex não coloca em sandbox servidores MCP stdio, a menos que você os envolva com codex sandbox. O Docker executa servidores MCP stdio locais fora da VM; seu gateway MCP e as políticas Cedar governam os servidores roteados por ele.

Top comments (0)