Governança de agentes de IA: seu sandbox não é sua aprovação final

Precisa de governança de agentes de IA para os agentes de programação que sua equipe executa? Veja como o Codex e os sandboxes do Docker definem limites e quem é responsável por revisar cada execução.

Ryan Mitchell

Ryan Mitchell

20 novembro 2026

Governança de agentes de IA: seu sandbox não é sua aprovação final

TL;DR: governança de agentes de IA é o conjunto de regras que decide quem pode iniciar um agente, o que ele pode tocar, o que ele pode alcançar, quem aprova quando ele pede mais permissões e qual registro ele deixa. O sandbox do Codex, da OpenAI, e o AI Governance do Docker implementam a metade de tempo de execução dessa lista. A outra metade — propriedade e revisão — está em como seu time atribui e aceita o trabalho dos agentes.

O que é governança de agentes de IA?

Governança de agentes de IA é o conjunto de políticas e registros em torno de agentes autônomos: quais pessoas podem iniciá-los, quais arquivos e destinos de rede eles podem usar, quais ferramentas podem chamar, quando um humano precisa aprovar uma ação e como cada decisão é registrada. Ela trata o agente como um ator com autoridade, e não como um processo a ser contido.

Esse enquadramento virou a manchete do setor esta semana. Em 19 de novembro, a Docker relançou sua marca em torno de uma frase da CMO Terri Avnaim: “Contêineres isolam cargas de trabalho. Mas agentes não são cargas de trabalho. Agentes são atores.” O post continua: “Os agentes tomam suas próprias decisões sobre o que executar, o que acessar e o que alterar.”

Um dia antes, a OpenAI publicou Inside the Codex sandbox, um relato detalhado de como o Codex limita o que os comandos podem fazer no seu laptop. Dois fornecedores, dois designs, uma pergunta em comum. Se seu time já executa agentes de código pelo Sharkly, este guia mostra onde esses controles de execução param e onde a governança de time precisa assumir.

Por que “agentes são atores” muda a pergunta

Um contêiner responde a uma pergunta: o que este processo consegue ver? Essa pergunta continua importante. Mas ela não cobre tudo o que um agente faz.

Um agente lê uma tarefa, escolhe comandos, decide quais arquivos editar, avalia se chama uma ferramenta e, às vezes, pede mais acesso no meio do caminho. Cada uma dessas etapas é uma decisão. O post sobre AI Governance da Docker resume bem a lacuna: “Uma decisão do modelo não é automaticamente uma ação autorizada.”

Então a governança sai de “isolar o processo” e passa para “autorizar o ator”. Você precisa de respostas para cinco perguntas:

  1. Quem pode iniciá-lo? Quais pessoas podem atribuir ou acionar determinado agente.
  2. O que ele pode tocar? Caminhos do sistema de arquivos, leitura ou escrita.
  3. O que ele pode alcançar? Domínios de rede e ferramentas MCP (Model Context Protocol).
  4. Quem aprova os escalonamentos? O que acontece quando o agente pede mais do que o padrão.
  5. O que fica registrado? Quem executou o quê, o que foi permitido ou negado e quem aceitou o resultado.

As duas abordagens atuais tratam as perguntas 2 a 4 de formas diferentes. A pergunta 1 e a maior parte da pergunta 5 ficam fora das duas.

Cinco camadas de governança de agentes de IA: quem inicia o agente, limites de sistema de arquivos, limites de rede e de ferramentas MCP, aprovação de escalonamento e o registro de auditoria

Como o sandbox do Codex governa o acesso dos agentes

O sandbox do Codex restringe comandos dentro do seu ambiente atual, em vez de movê-los para uma VM ou um contêiner. O motivo da OpenAI é prático: um build de iOS precisa das ferramentas nativas do Mac e do simulador, que um contêiner Docker não consegue executar.

A imposição vem de cada sistema operacional. O Codex usa Seatbelt no macOS, bubblewrap com seccomp-bpf no Linux, e está migrando o Windows para a biblioteca MXC (Microsoft eXecution Container), da Microsoft. Processos filhos herdam o sandbox, então os limites cobrem toda a árvore de processos.

O que os perfis de permissão do Codex controlam?

Um perfil de permissão define regras de sistema de arquivos e de rede para uma sessão. O perfil embutido :workspace permite escrita dentro do workspace, mantém .git e .codex como somente leitura, permite leituras amplas e desativa o acesso à rede. Você pode estendê-lo:

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"]
".vscode" = "read"
"**/*.env" = "deny"
"secrets" = "deny"

As regras de rede passam por um proxy que verifica cada requisição em listas de permitidos e negados. As regras de negação prevalecem. Uma requisição para um domínio não listado fica retida enquanto o Codex consulta o usuário ou a encaminha para revisão automática. A referência completa de chaves está na documentação de permissões do Codex.

Como os administradores aplicam limites?

O controle de time vem dos requisitos gerenciados em requirements.toml, que podem vir de arquivos do sistema ou de política na nuvem. O exemplo da OpenAI fixa todo usuário em somente leitura:

default_permissions = ":read-only"

[allowed_permission_profiles]
":read-only" = true
":danger-full-access" = false

O escalonamento é explícito. Um comando pode pedir with_additional_permissions (mais acesso dentro do sandbox) ou require_escalated (execução fora dele), com uma justificativa que o usuário vê. Quem decide é o harness, não o modelo.

Dois detalhes importam para a governança. Primeiro, codex sandbox --permission-profile dev -- <command> permite testar um perfil antes de confiar nele. Segundo, o Codex não coloca em sandbox o comando que inicia um servidor MCP stdio, porque não consegue adivinhar do que esse servidor precisa. Você mesmo envolve esse comando.

Como funcionam os Docker Sandboxes e o AI Governance

A Docker segue o caminho oposto. Os Docker Sandboxes dão a cada agente uma microVM isolada, com seu próprio Docker Engine, sistema de arquivos e rede, gerenciada pela CLI sbx.

O AI Governance acrescenta política organizacional por cima, em três partes:

  • Políticas de sandbox: permitem ou bloqueiam domínios, faixas de IP e portas, e controlam quais caminhos do host podem ser montados, em modo somente leitura ou leitura e escrita. A documentação de governança da organização afirma que a política é de negação por padrão.
  • Governança de ferramentas MCP: políticas para o tráfego MCP pelo MCP Gateway da Docker, escritas em Cedar, que definem quais servidores podem ser registrados e quais chamadas de ferramenta, recursos e prompts são permitidos. As políticas também podem exigir confirmação para chamadas específicas.
  • Auditoria e visibilidade: registros estruturados de cada decisão de política com principal, ação, alvo, decisão e horário, exportáveis ou encaminhados a um SIEM.

Um desenvolvedor pode verificar um limite antes de começar o trabalho:

$ sbx policy check network api.anthropic.com
Allowed: api.anthropic.com
$ sbx policy check network blocked.example.com
Denied: blocked.example.com

A Docker é transparente sobre uma limitação: as políticas de MCP se aplicam apenas ao tráfego que passa pelo seu gateway. Uma conexão direta a um servidor MCP remoto fica sujeita à política de rede do sandbox. A Docker vende o AI Governance como um plano separado, por meio do seu time de vendas.

Sandbox do Codex vs. AI Governance da Docker

Pergunta Sandbox do Codex Docker Sandboxes + AI Governance
Onde o agente roda Seu ambiente atual, sandbox no nível do SO MicroVM isolada por agente
Regras de sistema de arquivos Perfis de permissão: read, write, deny por caminho Políticas de montagem, somente leitura ou leitura e escrita
Regras de rede Proxy com lista de domínios permitidos/negados; requisições não listadas ficam retidas para aprovação Políticas de domínio, faixa de IP e porta, com negação por padrão
Ferramentas MCP Servidores stdio sem sandbox, a menos que você os envolva com codex sandbox Políticas Cedar no MCP Gateway
Aplicação pelo admin requirements.toml, do sistema ou da nuvem Docker Home ou a API do AI Governance
Escalonamento Solicitação por comando; o usuário ou a revisão automática decide Regras de confirmação em chamadas de ferramenta específicas
Auditoria Não é o foco do post Registros estruturados de decisões de política

Use o sandbox do Codex quando seus agentes precisam de ferramentas nativas do host e você usa principalmente o Codex. Use a abordagem da Docker quando quiser um único limite de isolamento para muitos agentes e uma trilha de auditoria central. Muitos times vão usar os dois.

Onde os controles de execução param

Os dois sistemas respondem “o que este processo pode fazer agora?”. Nenhum deles responde “por que este agente está rodando, quem pediu e quem aceitou o resultado?”.

Essa lacuna aparece rápido. Um sandbox pode bloquear uma escrita em .vscode, mas não consegue dizer que um agente foi iniciado do laptop de alguém às 2 da manhã, sem nenhum chamado. Um log de auditoria pode mostrar uma chamada MCP permitida, mas não mostra se uma pessoa revisou o diff antes do merge. O registro tem ações, mas não tem intenção nem aprovação formal.

Já cobrimos o lado de cada agente em permissões de agentes de código e o lado do merge em portões de aprovação para agentes de código. A governança na escala do time conecta os dois.

Como o Sharkly dá a cada execução de agente um responsável, uma tarefa e uma etapa de revisão

O Sharkly não substitui o sandbox do Codex nem os Docker Sandboxes. Ele fica acima dos agentes de código e adiciona o registro de trabalho que os controles de execução não têm. O mapeamento para as cinco perguntas:

Quem pode iniciá-lo. Cada Agent tem visibilidade Pessoal ou de Space, e a visibilidade define quem pode atribuí-lo, conversar com ele ou acioná-lo a partir de um comentário em uma tarefa. Um Space privado mantém suas tarefas visíveis apenas para os membros do Space.

Onde ele roda. Um Computer tem um responsável e visibilidade própria. Somente o responsável pode excluí-lo ou alterar quais organizações podem usar um Computer pessoal; nem um Organization Admin pode sobrepor isso. O responsável pode desvincular um Agent, o que cancela suas execuções ativas.

O que ele recebe. Uma execução vinculada a uma tarefa carrega a tarefa, os comentários recentes, as instruções do Agent, Skills, repositórios e apenas as variáveis de ambiente e vinculações de segredos configuradas para ela. Cada tarefa recebe um diretório isolado, e o trabalho em repositórios pode usar um worktree separado por execução.

Quem aprova. O workflow do tipo de tarefa limita quais status um Agent pode definir. Um Agent pode deixar uma tarefa aguardando revisão humana, e ela então aparece na Inbox do responsável.

O que fica registrado. O log de execução mostra a origem do acionamento, horários de início e fim, chamadas de ferramentas, eventos de Runtime e detalhes de falhas. Mensagens do Agent destinadas ao time viram comentários vinculados à execução.

Uma tarefa do Sharkly como registro de governança: um responsável atribui a tarefa, o agente roda dentro de um Computer com sandbox e uma pessoa revisa o resultado antes de ele seguir adiante

Assim, o sandbox decide o que um comando pode fazer, e a tarefa decide por que ele rodou e quem aprovou. A documentação do Sharkly cobre visibilidade, Computers e estados de execução em detalhe.

Uma checklist de governança para aplicar esta semana

  1. Liste todos os agentes que seu time executa e nomeie um responsável humano para cada um.
  2. Escreva um perfil de permissão ou política de sandbox por função, começando por somente leitura.
  3. Teste cada perfil com codex sandbox ou sbx policy check antes de liberar.
  4. Envolva ou coloque atrás de um gateway todo servidor MCP; não deixe servidores stdio sem sandbox.
  5. Fixe os perfis centralmente com requirements.toml ou com política da organização.
  6. Exija uma tarefa para cada execução de agente, para que toda execução tenha um motivo e um responsável.
  7. Encaminhe os resultados para um estado de revisão humana antes do merge.
  8. Mantenha segredos fora do texto de tarefas, das instruções e das Skills; vincule-os por runtime.

Nossa checklist de proteção de segredos aprofunda o passo 8.

Conclusão

Agentes são atores, então governá-los significa mais do que isolar um processo. O sandbox do Codex e o AI Governance da Docker agora dão respostas sólidas para limites de sistema de arquivos, de rede e de ferramentas. Propriedade, intenção e revisão ainda precisam de um lugar. Escolha um sandbox, escreva seu primeiro perfil e depois conecte seus agentes ao Sharkly para que cada execução comece com uma tarefa e termine com a aprovação de uma pessoa.

FAQ

Qual é a diferença entre governança de agentes de IA e segurança de agentes de IA?

Segurança é a camada de imposição: sandboxes, política de rede, restrições de ferramentas. A governança inclui essa camada e também as decisões em torno dela: quem pode executar qual agente, quem aprova escalonamentos e quem aceita o resultado.

O sandbox do Codex funciona sem Docker?

Sim. O Codex usa o sandbox nativo de cada sistema operacional (Seatbelt, bubblewrap com seccomp ou MXC) e executa comandos no seu ambiente atual, não em um contêiner.

Posso colocar um servidor MCP em sandbox no Codex?

Sim, mas não por padrão. O Codex não coloca em sandbox o comando que inicia um servidor MCP stdio. Você o envolve com codex sandbox --permission-profile <name> -- nos campos command e args do servidor.

O que o AI Governance da Docker registra?

Ele registra decisões de política de sandbox e eventos de sessão com principal, ação, alvo, decisão e horário. A Docker diz que os registros contêm metadados de governança, não o conteúdo de prompts ou respostas.

Preciso de um sandbox e de um quadro de tarefas?

Eles respondem a perguntas diferentes. Um sandbox limita o que um comando pode fazer. Uma tarefa registra por que a execução aconteceu, quem é o responsável e quem revisou o resultado. Times com mais de um agente geralmente precisam dos dois.

Um agente pode aprovar seu próprio escalonamento?

Não, em nenhum dos dois designs. No Codex, quem decide é o harness, perguntando ao usuário ou encaminhando para revisão automática. No Docker, quem decide são as regras de confirmação e a política de negação por padrão, não o agente.

Explore mais

Alternativa open source ao Slack: como o ExitPath ajuda você a sair

Alternativa open source ao Slack: como o ExitPath ajuda você a sair

Quer uma alternativa open source ao Slack? Veja o que a ExitPath diz sobre migrar para Mattermost, Zulip ou Element e não deixe o trabalho do seu agente se perder.

20 novembro 2026

GPT-6.2 Astra vs Fable 5.2: teste os dois no seu próprio repositório

GPT-6.2 Astra vs Fable 5.2: teste os dois no seu próprio repositório

GPT-6.2 Astra vs Fable 5.2: qual deve executar seus agentes de código? Veja em que ponto tokens de mesmo preço dividem a conta e teste os dois no seu próprio repositório.

20 novembro 2026

Preços do GPT-6.2: quanto Astra e Sol custam para equipes de agentes

Preços do GPT-6.2: quanto Astra e Sol custam para equipes de agentes

Quer saber o que o preço do GPT-6.2 significa para a sua equipe de agentes? Veja quanto a Astra e a Sol custam por tarefa e conheça os limites que ajudam a manter seus gastos sob controle.

20 novembro 2026