Agent Platform Sandboxes: Na Prática com Code Execution, Shell, Computer Use e Custom Containers
Por Fabio Douek
Conduzido por humano, com apoio de IA. Pesquisa e implementação feitas com ferramentas de IA, conduzidas, testadas e editadas por mim. Como os posts são classificados
Ir para seção
- Visão geral
- Configuração
- Passo 1: Instalar o SDK
- Passo 2: Criar a instância do Agent Runtime
- Passo 3: Permissões para Computer Use e custom containers
- Passo 4: Templates
- Testes
- Teste 1: O que são os sandboxes
- Teste 2: Tempos de criação
- Teste 3: Identidade e rede
- Teste 4: Estado e TTL
- Teste 5: Limites do Code Execution
- Teste 6: Pause vs snapshot
- Teste 7: Computer Use
- Teste 8: Custom containers
- Teste 9: O que é registrado
- Resumo dos resultados
- Monitoramento
- Preços
- Veredito
- O que funciona
- O que ainda não funciona
- Quem deve usar
Explica (TLDR) como se eu fosse...
Imagine uma loja de brinquedos com quatro tipos de caixas de brincar: uma caixa para fazer contas, uma caixa para digitar comandos, uma caixa com um navegadorzinho dentro e uma caixa que você enche com seus próprios brinquedos. Você pede uma caixa para a loja e ela entrega uma em dois segundos, porque guarda algumas de reserva na prateleira.
As caixas podem ser colocadas para dormir e acordadas, e a loja pode tirar uma foto de uma caixa e fazer uma gêmea a partir dela. A caixa de contas, porém, não tem timer na tampa: se você esquecer dela, ela fica na prateleira e a loja continua contando.
O serviço oferece quatro tipos de sandbox gerenciados por trás de uma única API, todos rodando em um projeto gerenciado pelo Google. O acesso à rede vem desligado por padrão, o metadata server é inalcançável mesmo com acesso à internet ligado, e o audit log registra quem criou, pausou ou executou algo em um sandbox.
As lacunas são específicas. Sandboxes de Code Execution não têm expiração padrão e são cobrados enquanto existirem, vários limites documentados diferem do que eu medi, e o audit log não contém o código que foi executado. Confirme a expiração, as cotas e os termos de cobrança do seu contrato.
A necessidade apresentada é um lugar seguro para rodar código escrito por um agente. O tratamento é um sandbox gVisor sem rede por padrão, criado em cerca de dois segundos a partir de um pool pré-aquecido. Nos meus testes, os dois tipos que consegui identificar, Code Execution e Shell, mostraram gVisor.
Efeitos colaterais a monitorar: um sandbox de Code Execution que nunca expira, um resume que retorna antes de o sandbox responder, e uma documentação que discorda do produto sobre tamanhos, limites e o que uma pausa preserva. Peça os exames você mesmo antes de prescrever em larga escala.
É tranquilizador pedir um sandbox e tê-lo em dois segundos, e saber que a rede está fechada, a menos que você a abra. Boa parte da ansiedade que acompanha rodar código gerado desaparece quando os padrões são tão cautelosos.
O atrito aparece nas pequenas surpresas: um sandbox que nunca expira, uma pausa que preserva mais do que a página prometia e um console que não consegue mostrar nada disso. Você acaba conferindo as coisas por conta própria, o que é reconfortante depois de feito e cansativo enquanto você faz.
Pense em quatro instrumentos em um mesmo rack, cada um ligado à mesma mesa de som. Eles entram rápido, porque a mesa mantém alguns aquecidos e prontos, e os dois que consegui ouvir de perto, Code Execution e Shell, ficam na mesma sala acústica, um sandbox gVisor.
O andamento é constante, cerca de dois segundos por take, exceto no caso em que você pede um patch novo e espera quase vinte. Pause é uma nota sustentada: o processo continua soando quando você volta. E nada no palco informa o volume da sala, você lê isso nos logs.
A proposta é uma API para quatro tipos de sandbox: rodar código, rodar comandos de shell, controlar um navegador ou trazer seu próprio container. A criação leva cerca de dois segundos, o acesso à rede vem desligado por padrão, e um sandbox pausado volta com o processo em execução intacto.
A história honesta para um slide: nenhum console de sandbox, um sandbox de Code Execution que nunca expira a menos que você defina um time to live, e uma cobrança de cerca de 18 centavos por hora para o tamanho padrão do Code Execution, durante todo o tempo em que ele existir.
Visão geral
Os sandboxes do Agent Platform são a família de sandboxes do Gemini Enterprise Agent Platform do Google, o produto antes conhecido como Vertex AI. Uma API cria quatro tipos de “container isolado com gVisor” em um projeto tenant gerenciado pelo Google: Code Execution (roda Python ou JavaScript), Shell (roda comandos bash), Computer Use (um navegador Chrome que um agente pode controlar) e custom containers (sua própria imagem do Artifact Registry). A documentação diz que os sandboxes “podem ser de curta duração, baseados em sessão ou stateful por vários dias”, e eles podem ser pausados, ter snapshots criados e ser restaurados. Os estágios de lançamento são desiguais: Shell e Computer Use chegaram a GA em 9 de setembro de 2026, enquanto Code Execution está em preview desde setembro de 2025 sem nenhum aviso de GA, e custom containers, templates e snapshots entraram em preview em 26 de maio de 2026, também sem aviso, embora Shell e Computer Use em GA dependam de templates.
Este post, parte 3 de 6 da série Google Cloud Sandboxes, testa essas afirmações. A Parte 2 cobriu o sandbox por trás do Managed Agents na Gemini API, onde um modelo decide o que rodar. Aqui você chama o sandbox diretamente, com uma simples chamada execute. A Parte 1 mapeia todas as opções do Google Cloud, e as partes 4 a 6 cobrem sandboxes do Cloud Run, o GKE Agent Sandbox e o Agent Substrate no GKE.
Eu testei em 14 de novembro de 2026 em us-central1, com o SDK Python e com chamadas REST diretas, e gravei uma execução limpa de cada teste para o vídeo. Sete resultados se destacaram:
- A criação é rápida quando algo está aquecido. Um sandbox de Code Execution, Shell ou Computer Use a partir de um template levou de 1,0 a 3,0 segundos. Pedir um sandbox Shell sem template levou cerca de 19 segundos, porque o SDK cria um template novo a cada vez. O primeiro sandbox de Code Execution em um projeto novo levou 142 segundos.
- Os tamanhos são quase todos não documentados. Um sandbox Shell padrão tem 0,5 vCPU e 0,5 GiB e o Computer Use tem 2 vCPU e 4 GiB; a documentação não informa nenhum dos dois. O sandbox de Code Execution reporta 2 GiB, não os 1,5 GiB documentados.
- A rede é fechada, e o metadata server é fechado mesmo quando a rede não é. Com acesso à internet ligado,
www.google.come um IP puro responderam; o metadata server e as faixas privadas continuaram dando timeout. - Um sandbox de Code Execution nunca expira por padrão. Shell e Computer Use ganham 2 horas. Todos são cobrados enquanto existirem.
- Pause preserva mais do que a documentação diz. Um processo em segundo plano, um pacote e o boot id sobreviveram a uma pausa. Um snapshot restaurado em um novo sandbox também os preservou.
- O audit log registra o ciclo de vida, mas não o trabalho. Create, pause, resume e snapshot são registrados, e
executeé registrado quando os Data Access logs estão ligados, mas o código que eu rodei não apareceu em lugar nenhum. - Nenhum console mostra nada disso. A página do Agent Runtime não lista nenhuma instância e nenhum sandbox. Cotas, logs e cobrança são as únicas visões do console.
Configuração
Novo no Google Cloud? Tudo vive em um projeto: as APIs que você ativa, as permissões e a cobrança. Eu usei um projeto dedicado e com cobrança em us-central1, com o billing ativado e estas APIs ligadas: aiplatform, artifactregistry, cloudbuild, iamcredentials e logging.
Passo 1: Instalar o SDK
python3.12 -m venv .venv && .venv/bin/pip install google-cloud-agentplatform==2.9.0 google-genai httpx requests websockets
Tudo usa agentplatform.Client().sandboxes.* com api_version="v1beta1": a API GA v1 não tem computerUseEnvironment nem bidiExecute, e todo quickstart fixa v1beta1. O quickstart do Shell mistura um SDK mais antigo (vertexai); eu usei apenas o agentplatform. Versões: Python 3.12.13, google-cloud-agentplatform 2.9.0, google-genai 3.3.0, Google Cloud CLI 593.0.0.
Passo 2: Criar a instância do Agent Runtime
Todo sandbox, template e snapshot é filho de uma instância do Agent Runtime, o mesmo recurso que hospeda agentes implantados. Você não precisa fazer deploy de um agente nela. O client.runtimes.create() exige pacotes extras, então criei a instância com uma chamada REST (t0_setup.py):
curl -s -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H 'Content-Type: application/json' \
"https://us-central1-aiplatform.googleapis.com/v1beta1/projects/$PROJECT/locations/us-central1/reasoningEngines" \
-d '{"displayName": "sbx-part3"}'
Ela ficou pronta em cerca de dois segundos. O SDK exige Application Default Credentials; para evitar um login no navegador, o sbx.py do repositório complementar entrega a ele o seu token do gcloud. Abra com python -i sbx.py e você tem um client pronto e helpers de uma linha.
Passo 3: Permissões para Computer Use e custom containers
Code Execution e Shell precisam apenas de roles/aiplatform.user para quem chama. O Computer Use fala com o endpoint HTTPS do próprio sandbox com um JWT assinado via iamcredentials, então precisa de uma service account com roles/aiplatform.user, e quem chama precisa de roles/iam.serviceAccountTokenCreator nela. As mudanças de IAM levaram um ou dois minutos para valer: minha primeira chamada de token retornou 403 e funcionou alguns minutos depois.
Custom containers precisam de um repositório no Artifact Registry e de roles/artifactregistry.reader para service-<project number>@gcp-sa-vertex-sandbox.iam.gserviceaccount.com. O Cloud Build também falhou no início: a service account padrão do Compute do projeto não tinha acesso ao próprio bucket de código-fonte, então concedi a ela roles/cloudbuild.builds.builder.
Passo 4: Templates
Code Execution recebe uma spec inline. Shell e Computer Use são baseados em template: um template nomeia a categoria do container, seu tamanho e sua configuração de rede, e a plataforma mantém um pool de sandboxes prontos para ele. Eu criei três, uma vez, e os reutilizei (t1_create.py): Shell com internet desligada, Shell com internet ligada e Computer Use.
Testes
Teste 1: O que são os sandboxes
# Code Execution: ask Python
os.cpu_count(), MemTotal, platform.uname(), dmesg
# Shell: bash
uname -r; dmesg | head -2; id; nproc; free -m
# Computer Use: ask the browser
navigator.hardwareConcurrency, navigator.userAgent
| Code Execution | Shell | Computer Use | |
|---|---|---|---|
| Kernel | 4.19.0-gvisor | 4.19.0-gvisor | (somente navegador) |
| dmesg | ”Starting gVisor…" | "Starting gVisor…“ | n/a |
| Usuário | root (uid 0) | appuser (uid 999) | n/a |
| SO e runtime | Python 3.12.5, Node 18 | Debian 12, Python 3.11.2, sem Node | Chrome 139 no Linux |
| Memória vista por dentro | 2 GiB (4 GiB no tamanho maior) | 512 MiB | n/a |
| Tamanho atribuído pela plataforma | docs: 2 vCPU, 1,5 GiB | 0,5 vCPU, 0,5 GiB | 2 vCPU, 4 GiB |
Code Execution e Shell são gVisor, cujo dmesg recebe você com “Starting gVisor…” e um boot log bem-humorado. No Computer Use eu só pude perguntar ao navegador, então não tenho uma string de kernel para ele, e os custom containers que testei servem apenas HTTP, então também não fiz o fingerprint deles. Os tamanhos deram trabalho. O Code Execution tem duas configurações de máquina, e MACHINE_CONFIG_VCPU4_RAM4GIB me deu 4 GiB por dentro, mas ambas reportam 8 CPUs, as do host, então a contagem de vCPU não pode ser lida de dentro; a documentação diz 2 e 4. Os tamanhos de Shell e Computer Use não são documentados. Cada sandbox tem um routing token, um JWT, com as claims machine_vcpu e machine_memory_gib, e os resources.limits do template dizem o mesmo: Shell 0,5 vCPU, 0,5 GiB (512 Mi), Computer Use 2 vCPU, 4 GiB. O nproc de um sandbox Shell reporta 2 CPUs enquanto o limite é 0,5.
Teste 2: Tempos de criação
op, secs = timed(client.sandboxes.create, name=rt, config={"sandbox_environment_template": tpl, "ttl": "600s"})
| Criação | Execuções | Tempo |
|---|---|---|
| Code Execution, spec inline | 5 | 1,0 a 2,4 s (mediana 1,6 s) |
| Shell, a partir de um template | 5 | 1,6 a 3,0 s (mediana 1,7 s) |
| Computer Use, a partir de um template | 3 | 1,6 a 2,1 s (mediana 1,7 s) |
| Shell, spec inline, sem template | 2 | 18,5 e 19,3 s |
| Um template, da criação até ACTIVE (três em paralelo) | 3 | 17,8 a 18,0 s |
A documentação promete “menos de um segundo” para Code Execution (não alcançado: 1,0 a 2,4 segundos, mais 0,5 a 1,1 segundo para o primeiro execute) e “cerca de 20 segundos” para Shell, que foi o que obtive somente sem um template. Com um template, a plataforma entrega um sandbox de um warm pool pré-aquecido. O recurso REST diz o tamanho desse pool: todo template que criei tinha warmPoolConfig.targetInstanceCount: 10, um padrão não documentado. Os sandboxes Shell que peguei de um pool já estavam de pé havia entre 105 segundos e 27 minutos (/proc/uptime).
Mais duas coisas. A criação inline do Shell cria um template novo a cada vez: depois de duas criações, a instância tinha dois templates extras chamados shell-sandbox-template, que mantêm seus warm pools, e o SDK nunca os apaga. E o “cold” é real, mas só na primeira vez: meu primeiro sandbox de Code Execution em um projeto novo levou 142 segundos (a documentação diz “até 2 minutos”), o primeiro template em uma nova instância do Agent Runtime levou cerca de 2 minutos e 40, e uma segunda instância no mesmo projeto não mostrou nada disso: 2,1 segundos, e templates prontos em 18 segundos. O campo REST warmPoolConfig não está no SDK, mas funciona: criei um template com um pool de 1, que testes posteriores usaram para os custom containers mais baratos. Um template com pool de 0 nunca produziu um sandbox nos 13 minutos que esperei.
Teste 3: Identidade e rede
whoami; id; sudo -n true; env | wc -l; which curl
python3 probe.py <url> # prints the HTTP status, or why it failed
O sandbox Shell roda como appuser, não tem sudo, não tem curl, tem 21 variáveis de ambiente e nenhuma com nome de secret, além de 8 variáveis KUBERNETES_*: é um pod. Depois, as mesmas sondas contra cada destino, com acesso à internet desligado e ligado no template, e Code Execution como controle:
| Destino | Shell, internet desligada | Shell, internet ligada | Code Execution |
|---|---|---|---|
| Metadata server (169.254.169.254) | timeout | timeout | inalcançável |
metadata.google.internal | sem DNS | sem DNS | sem DNS |
www.google.com | sem DNS | HTTP 200 | sem DNS |
storage.googleapis.com | sem DNS | HTTP 400 (o servidor respondeu) | sem DNS |
| 8.8.8.8 (IP puro) | timeout | HTTP 200 | inalcançável |
| 10.128.0.2, 192.168.0.1 (privados) | timeout | timeout | inalcançável |
pip install cowsay | falha | funciona | falha |
Com a internet desligada, o DNS não resolve e IPs puros dão timeout. Com ela ligada, o sandbox recebe a internet pública, mas não o metadata server nem as faixas privadas, como documentado. Não há allowlist no meio: o campo do template é um booleano, e o controle por domínio exige um VPC attachment com um firewall que você mesmo opera. Então “acesso à internet” é tudo ou nada, diferente das allowlists da parte 2. A nota de GA vende o Shell para instalar pacotes, mas sem internet e sem root, isso só funciona depois que você abre a rede e instala no virtualenv gravável pelo usuário (/opt/venv): pip install --user falha ali.
Teste 4: Estado e TTL
run(sb, "x = 41"); run(sb, "print(x + 1)") # 42
rest("GET", sandbox)["expireTime"] # after creating with no ttl
O Code Execution mantém seu estado Python entre as chamadas. Quanto à expiração, a documentação discorda de si mesma (2 horas, 7 dias, 14 dias, “não é excluído automaticamente”). Criei cada tipo sem ttl e li de volta via REST:
| Tipo | Expiração padrão |
|---|---|
| Code Execution | nenhuma: nenhum expireTime |
| Shell | 2 horas |
| Computer Use | 2 horas |
Também criei um sandbox de Code Execution e um Shell com ttl: 300s, rodei um comando aos 240 segundos e li expireTime de novo: ele não se mexeu. Um execute não reinicia o relógio, embora o quickstart do Code Execution diga que cada execução reinicia. Após a expiração, um GET retornou 404 e o audit log mostrou uma entrada AutoDeleteSandboxEnvironment.
ttl nunca expira, e sandboxes são cobrados enquanto existirem. No preço de tabela para o tamanho padrão documentado, isso dá cerca de US$ 0,18 por hora, US$ 4,40 por dia. Sempre defina um ttl.
Teste 5: Limites do Code Execution
client.sandboxes.execute_code(name=sb, input_data={"code": code, "files": [...]})
- JavaScript funciona: com
code_language: LANGUAGE_JAVASCRIPT,console.log(process.version, typeof require)imprimiu Node v18.20.1 efunction. A visão geral não menciona JavaScript. - As bibliotecas vêm pré-instaladas, o pip não: numpy 2.1.3, pandas 2.2.3, matplotlib 3.10.1, openpyxl 3.1.5, scipy 1.15.2 e Pillow estão lá;
pip install cowsayfalhou, já que o sandbox não tem rede. - Arquivos de saída voltam como chunks extras com um nome de arquivo: um PNG do matplotlib (16.656 bytes) e um XLSX (4.850 bytes) chegaram como arquivos válidos. Os dados já são bytes brutos: o
content.b64decode()do exemplo da documentação é um bug, e umbase64.b64decodetambém não é necessário. - O limite de 100 MB não pegou. Enviei 99 e 101 MiB como arquivos de entrada, e ambos funcionaram (
blob101.bin 105906176bytes por dentro). Cada um levou cerca de 9 minutos na minha conexão doméstica, então rodei este fora da execução gravada (t5b_upload.py).
Teste 6: Pause vs snapshot
Eu preparei um sandbox Shell com internet ligada: um http.server em segundo plano, um arquivo em /workspace, outro em /tmp, um pacote instalado e o boot id. Depois:
client.sandboxes.pause(name=sb)
client.sandboxes.resume(name=sb)
snap = client.sandboxes.snapshots.create(source_sandbox_environment_name=sb, config={"ttl": "7200s"})
new = client.sandboxes.create(name=rt, config={"sandbox_environment_snapshot": snap.name})
| Após pause e resume | Após snapshot e restore (novo sandbox) | |
|---|---|---|
| Processo em segundo plano | vivo, a porta respondeu | vivo, a porta respondeu |
Arquivos em /workspace e /tmp | preservados | preservados |
| Pacote instalado | preservado | preservado |
boot_id | o mesmo | o mesmo |
A documentação diz que uma pausa preserva o sistema de arquivos e que um snapshot preserva também a memória. Nas minhas execuções, ambos preservaram o processo em execução e o mesmo boot id, então não consegui distingui-los por esse caminho. Os tempos nas minhas execuções: pause de 5,3 a 9,8 segundos, resume() de 4,1 a 8,5 segundos, snapshot de 5,1 a 9,4 segundos, restore em um novo sandbox de 4,5 a 8,1 segundos. O sandbox restaurado é um recurso diferente, e a origem continuou rodando depois. Um segundo restore do mesmo snapshot também funcionou.
As surpresas estão nas bordas:
- Rodar um comando em um sandbox pausado o retoma. A chamada falha com
503 UNAVAILABLE: Sandbox environment is paused; resume has been initiated. Please retry the request.e uma dica de retry de 10 segundos, e o sandbox estava rodando de novo 4 a 5 segundos depois. A documentação diz que o data plane “retorna erros até você retomar”. - O
resume()retorna antes de o sandbox responder. Após umresume()explícito, o primeiro comando que teve sucesso no meu loop de retry (a cada 3 segundos, até 36) veio cerca de 34 segundos depois nas três execuções; após o resume automático, ele respondeu na hora. Trate 34 segundos como “até meio minuto”, não como um tempo de prontidão medido. - Retomar um sandbox em execução não é um erro. Retornou normalmente.
FAILED_PRECONDITIONapareceu apenas enquanto o sandbox ainda estava retomando (must be in PAUSED or STOPPED state to be resumed). - O recurso de snapshot é enxuto. O REST retorna
createTime,expireTime(7.200 segundos, meu ttl),owneresourceSandboxEnvironment, mas nenhumsizeBytese nenhumparentSnapshot, embora a referência documente ambos. Não consegui desenhar uma árvore de ancestralidade nem medir o armazenamento que um snapshot usa. - Code Execution não faz nenhum dos dois. Um snapshot retornou
404 Failed to get OSS Agent Sandbox CRe uma pausa retornou500 Internal error. O texto do 404 é o único lugar onde vi isso, e sugere que a plataforma procura um custom resource do projeto open source Agent Sandbox, o mesmo que o Agent Sandbox do próprio GKE usa (parte 5). Isso é inferência minha, não algo que a documentação diga.
Teste 7: Computer Use
cdp(sb, "Page.navigate", {"url": "https://cloud.google.com/docs"})
png = cdp(sb, "Page.captureScreenshot")["data"]
O sandbox serve uma pequena API HTTP na porta 8080: GET / retorna {"status":"healthy"}, e POST /cdp recebe um comando do Chrome DevTools Protocol. É um Chrome 139 a 1280 por 720. Um navigate mais um screenshot deu um PNG de 190 KB da página inicial da documentação do Google Cloud.

Depois, o loop (cu_loop.py, cerca de 100 linhas com a tradução para CDP): screenshot para o Gemini 3.8 Flash com a ferramenta computer-use, executar a ação do modelo, traduzi-la para CDP (Input.dispatchMouseEvent, Input.insertText, Page.navigate), novo screenshot, no máximo 6 passos. A página do modelo e as páginas do sandbox não referenciam uma à outra, então a cola entre elas é por sua conta.
step 1: click {'x': 608, 'y': 33, ...} step 3: scroll {'direction': 'down', ...}
step 2: type {'text': 'Agent Platform sandboxes', 'press_enter': True} step 4: click {'x': 432, 'y': 84}
Tarefa: pesquisar “Agent Platform sandboxes” na documentação do Google Cloud e abrir o primeiro resultado. Levou 4 ações, cerca de 30.300 tokens (alguns centavos no preço de tabela) e 34 segundos, com 3 a 4 segundos por chamada ao modelo na execução gravada (13 a 17 segundos em uma chamada lenta nas execuções anteriores), e terminou em “Sandboxes overview”. As coordenadas vão de 0 a 999 nos dois eixos e mapeiam para a página de 1280 por 720. Os nomes das ações diferem dos documentados: vi click, type e scroll, não click_at, type_text_at e scroll_document.
noVNC: o sandbox tem três portas, 5091, 8080 e 9222. A porta 5091 serve um cliente noVNC (GET /vnc.html retornou a página de 15.850 bytes, título “noVNC”), que é a visualização ao vivo que a documentação menciona sem informar a porta. Não consegui abrir seu websocket com os headers que o websocket do CDP usa (HTTP 400), então não posso dizer que a visualização ao vivo funciona.

O screenshot que o modelo viu após sua quarta ação: o primeiro resultado da busca, aberto.
Pause e snapshot funcionam também em um navegador. Deixei essa página aberta, pausei e retomei o sandbox, depois criei um snapshot dele e o restaurei em um novo sandbox. A página continuava aberta nas duas vezes. Uma armadilha: em uma tentativa anterior, o objeto de sandbox que eu já tinha em mãos respondeu Bad Gateway: Unable to reach the sandbox environment durante os cinco minutos em que meu loop de retry rodou após um resume. Quando li o sandbox de novo com get() e usei esse objeto novo, ele respondeu em 0,6 segundo. Acredito que o connection_info muda no resume, mas não comparei os valores.
Teste 8: Custom containers
A documentação pede uma imagem Linux com “um runner ou entry point compatível” que “não pode exigir root”, do Artifact Registry. O runner não é descrito em lugar nenhum da documentação, então testei três imagens, todas FROM python:3.12-slim e construídas com gcloud builds submit:
USER 1000
CMD ["python", "-m", "http.server", "8080"] # image 1: HTTP on 8080, non-root
CMD ["sleep", "infinity"] # image 2: no HTTP server
USER 0 # image 3: like image 1, as root
Cada uma recebeu um template com a porta 8080, 1 CPU e 500 Mi (e um warm pool de 1), e depois um sandbox (eu consultei o estado do template a cada poucos segundos, então leia a coluna do template como “cerca de 11 s”):
| Imagem | Template ACTIVE | Sandbox RUNNING | Chamada à porta 8080 |
|---|---|---|---|
HTTP, USER 1000 | cerca de 11 s | 4,5 s | o container respondeu |
| sem servidor HTTP | cerca de 11 s | 4,1 s | Bad Gateway: Unable to reach the sandbox environment |
HTTP, USER 0 | cerca de 11 s | 4,2 s | o container respondeu |
Então o contrato é um servidor em uma porta declarada. A mesma chamada de duas formas: :execute com a URI da requisição e a porta como chunks (o que execute_bash faz para /exec) e send_command pelo data plane. O http.server do Python respondeu à primeira com a própria página 501 Unsupported method ('POST'), o que mostra que o control plane encaminha sua chamada como um POST; send_command com um GET retornou a listagem do diretório. Mais três observações:
RUNNINGnão significa alcançável. A imagem sem servidor chegou aSTATE_RUNNINGem 4 segundos e toda chamada a ela falhou.- Root não foi rejeitado. A imagem
USER 0iniciou e serviu. Não consegui rodaridnela, então não posso dizer qual uid a plataforma realmente usou. - Um repositório recriado quebrou os templates. Eu havia apagado meu repositório do Artifact Registry e o recriado com o mesmo nome e as mesmas permissões. Templates apontando para ele ficaram em
PROVISIONINGpor 25 minutos, e os que apaguei ficaram emDEPROVISIONING. Um repositório com nome novo funcionou na hora.
Teste 9: O que é registrado
Os audit logs de Admin Activity estão sempre ligados. Eu liguei os Data Access logs para aiplatform.googleapis.com (ADMIN_READ e DATA_WRITE), rodei um ciclo de vida de Code Execution, um de Shell (create, execute, pause, resume, snapshot, delete) e um de Computer Use com código que imprime MARKER-4f2a, e li as entradas de volta:
gcloud logging read 'protoPayload.serviceName="aiplatform.googleapis.com" AND protoPayload.methodName:"SandboxEnvironment"' --freshness=1h
| Log | Métodos que apareceram |
|---|---|
| Admin Activity | CreateSandboxEnvironment, DeleteSandboxEnvironment, PauseSandboxEnvironment, ResumeSandboxEnvironment, SnapshotSandboxEnvironment, DeleteSandboxEnvironmentSnapshot (e AutoDeleteSandboxEnvironment quando um ttl acabou, e Create/DeleteSandboxEnvironmentTemplate) |
| Data Access | ExecuteSandboxEnvironment, GetSandboxEnvironment, ListSandboxEnvironments, GetSandboxEnvironmentSnapshot, AuthorizeSandboxEnvironmentAccess |
- Pause e resume são registrados, como Admin Activity. A página geral de audit logging os omite e a visão geral de sandboxes os lista; a visão geral está certa.
- O código não é registrado. Uma busca por
MARKER-4f2aencontrou 0 entradas. Uma entradaExecuteSandboxEnvironmenttem quem chamou, de onde e qual sandbox, e sua requisição contém apenas o nome do sandbox: nenhum código, nenhuma saída. - O Computer Use aparece como verificações de autorização. Os comandos CDP que enviei não são chamadas
execute: o único rastro foiAuthorizeSandboxEnvironmentAccess.
As entradas apareceram em um ou dois minutos, e algumas operações são registradas mais de uma vez. Os Data Access logs acrescentam custo de ingestão, pequeno aqui; desliguei depois.
Resumo dos resultados
| Afirmação ou pergunta | Resultado |
|---|---|
| Isolamento | gVisor (4.19.0-gvisor) em Code Execution e Shell; sem fingerprint em Computer Use ou custom containers |
| ”Menos de um segundo” para criar | 1,0 a 2,4 s a partir do aquecido; 142 s na primeira vez em um projeto |
| Shell “cerca de 20 s” | Cerca de 19 s sem template, 1,6 a 3,0 s com um |
| Tamanhos | Shell 0,5 vCPU / 0,5 GiB, Computer Use 2 / 4, Code Execution 2 GiB por dentro |
| Rede padrão | Desligada. Ligada: internet pública, sem metadata server, sem faixas privadas |
| Expiração padrão | Code Execution nunca, Shell e Computer Use 2 h; execute não a reinicia |
| Code Execution | JavaScript funciona, sem pip, entrada de 101 MiB aceita |
| Pause preserva | O processo, os arquivos, o pacote e o boot id; um comando em um sandbox pausado o retoma |
| Snapshot | Igual ao pause, em um novo sandbox em 4,5 a 8 s; o REST não tem tamanho nem parent |
| Computer Use | CDP puro e um loop com Gemini funcionam; noVNC servido na porta 5091 |
| Custom containers | Um servidor em uma porta declarada; sem servidor ainda chega a RUNNING; root não é rejeitado |
| Auditoria | Ciclo de vida e execute registrados; código e comandos CDP não |
Monitoramento
Não existe uma visão de sandboxes no console do Google Cloud. A página do Agent Runtime (Agents, Deployments) diz “No agent instances” enquanto a instância que guarda meus sandboxes existe:

O que o console mostra:
-
Cotas (IAM & Admin, filtrado por “sandbox”): a documentação publica cotas apenas para Code Execution, mas o projeto tem linhas para toda a família, por região: 500 entidades de sandbox, 500 entidades de template, 400 requisições de escrita de sandbox por minuto, 100 requisições de escrita de template por minuto e 500 requisições de execute por minuto.

-
Logs Explorer: as entradas de auditoria do Teste 9. Nada de dentro de um sandbox: stdout e stderr não são coletados.
-
Cloud Monitoring: listei os 373 tipos de métrica
aiplatform.googleapis.comdo projeto. Nenhum é sobre sandboxes; osreasoning_enginecobrem agentes implantados. -
Billing > Reports agrupa o custo por SKU, mas atrasa: cerca de nove horas depois dos meus primeiros sandboxes, o relatório ainda terminava em 13 de novembro, e nenhum dos SKUs da primeira página era do Agent Platform.
Preços
A página de preços cobra os ambientes de sandbox em dois SKUs, Agent Compute a US$ 0,085 por vCPU-hora e Agent Memory a US$ 0,009 por GiB-hora, arredondados ao segundo, e a documentação diz que os sandboxes são cobrados “enquanto existirem”. Shell e custom containers não são detalhados separadamente, então eu os precifiquei da mesma forma. O Agent Storage custa US$ 0,30 por GiB-mês. Com os tamanhos do Teste 1:
| Sandbox | Tamanho | Por hora | Expiração padrão | Pior caso se esquecido |
|---|---|---|---|---|
| Shell | 0,5 vCPU, 0,5 GiB | US$ 0,047 | 2 h | US$ 0,09 |
| Computer Use | 2 vCPU, 4 GiB | US$ 0,206 | 2 h | US$ 0,41 |
| Code Execution (tamanho da documentação) | 2 vCPU, 1,5 GiB | US$ 0,184 | nenhuma | US$ 4,40 por dia |
| Code Execution, 4 vCPU, 4 GiB | 4 vCPU, 4 GiB | US$ 0,376 | nenhuma | US$ 9,02 por dia |
| Custom container (meu template) | 1 vCPU, 500 Mi | US$ 0,089 | não medido |
Esses são preços de tabela da planilha de preços; não consegui ver minha própria fatura (acima). O que não consigo precificar:
- Warm pools. Todo template mantém 10 sandboxes prontos por padrão. Se eles forem cobrados como sandboxes, um template Shell custaria cerca de US$ 0,47 por hora e um template Computer Use cerca de US$ 2,06 por hora, enquanto ocioso. A documentação não diz. Mantive os templates vivos apenas durante os testes e defini um pool de 1 para os custom containers.
- Sandboxes pausados e snapshots. A documentação diz que um sandbox pausado custa “significativamente menos”, sem nenhum valor, e nenhuma página diz se snapshots são cobrados como Agent Storage. Deixei um sandbox Shell em execução e outro pausado lado a lado por cerca de 40 minutos para comparar, o que é curto demais para o relatório diário de qualquer forma.
- Tokens do modelo para Computer Use: a execução de 4 ações usou cerca de 30.300 tokens, alguns centavos nos preços de tabela do Gemini 3.8 Flash, que dobram em 1º de janeiro de 2027.
No preço de tabela, o tempo de sandbox de toda a exploração e da gravação (várias dezenas de sandboxes curtos) ficou bem abaixo de um dólar. A questão em aberto são os warm pools, que poderiam somar alguns dólares se forem cobrados como sandboxes. Para limpar:
python teardown.py # sandboxes, snapshots, templates, the instance, the repo, the service account, audit logs
Veredito
O que funciona
Criar um sandbox é rápido e uniforme: dois segundos a partir de um warm pool, a mesma API para quatro tipos e gVisor nos dois tipos que consegui identificar. Os padrões são cautelosos: sem rede, sem metadata server mesmo com a rede ligada, um usuário sem privilégios no Shell. Pause é melhor do que o documentado: um processo, uma página de navegador e um pacote voltaram, e um snapshot, que a documentação diz que preserva a memória, é restaurado em um sandbox novo em segundos. O Computer Use é simples de controlar com um loop de cerca de 100 linhas, e o audit log responde quem criou, pausou e rodou o quê.
O que ainda não funciona
Você não vê nada disso no console, e a documentação e o produto discordam em muitos pontos: tamanhos, o limite de 100 MB, o que uma pausa preserva, o que um execute faz com a expiração, as cotas. Um sandbox de Code Execution que nunca expira é um risco de cobrança, e “acesso à internet” é uma única chave sem allowlist. O resume() retorna antes de o sandbox responder, uma conexão obsoleta após um resume do Computer Use responde apenas Bad Gateway, e o recurso de snapshot não tem os campos de tamanho e parent que a referência lista. Se os pools de templates são cobrados ou não, ninguém diz.
Quem deve usar
Use quando você quer sandboxes como uma API sem operar um cluster, e quando a criação em dois segundos e o pause e resume importam mais do que um console. Defina um ttl em tudo, mantenha poucos templates e apague-os, coloque seu próprio firewall na frente se abrir a rede e leia o audit log, não o código, para saber quem fez o quê. Se você precisa ver sandboxes em um console ou rodá-los ao lado das suas próprias workloads, a parte 4 analisa os sandboxes do Cloud Run, e as partes 5 e 6 o GKE.