Vídeo com IA: Claude Code, Codex e ElevenLabs · Capítulo 12 de 25 · 27 min
Configurar o Codex com GPT-6 Astra num sandbox que pede aprovação
Instale o Codex CLI nos três sistemas e deixe o GPT-6 Astra editar e renderizar num sandbox sem rede que pede a sua aprovação antes de gastar qualquer dólar.
Este capítulo faz parte do curso gratuito Vídeo com IA: Claude Code, Codex e ElevenLabs.
Um segundo agente no projeto de vídeo só ajuda se não puder gastar, baixar ou apagar nada por conta própria. O Codex, o agente de programação da OpenAI, não gera vídeo: lê o AGENTS.md (o arquivo de instruções que ele carrega antes de cada tarefa, como o manual de procedimentos de uma cozinha), edita arquivos e executa FFmpeg, Remotion ou MoviePy dentro de um sandbox. Sandbox é o cercado onde o agente trabalha, como a caixa de areia de uma criança: lá dentro ele cava e constrói à vontade; para usar a rede ou sair da pasta, precisa pedir.
Sem esse cercado, o custo aparece na fatura antes do primeiro quadro. Um perfil com acesso total e aprovação desligada deixa o agente chamar a API de imagem em lote sem perguntar o preço, baixar fontes da internet no meio do render e escrever fora do projeto. Com o perfil certo, cada saída da pasta vira um pedido na tela, e a regra de custo fica escrita num arquivo que o agente relê em toda sessão.
Nesta aula você instala o Codex CLI estável (versão 0.162.1, de 09/10/2026) no macOS, no Linux ou no Windows, escolhe entre GPT-6 Astra, GPT-6.1 Sol e GPT-6 Luna, escreve o ~/.codex/config.toml com workspace-write e aprovação on-request, cria o AGENTS.md do projeto de vídeo e roda o Codex sem interface com codex exec e resposta validada por schema.
Instalar o Codex e escolher o modelo
Instale pelo script oficial do seu sistema e confira a versão logo em seguida. Se você seguiu a bancada da aula 3, o FFmpeg já está no PATH, e é ele que o Codex vai chamar nos renders. No primeiro uso ele pergunta como você entra: "Sign in with ChatGPT" usa a assinatura, e a chave de API cobra pela tabela da API. A assinatura do ChatGPT não inclui créditos de API, e quem entra só com chave não tem as tarefas na nuvem.
No Windows, o Codex roda em PowerShell nativo com o sandbox do próprio Windows ou dentro do WSL2 (o Linux que o Windows hospeda). A 0.162.0, de 08/10/2026, trouxe correções justamente nesse sandbox, e a 0.162.1, de 09/10/2026, corrigiu o travamento da interface com perguntas de várias linhas, então não fique em versões antigas. O GPT-6 Astra exige a 0.153.0 ou mais nova e só aparece no seletor de modelo a partir da 0.154.0, de 09/09/2026.
Instale o Codex CLI no seu sistema
macOS e Linux
# Script oficial (macOS e Linux), lido em 09/10/2026
curl -fsSL https://chatgpt.com/codex/install.sh | sh
# Alternativa no macOS: Homebrew
# brew install --cask codex
# Em CI ou máquina sem tela: instalação sem perguntas
# curl -fsSL https://chatgpt.com/codex/install.sh | CODEX_NON_INTERACTIVE=1 sh
codex --version # estável em 12/10/2026: 0.162.1 (o Astra exige 0.153.0 ou mais nova)
codex # primeiro uso: "Sign in with ChatGPT" ou chave de APISe codex --version responder "command not found", feche e abra o terminal para recarregar o PATH e rode de novo.
Windows
# Windows (PowerShell), lido em 09/10/2026
powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
codex --version # estável em 12/10/2026: 0.162.1 (o Astra exige 0.153.0 ou mais nova)
codex # roda com o sandbox do Windows
# Prefere Linux? Dentro do WSL2 use o script do macOS e Linux:
# wsl
# curl -fsSL https://chatgpt.com/codex/install.sh | shEscolha um lado e fique nele: se o projeto mora no WSL2, instale e rode o Codex lá dentro. Um único lado evita dois config.toml diferentes na mesma máquina.
Se a CLI 0.157.0 recusar abrir num terminal de administrador, reclamando do daemon (o servidor em segundo plano que as sessões do Windows compartilham desde a 0.154.0), abra um terminal comum ou rode codex --no-daemon; a 0.161.0, de 07/10/2026, corrigiu. Desde 07/10/2026, o app de desktop 26.1002 falha em todo comando com helper_unknown_error; no Windows, prefira a CLI pelo instalador oficial até a correção sair.
npm (qualquer sistema)
# Exige Node recente; com Node antigo o npm global falha por permissão
npm install -g @openai/codex
codex --versionUse o npm só se o Node da aula 3 estiver em dia. Erro de permissão no -g é sinal para voltar ao script oficial.
Escolher o modelo é escolher quanto cada pensamento custa. O GPT-6 Astra (gpt-6-astra, lançado em 03/09/2026) é o modelo mais capaz da OpenAI: contexto de 1,05 milhão de tokens, saída de até 128 mil e conhecimento até 30/04/2026, e não aceita temperature, top_p nem esforço none. O GPT-6.1 Sol (gpt-6.1-sol, do DevDay de 29/09/2026) entrega quase tudo o que um pipeline de vídeo precisa por um quinto do preço, e por isso é o padrão deste curso; o Astra entra por chamada, com -m gpt-6-astra, quando o Sol falha duas vezes no mesmo problema.
Quando a tarefa é planejar cenas, revisar um script ou escrever um corte de FFmpeg, fique no 6.1 Sol. Diante de um bug de sincronia entre áudio e legenda que resistiu a duas rodadas, troque para o Astra só naquela chamada. Para checagens mecânicas em volume, como conferir 40 nomes de arquivo, o Luna resolve por centavos. Desde a 0.159.1, de 29/09/2026, quem não define model já cai no 6.1 Sol. Se o seu config.toml ainda aponta gpt-5.5, troque agora: o modelo sai do Codex em 14/10/2026 (a API não muda).
Os modos Fast e Ultrafast não compensam aqui: o gargalo de vídeo é o render, não o modelo. O Ultrafast gera até 300 tokens por segundo, mas na API custa seis vezes o Standard (US$ 60 / US$ 300 por milhão no Astra desde 29/09/2026; US$ 12 / US$ 60 no 6.1 Sol desde 08/10/2026) e, no Codex, só existe no Pro 500 e em Enterprise ou Edu elegíveis, gastando 8 vezes a cota incluída. No Plus, no Pro 100 e no Pro 200 ele não existe, nem pago com créditos.
Modelos e cota do Codex em 12/10/2026
layers Modelos do Codex e da API
Modelos do Codex e da API em 12/10/2026
| Modelo | Preço por 1M de tokens (entrada / saída) | Quando usar |
|---|---|---|
| gpt-6.1-sol | US$ 2 / US$ 10 (cache US$ 0,10) | Padrão do curso e da CLI desde a 0.159.1: planejar, revisar, scripts de corte |
| gpt-6-astra | US$ 10 / US$ 50 (cache US$ 1) | Só na chamada em que o Sol falhou duas vezes |
| gpt-6-luna | US$ 0,10 / US$ 0,50 (cache US$ 0,01) | Checagens mecânicas e lote barato |
| gpt-6-sol | US$ 2 / US$ 10 (cache US$ 0,20) | Lançado em 22/09/2026; substituto oficial do gpt-5.3-codex |
| gpt-6-instant | Não é id de API | Nome de comportamento da aba Chat; não configure |
| gpt-5.3-codex | Descontinuado em 01/10/2026; sai em 01/04/2027 | Troque pelo gpt-6-sol ou pelo 6.1 Sol |
| gpt-5.5 | Sai do Codex em 14/10/2026; a API continua | Tire do config.toml |
Acima de 272 mil tokens de entrada, a entrada dobra e a saída sobe 1,5 vez. No Plus (US$ 20/mês), a janela de 5 horas comporta de 5 a 45 mensagens de Astra, de 15 a 160 de 6.1 Sol e de 350 a 3.000 de Luna.
Fonte: OpenAI, tabela de preços Standard, changelogs e página de descontinuações, lidas em 12/10/2026
scale Contar a cota em créditos do plano
Na assinatura, o Codex não cobra em dólar: cada modelo consome créditos do plano por milhão de tokens. Na tabela lida em 12/10/2026, o Astra gasta 250 créditos por milhão de tokens de entrada, 25 no cache e 1.250 na saída; o 6.1 Sol gasta 50, 2,5 e 250; o Luna, 2,5, 0,25 e 12,5. Um turno de Astra pesa como cinco de 6.1 Sol e cem de Luna. O modo Fast gasta 2,5 vezes a cota incluída. No Plus, o Astra vem com uso limitado e créditos opcionais depois; Pro 100, Pro 200 e Business Premium usam a cota inteira.
Antes de trocar de modelo numa sessão longa, rode /status na CLI: ele mostra qual limite está valendo e quanto resta. Se a janela de cinco horas passou da metade e ainda falta o render, volte o executor para o 6.1 Sol e deixe o Luna nas checagens de nome de arquivo. Desde 29/09/2026, o Codex Cloud está em todos os planos pagos, e as tarefas na nuvem saem da mesma cota, podendo gastar mais que as locais. O erro comum é deixar model = "gpt-6-astra" fixo no config.toml: a cota da semana some numa tarde. O conserto é o Astra só por chamada, com -m. Está certo quando você sabe dizer, antes de começar, quantos turnos de Astra a semana comporta.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Fechar o sandbox e a aprovação no config.toml
O ~/.codex/config.toml é o arquivo de preferências do Codex, compartilhado entre a CLI e a extensão de IDE (VS Code, Cursor e Windsurf). Três chaves decidem a segurança. sandbox_mode aceita read-only, workspace-write e danger-full-access. approval_policy aceita on-request, never ou um objeto granular; on-failure está deprecado e untrusted foi aposentada na documentação atual. A rede começa desligada e só abre com network_access = true dentro de [sandbox_workspace_write]. Mesmo em workspace-write, as pastas .git, .agents e .codex ficam só para leitura, com tudo o que há dentro delas.
No modo Auto da interface, o preset equivale a --sandbox workspace-write --ask-for-approval on-request: o agente edita e roda comandos no projeto e pede aprovação para usar a rede ou sair dele. É exatamente o que um projeto de vídeo precisa. Se quiser entender por que dar menos poder ao agente é a escolha padrão, a aula de segurança e governança de agentes mostra o mesmo raciocínio aplicado a qualquer ferramenta.
# ~/.codex/config.toml (no Windows: %USERPROFILE%\.codex\config.toml)
# Perfil seguro para projeto de vídeo, 09/10/2026
model = "gpt-6.1-sol" # US$ 2 / US$ 10 por 1M; Astra só com -m gpt-6-astra
model_reasoning_effort = "medium"
sandbox_mode = "workspace-write" # edita e roda comandos só dentro do projeto
approval_policy = "on-request" # nunca "never"; "on-failure" é deprecado e "untrusted" foi aposentada
approvals_reviewer = "user" # quem aprova é você, não "auto_review"
[sandbox_workspace_write]
network_access = false # ligue só na sessão que chama API de imagem ou de voz
# Servidor MCP de documentação da OpenAI (o Codex é cliente MCP)
[mcp_servers.openaiDeveloperDocs]
url = "https://developers.openai.com/mcp"Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Por que o curso não usa danger-full-access
shield A página oficial de aprovações e segurança

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
scale Perfil inseguro x perfil do curso
Por que não usar danger-full-access no projeto de vídeo
danger-full-access com never
Coluna a evitar
- Sem cercado: o agente lê e escreve em qualquer pasta da máquina
- Rede aberta: baixa pacotes e chama APIs pagas sem perguntar
- Nenhuma pausa para você aprovar, nem diante de um lote de imagens
- A regra de custo do AGENTS.md vira sugestão, porque nada obriga a parar
workspace-write com on-request
Coluna recomendada
- Edita e renderiza só dentro da pasta do projeto
- Rede desligada até você abrir uma sessão própria para APIs
- Pedido de aprovação na tela antes de sair da pasta ou usar a rede
- .git, .agents e .codex só para leitura
Escrever o AGENTS.md do projeto de vídeo
O Codex monta as instruções em camadas. Primeiro lê o global, ~/.codex/AGENTS.override.md ou ~/.codex/AGENTS.md (a variável CODEX_HOME muda essa raiz); depois lê um arquivo por diretório, da raiz do repositório até a pasta atual, com o AGENTS.override.md antes do AGENTS.md. O mais próximo da pasta onde você está prevalece. O comando /init cria um esqueleto, que você substitui pelo modelo abaixo.
Todos os AGENTS.md somados têm teto de 32 KiB (project_doc_max_bytes). Um arquivo de projeto de vídeo cabe em 3 KiB: estrutura de pastas, regras e verificação. Roteiro inteiro não entra ali, porque o que passar do teto deixa de ser lido. A ideia de um arquivo único que qualquer assistente entende é a mesma da aula sobre o arquivo que todo assistente de IA entende, e é ela que permite, na aula 14, apontar Claude Code e Codex para as mesmas regras.
# AGENTS.md - projeto video-ia (Cozinha da Rafa)
## Estrutura
- roteiro/ roteiro.md (fonte da verdade do texto narrado, pt-BR com acentuação completa)
- storyboard/ cenas.json e quadros-chave PNG (gpt-image-2.5-flare; edição com gpt-image-2.5-sunburst)
- config/schemas/ cenas.json (schema do plano de cenas)
- audio/ narracao.mp3 (ElevenLabs eleven_v4) e trilha.mp3
- legendas/ narracao.srt (Scribe v2, tempo por palavra)
- composicoes/ cozinha-remotion/ (projeto Remotion: src/, public/); render grava em renders/
- marca/ paleta.png e fontes/ (fontes locais do render)
- renders/ MP4 final (não commitar mídia nem chaves)
## Regras
- NÃO chamar /v1/videos nem sora-2 ou sora-2-pro: desligados em 24/09/2026, sem substituto.
- Ids de modelo vêm do .env (MODEL_IMAGE, MODEL_VIDEO, MODEL_TTS). Nunca escrever id no código.
- Antes de chamar API paga, mostrar o custo estimado em dólar e esperar minha confirmação.
- Render padrão: H.264, yuv420p, 30 fps, -crf 20, AAC 192k, -movflags +faststart.
- 16:9 = 1920x1080; 9:16 = 1080x1920; área segura de 10% nas bordas.
- Fontes só de marca/fontes/ e imagens só de marca/ e storyboard/; nada baixado da internet durante o render.
- Rosto de pessoa real só com autorização por escrito. Avisar no vídeo que a voz é gerada por IA.
## Quando a tarefa está pronta
- Pronto = renderizar, rodar ffprobe e corrigir até a duração ficar a até 0,5 s do áudio.
- Permissão permanente, sem pedir: ffmpeg, ffprobe, npx remotion render e leitura de arquivos do projeto.
- Pare e peça aprovação só para: rede, API paga e escrita fora da pasta do projeto.
## Verificação
- `ffmpeg -version` antes de qualquer render.
- `cd composicoes/cozinha-remotion && npx remotion render src/index.ts Receita ../../renders/receita.mp4` termina sem erro.
- `ffprobe -v error -show_entries format=duration renders/receita.mp4` difere no máximo 0,5 s do áudio.Diga ao agente onde a tarefa termina. O guia da OpenAI sobre prompts e skills para o Astra, publicado entre 11 e 12/09/2026, avisa que um AGENTS.md cheio de "pergunte antes" faz o modelo parar onde você queria que ele continuasse e devolver a tarefa pela metade. Por isso o modelo acima ganhou três linhas: o que é pronto (renderizar, rodar ffprobe e corrigir até a duração bater), a permissão permanente para os comandos seguros que você já conhece e a pausa restrita a rede, API paga e escrita fora do projeto. A regra de custo continua; ela só deixou de ser genérica.
O mesmo guia pede ponteiros em vez de ordens de leitura: "o texto narrado está em roteiro/roteiro.md" custa uma linha, enquanto "leia todos os docs antes de cada edição" consome contexto em toda chamada e deixa o Astra lento. Ele também dispensa "rode os testes", porque o Astra já roda a verificação sozinho. Se o Codex parar no meio do render pedindo um sim que você daria sempre, falta aquele comando na linha de permissão permanente: acrescente e rode de novo.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Rodar sem interface com codex exec e ligar MCP
O codex exec roda uma tarefa do começo ao fim, sem conversa, e é o que transforma o Codex em peça de script. Ele começa em read-only; --sandbox workspace-write libera a escrita, e o antigo --full-auto está obsoleto. Quatro opções fazem o trabalho pesado: --output-schema obriga a resposta a caber num schema (o molde do JSON, como a forma de um bolo: o que não couber faz a chamada falhar em vez de devolver texto solto), -o grava a última mensagem num arquivo, --json emite os eventos linha a linha e --ephemeral não guarda a sessão. Para continuar de onde parou, codex exec resume --last. Em CI, exporte CODEX_API_KEY.
Três tempos formam o padrão do curso: planejar em read-only com schema, renderizar em workspace-write e continuar a mesma sessão com resume --last. O script abaixo cria o schema, roda os três tempos e confere o plano com jq.
#!/usr/bin/env bash
# scripts/pipeline_exec.sh - roda na raiz video-ia; planeja em read-only (padrão do exec), renderiza com escrita, continua a sessão
set -euo pipefail
mkdir -p config/schemas storyboard renders
# 0) Schema do plano de cenas: additionalProperties false impede campos inventados
cat > config/schemas/cenas.json <<'JSON'
{
"type": "object",
"properties": {
"cenas": {
"type": "array",
"items": {
"type": "object",
"properties": {
"id": { "type": "integer" },
"duracao_s": { "type": "number" },
"texto_narrado": { "type": "string" },
"prompt_quadro": { "type": "string" }
},
"required": ["id", "duracao_s", "texto_narrado", "prompt_quadro"],
"additionalProperties": false
}
}
},
"required": ["cenas"],
"additionalProperties": false
}
JSON
# 1) Plano de cenas: read-only, resposta validada pelo schema e gravada com -o
codex exec -m gpt-6.1-sol \
"Leia roteiro/roteiro.md e devolva as cenas com duração, texto narrado e prompt de quadro-chave" \
--output-schema ./config/schemas/cenas.json -o ./storyboard/cenas.json
jq '.cenas | length' storyboard/cenas.json # número de cenas; erro aqui = JSON fora do molde
# 2) Render com escrita no workspace (--full-auto está obsoleto)
codex exec --sandbox workspace-write \
"Use storyboard/cenas.json para montar a composição Remotion em composicoes/cozinha-remotion, renderize renders/receita.mp4 e rode ffprobe no final"
# 3) Continua a mesma sessão, sem repetir o contexto
codex exec resume --last "Exporte também a versão 1080x1920 com legenda queimada"
# Em CI: export CODEX_API_KEY=... antes dos comandos (cobrado pela tabela da API)No Codex, o MCP explicado na aula 9 funciona sempre como cliente: codex mcp add <nome> -- <comando> liga um servidor local, codex mcp add <nome> --url <endereço> liga um remoto com Bearer ou OAuth, codex mcp login <nome> autentica e codex mcp list mostra o estado. O modo inverso, codex mcp-server, que expunha o Codex a outro agente, foi removido em 05/09/2026. Antes de ligar qualquer servidor, meça o que ele pode fazer com a aula sobre o grau de poder de cada servidor.
As skills do Codex são pastas com um SKILL.md (campos name e description obrigatórios) em .agents/skills, chamadas por $nome ou /skills; a lista inicial ocupa no máximo 2% do contexto e o arquivo completo só carrega quando usado. As skills oficiais do Remotion servem ao Codex, ao Claude Code e ao Cursor. O diretório oficial openai/plugins traz remotion, hyperframes e codex-security. O AGENTS.md cumpre no Codex o papel que o CLAUDE.md da aula 7 cumpre no Claude Code, e o app do Codex importa essa configuração em Settings, General, Import other agent setup.
Para render longo, o Codex Cloud roda a tarefa numa máquina da OpenAI a partir de um repositório GitHub, mesmo com o seu computador desligado. O ambiente é criado na web ou no app do Codex: ele lê o repositório e propõe a preparação, que instala dependências e ferramentas, e você revisa antes de publicar. Confira se o FFmpeg está nessa preparação. A internet é um ajuste do próprio ambiente (Allow Codex to access internet), com três presets: Package managers, que já inclui os repositórios do Ubuntu e do Debian, Custom domains only, em que você lista cada domínio, e All. A máquina tem teto: no Plus, 2 vCPUs, 8 GiB de memória e 8 GiB de disco; no Pro, Business, Enterprise e Edu, 4 vCPUs, 16 GiB e 32 GiB. No Plus cabe um corte 9:16 por tarefa, não a semana inteira de renders.
#!/usr/bin/env bash
set -euo pipefail
# MCP: o Codex é cliente (codex mcp-server foi removido em 05/09/2026)
codex mcp add openaiDeveloperDocs --url https://developers.openai.com/mcp # remoto
codex mcp add context7 -- npx -y @upstash/context7-mcp # local (STDIO)
codex mcp list # nome, tipo e autenticação
# Skills oficiais do Remotion: vão para .agents/skills e servem a Codex, Claude Code e Cursor
npx skills add remotion-dev/skills
# Codex Cloud (só com login do ChatGPT; chave de API não tem nuvem)
# Plus: 2 vCPUs, 8 GiB de memória e 8 GiB de disco; um render longo por tarefa
# Na preparação do ambiente (revisada antes de publicar), confira que o FFmpeg entra:
# apt-get update && apt-get install -y ffmpeg
codex cloud exec --env "$CODEX_ENV_ID" "Renderize os três cortes 9:16 da semana e rode ffprobe em cada um"
# Quando a tarefa terminar, traga o diff para o repositório local:
# codex apply TASK_IDConfigure o Codex para render seguro em oito passos
Siga na ordem, dentro da pasta do projeto de vídeo. Cada passo tem o sinal de que deu certo e o erro que mais aparece.
Passo 1: Instale e autentique
Rode o instalador do seu sistema e depois `codex --version`.
Deu certo quando: O terminal imprime 0.162.1 ou superior (0.153.0 é o mínimo para o Astra) e o Codex abre pedindo login.
Erro comum: Instalar pelo npm com Node antigo e receber erro de permissão global.
Passo 2: Escolha o modelo no config.toml
Defina `model = "gpt-6.1-sol"` e `model_reasoning_effort = "medium"`.
Deu certo quando: Ao abrir `codex`, o rodapé mostra o modelo escolhido.
Erro comum: Configurar `gpt-6-instant`, que não é id de API, ou manter `gpt-5.5`, que sai do Codex em 14/10/2026.
Passo 3: Feche o sandbox
`sandbox_mode = "workspace-write"`, `approval_policy = "on-request"` e `network_access = false`.
Deu certo quando: Pedir "baixe o pacote X da internet" gera um pedido de aprovação.
Erro comum: Usar `on-failure` (deprecado) ou `untrusted` (aposentada).
Passo 4: Crie o AGENTS.md
Rode `/init` e troque o esqueleto pelo modelo desta aula.
Deu certo quando: Perguntado sobre as pastas do projeto, o Codex responde com a estrutura do arquivo.
Erro comum: Colar o roteiro inteiro e passar de 32 KiB somados.
Passo 5: Rode o primeiro codex exec em read-only
Peça o plano de cenas com `--output-schema` e `-o`.
Deu certo quando: `storyboard/cenas.json` existe e `jq '.cenas | length'` devolve o número de cenas.
Erro comum: Esquecer o `-o` e perder a resposta no terminal.
Passo 6: Renderize com escrita
`codex exec --sandbox workspace-write` com o pedido de render.
Deu certo quando: `renders/receita.mp4` existe e o `ffprobe` mostra a duração.
Erro comum: Usar `--full-auto`, que está obsoleto.
Passo 7: Conecte um MCP e liste
`codex mcp add` e depois `codex mcp list`.
Deu certo quando: O servidor aparece na lista com o estado de autenticação.
Erro comum: Tentar `codex mcp-server`, removido em 05/09/2026.
Passo 8: Envie um lote ao Codex Cloud (opcional)
`codex cloud exec --env ENV_ID` e, ao fim, `codex apply`.
Deu certo quando: O diff da tarefa chega ao repositório local.
Erro comum: Publicar o ambiente sem o FFmpeg na preparação, ou no preset Custom domains only sem os repositórios do Ubuntu e do Debian.
No fim você tem: Codex instalado, perfil seguro no config.toml, AGENTS.md do projeto e um MP4 de teste conferido com ffprobe.
Guia prático: dois perfis, rede por domínio e teste do cercado
A aula deixou o Codex sem rede e pedindo aprovação. Este guia separa a sessão que só edita e renderiza da sessão que chama API paga: um arquivo de perfil liga a rede só para api.openai.com e api.elevenlabs.io, um filtro impede que as chaves cheguem a comandos que não precisam delas e o comando codex sandbox mostra, antes da tarefa, o que o cercado nega.
Funções, casos de uso e aplicações
Funções
Recursos do Codex que a aula não usou
| Função ou recurso | O que faz | Quando usar | Desde |
|---|---|---|---|
| codex --profile api com o arquivo ~/.codex/api.config.toml | Carrega um arquivo de perfil que mora ao lado do config.toml e vale só na sessão em que você o escolhe | Separar a sessão local, sem rede, da sessão que chama API de imagem ou de voz | Referência de 12/10/2026 |
| [features.network_proxy] com domains | Proxy experimental dos comandos do cercado: só passam os domínios marcados allow, e deny vence em conflito | Liberar api.openai.com e api.elevenlabs.io sem abrir a internet inteira | Referência de 12/10/2026 (experimental) |
| codex sandbox linux, macos ou windows (atalho codex debug) | Roda um comando dentro do cercado e mostra o que é negado; no macOS, --log-denials lista as negações | Provar o perfil antes de entregar um render longo ao agente | Referência de 12/10/2026 |
| approval_policy = { granular = { ... } } | Escolhe, categoria a categoria, quais pedidos aparecem: sandbox_approval, rules, mcp_elicitations, request_permissions e skill_approval | Silenciar perguntas de um servidor MCP de leitura e manter o pedido de rede | Referência de 12/10/2026 |
| shell_environment_policy (inherit e filters) | Define quais variáveis de ambiente cada comando herda: all, core ou none, com inclusões por nome | Impedir que OPENAI_API_KEY chegue ao FFmpeg ou a um script baixado | Referência de 12/10/2026 |
| Escrita ampliada por aprovação | Uma escalada de escrita aprovada pode abrir mais pastas e mantém as leituras negadas e a rede fechada | Render que precisa gravar numa pasta de mídia fora do projeto | 0.161.0, 07/10/2026 |
| Correções do cercado no Linux e no Windows | Corrige a partida do cercado com vários arquivos negados e o acesso a letras de unidade no Windows 10 | Motivo concreto para ficar na 0.162.x | 0.162.0, 08/10/2026 |
O proxy de rede cobre só os comandos que rodam dentro do cercado; busca na web, apps, MCP e ferramentas hospedadas ficam fora do filtro.
Fonte: OpenAI, Agent approvals & security, Config reference e releases do Codex CLI, 12/10/2026
Casos de uso
Lívia, coordenadora de conteúdo de uma agência de performance em Campinas
Marketing digital
Dor
O Codex da equipe roda com rede ligada no config.toml global; numa tarde de render, chamadas pagas de imagem saíram de uma sessão que deveria só montar cortes.
Solução
Rede desligada no arquivo principal e um perfil api com o proxy liberando só os dois domínios de API. Quem vai gerar imagem ou voz abre codex --profile api; o resto da semana roda sem rede.
Resultado
Na fatura semanal da OpenAI e no painel da ElevenLabs, as chamadas pagas passam a coincidir com os horários das sessões de perfil api. Confira por duas semanas antes de dar o arranjo por fechado.
Custo apurado: Os dois perfis são só configuração do Codex e saem sem custo novo.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Marcos, coordenador de produção de uma escola de cursos livres a distância em Belo Horizonte
Educação
Dor
Monitores usam a mesma máquina para editar videoaulas, e as chaves de API ficam no ambiente de qualquer comando que o agente roda, inclusive scripts baixados de tutoriais.
Solução
shell_environment_policy com inherit = "core" e inclusão só das duas chaves no perfil de API; no perfil padrão, nenhuma chave entra. Antes de cada lote, codex sandbox linux env mostra o que o comando enxerga.
Resultado
Observe a saída do env dentro do cercado: no perfil padrão nenhuma variável terminada em _API_KEY aparece. Repita o teste a cada atualização da CLI.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Na prática
No projeto video-ia, o ~/.codex/config.toml da aula continua como está, sem rede. O arquivo abaixo cria o perfil api, que você abre com codex --profile api só na sessão que gera quadros (aula 13) ou narração (aula 15). O proxy de rede (o intermediário que decide quais endereços um comando pode alcançar) ainda é experimental, por isso o roteiro termina testando um domínio liberado e um bloqueado.
# ~/.codex/api.config.toml - perfil "api" do projeto video-ia
# Abra com: codex --profile api (o config.toml principal segue sem rede)
model = "gpt-6.1-sol"
sandbox_mode = "workspace-write"
approval_policy = "on-request"
approvals_reviewer = "user" # API paga: quem aprova é você
[sandbox_workspace_write]
network_access = true
# Proxy experimental: só passa o que estiver com "allow"; "deny" vence em conflito
[features.network_proxy]
enabled = true
[features.network_proxy.domains]
"api.openai.com" = "allow"
"api.elevenlabs.io" = "allow"
# Comandos herdam só o essencial do ambiente, mais as duas chaves do projeto
[shell_environment_policy]
inherit = "core"
[shell_environment_policy.filters]
"OPENAI_API_KEY" = "include"
"ELEVENLABS_API_KEY" = "include"#!/usr/bin/env bash
# scripts/testar_cercado.sh - rode na raiz video-ia (no macOS troque linux por macos)
set -uo pipefail
# 1) Sem rede no perfil padrão: o curl precisa falhar
codex sandbox linux curl -sS -m 10 -o /dev/null https://api.elevenlabs.io/v1/models \
&& echo "ALERTA: a rede está aberta no perfil padrão" \
|| echo "ok: rede negada no perfil padrão"
# 2) Escrita fora do projeto: precisa falhar
codex sandbox linux touch ../fora-do-projeto.txt \
&& echo "ALERTA: escreveu fora do projeto" \
|| echo "ok: escrita fora do projeto negada"
# 3) Pastas protegidas continuam só para leitura
codex sandbox linux touch .codex/teste.txt \
&& echo "ALERTA: .codex aceitou escrita" \
|| echo "ok: .codex protegida"
# 4) Variáveis que um comando enxerga dentro do cercado
codex sandbox linux env | grep -c "_API_KEY" || trueDois perfis e um teste em cinco passos
Faça uma vez por máquina e repita o teste a cada atualização do Codex.
Passo 1: Rode o teste do cercado no perfil padrão
bash scripts/testar_cercado.sh na raiz do projeto.
Deu certo quando: As três primeiras linhas começam com "ok".
Erro comum: Rodar fora da pasta do projeto e confundir o que é "dentro" do cercado.
Passo 2: Crie o arquivo do perfil api
Copie o api.config.toml para ~/.codex/ (no Windows, %USERPROFILE%\.codex\).
Deu certo quando: O arquivo fica ao lado do config.toml.
Erro comum: Colocar network_access = true no config.toml principal.
Passo 3: Abra a sessão de API e peça dois acessos
codex --profile api e o pedido: "rode curl -sI em https://api.elevenlabs.io e em https://pypi.org e me diga o resultado de cada um".
Deu certo quando: O domínio da ElevenLabs responde e o pypi.org é recusado.
Erro comum: Liberar * no proxy para o teste passar.
Passo 4: Confira as chaves no ambiente
Na mesma sessão, peça env | grep _API_KEY | cut -d= -f1.
Deu certo quando: Aparecem só os nomes das duas chaves, sem os valores.
Erro comum: Pedir ao agente que mostre o valor da chave.
Passo 5: Volte ao perfil padrão para editar e renderizar
Feche a sessão e abra codex sem --profile.
Deu certo quando: Um pedido de rede volta a gerar pedido de aprovação.
Erro comum: Deixar a sessão de API aberta o dia inteiro.
No fim você tem: Rede só onde há API paga, chaves só onde fazem falta e um teste que prova o cercado antes de cada lote.
Armadilhas
Rede e chaves no Codex: o que evitar e o que fazer
Evite
Coluna a evitar
- Ligar a rede no config.toml principal "só por hoje"
- Liberar * no proxy para não ter de listar domínios
- Contar com o proxy para filtrar busca na web e servidores MCP
- Deixar todo comando herdar o ambiente com as chaves
- Trocar para auto_review numa sessão que gasta API
Prefira
Coluna recomendada
- Rede só no perfil api, aberto com --profile quando há chamada paga
- Só api.openai.com e api.elevenlabs.io com allow
- Medir MCP e busca à parte: o proxy cobre só comandos do cercado
- inherit = "core" e inclusão nominal das duas chaves
- approvals_reviewer = "user" sempre que houver dólar em jogo
Na Cozinha da Rafa, canal de receitas de Recife com três vídeos por semana (um longo 16:9 e dois cortes 9:16), o projeto video-ia recebe o AGENTS.md acima e o config.toml com a rede desligada. Na segunda-feira, o codex exec em read-only lê roteiro/roteiro.md, com a receita do bolo de rolo, e devolve seis cenas de 8 a 12 segundos. Com cerca de 8 mil tokens de entrada e 2 mil de saída no 6.1 Sol, a chamada custa US$ 0,016 mais US$ 0,02, ou US$ 0,036, em 09/10/2026. No render do corte 9:16, o Codex tenta baixar uma fonte da internet; o sandbox pede aprovação, a Rafa nega e coloca a fonte em marca/fontes/.
Se a tarefa chama API paga (imagem, voz ou vídeo), abra uma sessão à parte com network_access = true e aprovação on-request; se só edita e renderiza localmente, mantenha a rede desligada. Quando o render passa do que o seu notebook aguenta, mande para o Codex Cloud com FFmpeg instalado na preparação. Com um CLAUDE.md pronto, importe-o no app e revise o AGENTS.md gerado; sem ele, comece pelo /init e pelo modelo desta aula.
Glossário rápido
Codex
Agente de programação da OpenAI que lê instruções, edita arquivos e roda comandos no terminal; não gera vídeo.
sandbox
Cercado onde o agente trabalha: dentro dele edita e executa; para usar a rede ou sair da pasta, precisa pedir.
AGENTS.md
Arquivo de instruções que o Codex lê antes de cada tarefa, como o manual de procedimentos de uma cozinha.
approval_policy
Regra que diz quando o Codex para e pede a sua aprovação; o curso usa on-request.
codex exec
Modo sem interface do Codex, que roda uma tarefa do começo ao fim e serve para scripts e CI.
schema
Molde do JSON de resposta, como a forma de um bolo: o que não couber nela faz a chamada falhar.
Codex Cloud
Tarefas do Codex rodando em contêineres da OpenAI a partir de um repositório GitHub, com o computador desligado.
Instale o Codex, grave o config.toml desta aula e rode o prompt acima na pasta do projeto. Está pronto quando codex --version mostra 0.162.1 ou superior, o cenas.json passa no jq, o MP4 de teste de 3 segundos sai em 1080x1920 sem nenhum download e o primeiro pedido de rede aparece na tela esperando o seu sim. Com isso, a aula 13 usa o mesmo cercado para gerar o storyboard.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. Nos vídeos e áudios, use Anotar este momento. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Conexões deste capítulo
Veja o que estudar antes e para onde seguir depois, explore os conceitos e compare abordagens em outros cursos. Sugestões marcadas como “sugerido pelo grafo” vêm dos assuntos em comum, não do índice do curso.
Estude antes
- CursoClaude Code CLI: Programação com IA
- CursoAstra profundosugerido pelo grafoA quinta parte do Astra planeja o vídeo e edita o material bruto com o modelo dirigindo a ferramenta. O curso de vídeo com IA aprofunda esse trabalho com Claude Code, Codex e ElevenLabs, do roteiro à publicação. O grafo já sugeria esta ordem pela regra de entrada da trilha; com a ordem anterior curada, ela passa a ser declarada (Etapa 4, wave 3).
- CursoSetup Completo: do zero ao Claude Codesugerido pelo grafo7 capítulos de “Vídeo com IA: Claude Code, Codex e ElevenLabs” usam conceitos apresentados em “Setup Completo: do zero ao Claude Code”.
Depois, siga para
- Configurar ambiente, skills e o contêiner de contextosugerido pelo grafoApresenta o conceito “Codex”, usado em “Configurar ambiente, skills e o contêiner de contexto”.
- Comparar modelos e interpretar benchmarkssugerido pelo grafoApresenta o conceito “Codex”, usado em “Comparar modelos e interpretar benchmarks”.
- Situar agentes, híbridos e RLM numa matriz de decisãosugerido pelo grafoApresenta o conceito “Codex”, usado em “Situar agentes, híbridos e RLM numa matriz de decisão”.
- Provar uma auto-melhoria antes de acreditar nelasugerido pelo grafoApresenta o conceito “Codex”, usado em “Provar uma auto-melhoria antes de acreditar nela”.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Claude Code CLI: Programação com IAEscolher entre Claude e ChatGPT pelo custo do erroExaminar conexões de Escolher entre Claude e ChatGPT pelo custo do erro
- Software e IA para executivosEscolher entre buscar, treinar ou rotear antes de pagar a contaExaminar conexões de Escolher entre buscar, treinar ou rotear antes de pagar a conta
- Engenharia de Software para ExecutivosPôr teto na conta de IA e cobrar o retornoExaminar conexões de Pôr teto na conta de IA e cobrar o retorno
- Astra profundoCalcular custo e escolher modelos por resultadoExaminar conexões de Calcular custo e escolher modelos por resultado
Voltar ao capítulo anterior: Revisar quadros com a visão do Claude e uma rubrica escrita
Leve uma ideia para a prática
Escolha uma atividade no painel e volte a este curso quando quiser.
Atividades e evolução ficam reunidas no painel da sua conta.
Laboratórios ao vivo deste curso
Cada laboratório monta a biblioteca real dentro da aula, com controles para você mexer e o código do exemplo para copiar. O texto de reserva descreve a demonstração para quem lê sem JavaScript. O link abre o capítulo já no ponto do laboratório.
MediaRecorder, Canvas 2D e Long Animation Frames (plataforma)
Grave a cena em tempo real e veja os quadros que se perdem
Suba as partículas, force um bloqueio de 300 ms e grave seis segundos; compare com o render quadro a quadro desta aula.
Pacote
Abrir no capítuloMontar vídeo em HTML com HyperFrames e escolher entre ele e o Remotionsem pacoteMotion
Ver agentes em paralelo trocando mensagens numa linha do tempo
Reproduza a cena, percorra o tempo pelo controle e compare o tempo de parede com a soma das barras de cada agente.
Pacote
Abrir no capítuloParalelizar cenas com subagentes sem estourar o limite das APIsmotionReact (sem dependência extra), com as APIs do Veo e do fal.ai
Prompt de vídeo em cinco camadas, pronto para a API
Escolha plano, câmera, luz, ação e áudio e copie o prompt e o JSON para o Veo ou para o fal.ai.
Pacote
Abrir no capítuloEscrever prompt de vídeo em cinco camadas e manter o personagem consistentereactReact (sem dependência extra), com o comando para o FFmpeg
Corte o vídeo apagando palavras da transcrição
Aperte as palavras para removê-las, ligue a remoção de pausas e copie o comando FFmpeg e a legenda SRT gerados.
Pacote
Abrir no capítuloRemover pausas e reenquadrar o vídeo de 16:9 para 9:16 com legenda por palavrareactReact (sem dependência extra)
Quanto custa cada etapa do seu pipeline de vídeo
Troque a ferramenta de cada etapa e o percentual de b-roll e veja qual etapa pesa no custo por minuto e por vídeo.
Pacote
Abrir no capítuloOrquestrar o pipeline com etapas idempotentes e teto de gastoreact
Capítulos vizinhos em Vídeo com IA: Claude Code, Codex e ElevenLabs
- 10Paralelizar cenas com subagentes sem estourar o limite das APIs
- 11Revisar quadros com a visão do Claude e uma rubrica escrita
- 12Configurar o Codex com GPT-6 Astra num sandbox que pede aprovação
- 13Gerar storyboard e miniaturas com gpt-image no lugar do Sora
- 14Pôr Claude Code e Codex em revisão cruzada sem loop