Codex CLI: The Definitive Technical Reference

Codex opera como um agente de codificação multi-superfície, não como um chatbot que escreve código. O CLI lê sua base de código, executa comandos em um sandbox, aplica patches em arquivos, conecta-se a serviços externos via MCP e delega tarefas de longa duração para a nuvem. Ele roda localmente, mas pensa globalmente — a mesma inteligência alimenta quatro superfícies distintas dependendo de como você trabalha.

A diferença entre o uso casual e o uso eficiente do Codex se resume a cinco sistemas fundamentais. Domine-os e o Codex se torna um multiplicador de força:

1. Sistema de configuração — controla o comportamento via config.toml
2. Sandbox e modelo de aprovação — define os limites do que o Codex pode fazer
3. AGENTS.md — estabelece contratos operacionais no nível do projeto
4. Protocolo MCP — estende as capacidades para serviços externos
5. Sistema de skills — empacota expertise de domínio reutilizável

Passei meses executando o Codex lado a lado com o Claude Code em bases de código de produção, pipelines de CI/CD e fluxos de trabalho em equipe. Este guia destila essa experiência na referência completa que eu gostaria que existisse quando comecei. Cada recurso inclui a sintaxe real, exemplos práticos de configuração e os casos extremos que pegam até usuários experientes de surpresa.

Nota de estabilidade: Recursos marcados como [EXPERIMENTAL] estão sujeitos a mudanças entre versões. O Codex Cloud e o grupo de comandos MCP são ambos experimentais a partir da v0.101.0. O CLI principal, sandbox, AGENTS.md, config.toml e Skills são estáveis.

Como o Codex funciona: o modelo mental

Antes de mergulhar nos recursos, entenda como a arquitetura do Codex molda tudo o que você faz com ele. O sistema opera em quatro superfícies sustentadas por uma camada de inteligência compartilhada:

┌─────────────────────────────────────────────────────────┐
│                    CODEX SURFACES                        │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │   CLI    │  │ Desktop  │  │   IDE    │  │ Cloud  │ │
│  │ Terminal │  │   App    │  │Extension │  │  Tasks │ │
│  └──────────┘  └──────────┘  └──────────┘  └────────┘ │
│  Local exec     Multi-task    Editor-native  Async      │
│  + scripting    + worktrees   + inline edits detached   │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐   │
│  │   MCP   │  │ Skills  │  │  Apps   │  │  Search │   │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘   │
│  External tools, reusable expertise, ChatGPT            │
│  connectors, web search (cached + live)                  │
├─────────────────────────────────────────────────────────┤
│  SECURITY LAYER                                          │
│  ┌─────────────────────────────────────────────────┐    │
│  │    Sandbox (Seatbelt / Landlock / seccomp)      │    │
│  │    + Approval Policy (untrusted → never)        │    │
│  └─────────────────────────────────────────────────┘    │
│  OS-level filesystem + network restrictions              │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │         GPT-5.x-Codex Intelligence              │    │
│  │   Tools: Shell, Patch, Read, Web Search         │    │
│  └─────────────────────────────────────────────────┘    │
│  Shared model across all surfaces; costs tokens          │
└─────────────────────────────────────────────────────────┘

Camada Core: A família de modelos GPT-5.x-Codex alimenta tudo. A partir da v0.101.0, gpt-5.3-codex é o modelo padrão com uma janela de contexto de 272K tokens. Ele lê arquivos, escreve patches, executa comandos shell e raciocina sobre sua base de código. Quando o contexto enche, o Codex compacta a conversa para liberar espaço. Essa camada consome tokens.

Camada de segurança: Todo comando que o Codex executa passa por um sandbox em nível de sistema operacional. No macOS, o framework Seatbelt da Apple aplica restrições em nível de kernel. No Linux, Landlock + seccomp filtram o acesso ao sistema de arquivos e às chamadas de sistema. Isso não é baseado em containers — está integrado ao sistema operacional. A política de aprovação então decide quando solicitar confirmação humana.

Camada de extensão: MCP conecta serviços externos (GitHub, Figma, Sentry). Skills empacotam fluxos de trabalho reutilizáveis que o Codex carrega sob demanda. Apps conectam-se a conectores do ChatGPT. A busca na web adiciona contexto em tempo real da internet.

Camada de superfície: CLI para usuários avançados de terminal e automação. Codex Desktop App para gerenciamento de projetos com múltiplas threads. Extensão para IDE para ciclos de edição-compilação-teste. Cloud para tarefas assíncronas que rodam independentemente.

O insight principal: A maioria dos usuários usa apenas uma superfície. Usuários avançados usam todas as quatro — Cloud para tarefas de longa duração, CLI para operações determinísticas no repositório, extensão para IDE para ciclos de codificação rápidos, e o Codex Desktop App para planejamento e coordenação.

Sumário

1. Como instalar o Codex?
2. Superfícies de interação principais
3. Mergulho profundo no sistema de configuração
4. Qual modelo devo escolher?
5. Frameworks de decisão
6. Como funciona o sistema de sandbox e aprovação?
7. Como funciona o AGENTS.md?
8. O que é MCP (Model Context Protocol)?
9. O que são skills?
10. Plan Mode e colaboração
11. Modo não interativo (codex exec)
12. Codex Cloud e tarefas em segundo plano
13. O Codex Desktop App
14. GitHub Action e CI/CD
15. Codex SDK
16. Quanto custa o Codex?
17. Otimização de desempenho
18. Como depurar problemas?
19. Implantação empresarial
20. Dicas e técnicas da comunidade
21. Guia de migração
22. Cartão de referência rápida
23. Changelog
24. Referências

Como instalar o Codex?

Gerenciadores de pacotes

# npm (recommended)
npm install -g @openai/codex

# Homebrew (macOS)
brew install --cask codex

# Upgrade to latest
npm install -g @openai/codex@latest

Downloads de binários

Para ambientes sem npm ou Homebrew, baixe binários específicos para cada plataforma em GitHub Releases¹:

Requisitos do sistema

• macOS: Apple Silicon ou Intel (suporte completo a sandbox via Seatbelt)
• Linux: x86_64 ou arm64 (sandbox via Landlock + seccomp)
• Windows: Experimental (WSL recomendado para suporte completo a sandbox)²

Autenticação

codex login                  # Interactive OAuth (recommended)
codex login --device-auth    # OAuth device code flow (headless)
codex login --with-api-key   # API key from stdin
codex login status           # Check auth state (exit 0 = logged in)
codex logout                 # Clear stored credentials

Dois caminhos de autenticação:

1. Conta ChatGPT (recomendado): Faça login com sua assinatura existente do Plus, Pro, Team, Business, Edu ou Enterprise. Acesso completo a todos os recursos, incluindo tarefas na nuvem.
2. API Key: Configure via variável de ambiente CODEX_API_KEY ou codex login --with-api-key. Alguns recursos (cloud threads) podem não estar disponíveis.

Dica avançada: O armazenamento de credenciais é configurável via cli_auth_credentials_store no config.toml. Opções: file (padrão), keyring (chaveiro do sistema operacional) ou auto (keyring se disponível, file como fallback).

Autocompletar do shell

# Generate completions for your shell
codex completion bash > /etc/bash_completion.d/codex
codex completion zsh > ~/.zsh/completions/_codex
codex completion fish > ~/.config/fish/completions/codex.fish

Verificar a instalação

codex --version
# Codex CLI v0.101.0

Superfícies de interação principais

O Codex oferece quatro interfaces distintas sustentadas pela mesma inteligência. Cada superfície é otimizada para um padrão de fluxo de trabalho diferente.

1. CLI interativo (Terminal UI)

codex                        # Launch TUI
codex "fix the failing tests" # Launch with initial prompt
codex -m gpt-5.3-codex      # Specify model
codex --full-auto            # Workspace-write sandbox + on-request approval

A TUI do terminal é uma aplicação em tela cheia com:

• Compositor: Digite prompts, anexe arquivos com @, execute comandos shell com o prefixo !
• Painel de saída: Respostas do modelo em streaming, chamadas de ferramentas e saída de comandos
• Barra de status: Modelo, uso de tokens, branch git, modo de sandbox

Atalhos principais da TUI:

Slash commands disponíveis na TUI:

2. Codex Desktop App (macOS)

codex app                    # Launch desktop app (auto-installs if missing)

O Codex Desktop App adiciona capacidades que o CLI não possui:

• Multitarefa: Execute múltiplos agentes paralelos em diferentes projetos simultaneamente
• Isolamento com git worktree: Cada thread trabalha em uma cópia isolada do seu repositório
• Revisão de diff integrada: Faça stage, reverta e commite alterações sem sair do aplicativo
• Terminal integrado: Terminal por thread para executar comandos
• Bifurcação de conversas: Ramifique conversas para explorar alternativas
• Janelas pop-out flutuantes: Destaque conversas em janelas portáteis
• Automações: Agende tarefas recorrentes (triagem de issues, monitoramento de CI, resposta a alertas)

Quando usar o app vs CLI: Use o Codex Desktop App quando estiver coordenando múltiplos fluxos de trabalho ou precisar de revisão visual de diffs. Use o CLI quando quiser composabilidade no terminal, scripting ou integração com CI/CD.

3. Extensão para IDE (VS Code, Cursor, Windsurf)

A extensão do Codex para IDE se integra diretamente ao seu editor:

• Modo agente por padrão: Lê arquivos, faz edições, executa comandos
• Edições inline: Sugestões contextuais nos seus arquivos ativos
• Sessões compartilhadas: As sessões sincronizam entre CLI e extensão para IDE
• Mesma autenticação: Faça login com conta do ChatGPT ou API key

Instale pelo VS Code Marketplace ou pelas lojas de extensões do Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Tarefas na nuvem rodam de forma assíncrona em ambientes gerenciados pela OpenAI:

• Disparar e esquecer: Enfileire tarefas que rodam independentemente da sua máquina local
• Execução paralela: Execute múltiplas tarefas na nuvem simultaneamente
• Criação de PR: O Codex cria pull requests a partir do trabalho concluído
• Aplicação local: Puxe os resultados da nuvem para seu repositório local com codex apply <TASK_ID>

codex cloud list             # List recent cloud tasks
codex apply <TASK_ID>        # Apply diff from a specific cloud task

Tarefas na nuvem também são acessíveis em chatgpt.com/codex.⁴

Mergulho profundo no sistema de configuração

Codex usa TOML para configuração. Entender a hierarquia de precedência é fundamental — ela determina quais configurações prevalecem quando há conflitos.

Precedência (da mais alta para a mais baixa)

1. Substituições de sessão (mais alta): flags da CLI (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) e substituições -c key=value
2. Configuração do projeto (.codex/config.toml, descoberta a partir do diretório atual subindo até a raiz do projeto — o diretório mais próximo prevalece)
3. Configuração do usuário ($CODEX_HOME/config.toml, padrão ~/.codex/config.toml)
4. Configuração do sistema (/etc/codex/config.toml no Unix)
5. Padrões integrados (mais baixa)

A configuração administrativa gerenciada atua como uma camada de restrição de políticas e pode forçar ou proibir valores após a mesclagem normal. Veja Implantação empresarial.

Localizações dos arquivos de configuração

Dica avançada: A variável de ambiente CODEX_HOME substitui o diretório padrão ~/.codex. Útil para CI/CD ou configurações com múltiplas contas.

Referência completa de configuração

# ~/.codex/config.toml — annotated reference

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.3-codex"                # Default model (272K context)
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_reasoning_effort = "medium"       # low|medium|high|xhigh (model-dependent)
model_reasoning_summary = "auto"        # auto|concise|detailed|none
model_verbosity = "medium"              # low|medium|high
personality = "pragmatic"               # none|friendly|pragmatic
review_model = "gpt-5.2-codex"         # Model for /review command
oss_provider = "lmstudio"              # lmstudio|ollama (used with --oss)

# ─── Sandbox & Approval ───────────────────────────────
sandbox_mode = "workspace-write"        # read-only|workspace-write|danger-full-access
approval_policy = "on-request"          # untrusted|on-failure|on-request|never

[sandbox_workspace_write]
writable_roots = []                     # Additional writable paths
network_access = false                  # Allow outbound network
exclude_tmpdir_env_var = false          # Exclude $TMPDIR from sandbox
exclude_slash_tmp = false               # Exclude /tmp from sandbox

# ─── Web Search ────────────────────────────────────────
web_search = "live"                     # Web search mode (constrained by allowed modes)

# ─── Instructions ──────────────────────────────────────
developer_instructions = ""             # Additional injected instructions
model_instructions_file = ""            # Custom instructions file path
compact_prompt = ""                     # Custom history compaction prompt

# ─── Shell Environment ─────────────────────────────────
[shell_environment_policy]
inherit = "all"                         # all|core|none
ignore_default_excludes = false         # Set true to keep KEY/SECRET/TOKEN vars
exclude = []                            # Glob patterns to exclude
set = {}                                # Explicit overrides
include_only = []                       # Whitelist patterns

# ─── Authentication ────────────────────────────────────
cli_auth_credentials_store = "file"     # file|keyring|auto
forced_login_method = "chatgpt"         # chatgpt|api

# ─── History & Storage ─────────────────────────────────
[history]
persistence = "save-all"                # save-all|none
max_bytes = 0                           # Cap size (0 = unlimited)

tool_output_token_limit = 10000         # Max tokens per tool output
log_dir = ""                            # Custom log directory

# ─── UI & Display ──────────────────────────────────────
file_opener = "vscode"                  # vscode|vscode-insiders|windsurf|cursor|none
hide_agent_reasoning = false
show_raw_agent_reasoning = false
check_for_update_on_startup = true

[tui]
notifications = false                   # Enable notifications
notification_method = "auto"            # auto|osc9|bel
animations = true
show_tooltips = true
alternate_screen = "auto"               # auto|always|never
status_line = ["model", "context-remaining", "git-branch"]

# ─── Project Trust ─────────────────────────────────────
project_doc_max_bytes = 32768           # Max AGENTS.md size (32 KiB)
project_doc_fallback_filenames = []     # Alternative instruction filenames
project_root_markers = [".git"]         # Project root detection

# ─── Feature Flags ─────────────────────────────────────
# Use `codex features list` for current names/stages/defaults.
[features]
shell_tool = true                       # Shell command execution (stable)
collaboration_modes = true              # Plan mode (stable)
personality = true                      # Personality selection (stable)
request_rule = true                     # Smart approvals (stable)
unified_exec = true                     # PTY-backed exec (stable)
shell_snapshot = true                   # Shell env snapshots (stable)
remote_models = true                    # Refresh remote model list (stable)
apps = false                            # ChatGPT Apps/connectors (experimental)
child_agents_md = false                 # AGENTS.md guidance (experimental)
runtime_metrics = false                 # Runtime summary in turns

# ─── Project Trust ─────────────────────────────────────
[projects."/absolute/path/to/repo"]
trust_level = "trusted"                 # Per-project trust override

Perfis

Predefinições de configuração nomeadas para diferentes modos de trabalho:

# Define profiles in ~/.codex/config.toml

[profiles.fast]
model = "gpt-5.1-codex-mini"
model_reasoning_effort = "low"
approval_policy = "on-request"
sandbox_mode = "workspace-write"
personality = "pragmatic"

[profiles.careful]
model = "gpt-5.3-codex"
model_reasoning_effort = "xhigh"
approval_policy = "untrusted"
sandbox_mode = "read-only"

[profiles.auto]
model = "gpt-5.3-codex"
model_reasoning_effort = "medium"
approval_policy = "never"
sandbox_mode = "workspace-write"

Ative um perfil:

codex --profile fast "quick refactor"
codex --profile careful "security audit"
codex -p auto "fix CI"

Dica avançada: Defina um perfil padrão com profile = "fast" no nível superior da sua configuração. Substitua por sessão com --profile.

Provedores de modelo personalizados

Conecte-se ao Azure, modelos locais ou serviços de proxy:

[model_providers.azure]
name = "Azure OpenAI"
base_url = "https://YOUR_PROJECT.openai.azure.com/openai"
wire_api = "responses"
query_params = { api-version = "2025-04-01-preview" }
env_key = "AZURE_OPENAI_API_KEY"

[model_providers.ollama]
name = "Ollama (Local)"
base_url = "http://localhost:11434/v1"
wire_api = "chat"

Use modelos locais com a flag --oss:

codex --oss "explain this function"               # Uses default OSS provider
codex --oss --local-provider lmstudio "explain"   # Explicit LM Studio
codex --oss --local-provider ollama "explain"      # Explicit Ollama

Ou defina na configuração:

model_provider = "oss"
oss_provider = "lmstudio"   # or "ollama"

Substituições de configuração inline

Substitua qualquer valor de configuração pela linha de comando:

codex -c model="gpt-5.2-codex" "refactor the API"
codex -c 'sandbox_workspace_write.network_access=true' "install dependencies"
codex -c model_reasoning_effort="xhigh" "debug the race condition"

Qual modelo devo escolher?

Modelos disponíveis (fevereiro de 2026)

A lista exata de modelos varia conforme a conta e o rollout. Verifique seu cache local: ~/.codex/models_cache.json.

Fluxograma de seleção de modelo

Is this a quick fix or simple question?
├─ Yes → gpt-5.1-codex-mini (fastest, cheapest)
└─ No
   ├─ Do you need real-time pairing speed?
   │  ├─ Yes → gpt-5.3-codex-spark (interactive, lower latency)
   │  └─ No
   │     ├─ Is this a multi-file refactor or migration?
   │     │  ├─ Yes → gpt-5.2-codex (272K context, strong at long tasks)
   │     │  └─ No → gpt-5.3-codex (default, best overall)
   └─ Still unsure? → gpt-5.3-codex

Esforço de raciocínio

Controle o quanto o modelo “pensa” antes de responder:

Os níveis suportados dependem do modelo. Nem todos os modelos suportam todos os níveis.

codex -c model_reasoning_effort="xhigh" "find the race condition"

Dica avançada: O raciocínio xhigh pode usar de 3 a 5 vezes mais tokens do que medium para o mesmo prompt. Reserve-o para problemas genuinamente difíceis em que o pensamento extra compensa.

Troca de modelo

Troque de modelo durante a sessão com o slash command /model, ou defina por execução via --model / -m:

codex -m gpt-5.3-codex-spark "pair with me on this component"

Frameworks de decisão

Quando usar cada superfície

Quando usar cada modo de sandbox

Quando usar cada nível de raciocínio

Como Funciona o Sistema de Sandbox e Aprovação?

O Codex utiliza um modelo de segurança em duas camadas que separa o que é tecnicamente possível de quando a aprovação humana é necessária. Isso é fundamentalmente diferente do sistema de permissões do Claude Code — o Codex aplica restrições no nível do kernel do sistema operacional.⁵

Camada 1: Sandbox (O Que É Possível)

O sandbox controla o acesso ao sistema de arquivos e à rede usando mecanismos nativos do sistema operacional:

Implementação específica por plataforma:

• macOS: Framework Seatbelt da Apple via sandbox-exec com perfis específicos por modo compilados em tempo de execução e aplicados pelo kernel⁶
• Linux: Landlock para restrições de sistema de arquivos + seccomp para filtragem de syscalls. Um processo auxiliar independente (codex-linux-sandbox) fornece isolamento em profundidade. Pipeline opcional com Bubblewrap (bwrap) disponível como alternativa⁷
• Windows: Sandbox nativo experimental com tokens restritos. WSL recomendado para suporte completo ao sandbox (herda Landlock + seccomp do Linux)

Por que isso importa: Diferente do sandboxing baseado em contêineres (Docker), o sandboxing em nível de sistema operacional é mais rápido, mais leve e mais difícil de escapar. O kernel aplica as restrições antes mesmo de o Codex ver a chamada de sistema.

Camada 2: Política de Aprovação (Quando Perguntar)

A política de aprovação determina quando o Codex pausa para solicitar confirmação humana:

A Flag --full-auto

--full-auto é um atalho conveniente para:

codex --sandbox workspace-write --ask-for-approval on-request

Pegadinha crítica: --full-auto sobrescreve qualquer valor explícito de --sandbox. Se você passar --full-auto --sandbox read-only, o resultado será workspace-write porque --full-auto tem precedência.⁸

Configurações Recomendadas

Desenvolvimento diário (padrão seguro):

sandbox_mode = "workspace-write"
approval_policy = "on-request"

Usuário avançado (acesso total, humano no loop):

sandbox_mode = "danger-full-access"
approval_policy = "untrusted"

Esta é a configuração recomendada pela comunidade como o “ponto ideal” — capacidade máxima, mas aprovação necessária para cada comando.⁹

Automação CI/CD:

sandbox_mode = "workspace-write"
approval_policy = "never"

Habilitando Acesso à Rede

A rede é bloqueada por padrão no modo workspace-write. Habilite quando necessário:

# Per-run
codex -c 'sandbox_workspace_write.network_access=true' "install the packages"

# In config.toml
[sandbox_workspace_write]
network_access = true
writable_roots = ["/path/to/extra/dir"]   # Additional writable directories
exclude_slash_tmp = false                  # Prevent /tmp from being writable
exclude_tmpdir_env_var = false             # Prevent $TMPDIR from being writable

Testando o Sandbox

Verifique o comportamento do sandbox antes de confiar nele:

codex sandbox macos --full-auto -- ls /etc/passwd   # macOS test
codex sandbox linux --full-auto -- cat /etc/shadow   # Linux test

Como Funciona o AGENTS.md?

AGENTS.md é o sistema de instruções de projeto do Codex — um padrão aberto¹⁰ suportado pelo Codex, Cursor, Amp, Jules (Google) e Factory. Ele define como o Codex deve se comportar dentro de um repositório ou diretório específico.

Hierarquia de Descoberta

O Codex constrói uma cadeia de instruções no início da sessão percorrendo a árvore de diretórios:

1. Global (~/.codex/): AGENTS.override.md > AGENTS.md
2. Projeto (raiz do git até o diretório atual): Cada nível é verificado para AGENTS.override.md > AGENTS.md > nomes de arquivo alternativos
3. Mesclagem: Os arquivos são concatenados da raiz para baixo; arquivos mais próximos aparecem depois no prompt e sobrescrevem orientações anteriores

~/.codex/AGENTS.md                     ← Global defaults
  └─ /repo/AGENTS.md                   ← Project-wide rules
      └─ /repo/services/AGENTS.md      ← Service-specific rules
          └─ /repo/services/payments/
               AGENTS.override.md      ← Overrides everything above for this dir

O Que Torna um AGENTS.md Excelente

Com base em orientações diretas do próprio Codex e padrões da comunidade¹¹:

FAÇA: - Seja específico: "Use rg --files for discovery" é melhor que "search efficiently" - Defina conclusão: O que significa “pronto”? (testes passam, lint limpo, etc.) - Inclua comandos: Build, teste, lint, formatação — invocações exatas - Organize por tarefa: Seções de codificação, revisão, release, incidente/debug - Defina escalonamento: O que fazer quando bloqueado ou encontrando estado inesperado

NÃO FAÇA: - Despejar guias de estilo inteiros sem regras de execução - Usar diretivas ambíguas (“tenha cuidado”, “otimize”) - Misturar prioridades contraditórias (velocidade + verificação exaustiva + sem orçamento de execução) - Escrever documentação em prosa — AGENTS.md é política operacional, não README

Exemplo: AGENTS.md de Produção

# Repository Guidelines

## Build, Test, and Development Commands
- Run API (dev): `python3 -m uvicorn main:app --reload`
- Install deps: `pip install -r requirements.txt`
- Lint: `python3 -m ruff check .` (auto-fix: `--fix`)
- Format: `python3 -m ruff format .`
- Tests: `python3 -m pytest -v`
- Coverage: `python3 -m pytest --cov=app --cov-report=term-missing`

## Coding Style & Naming Conventions
- Python 3.11+. Type hints on all functions.
- Ruff enforced: 88-char lines, double quotes, spaces for indent.
- Naming: modules `snake_case.py`, classes `PascalCase`, functions `snake_case`.

## Commit & Pull Request Guidelines
- Conventional Commits: `feat:`, `fix:`, `docs:`, `refactor:`, `chore:`, `test:`
- Commits should be small and focused.
- PRs must include: description, test plan, and screenshots for UI changes.

## Security
- Never commit secrets. Use `.env` for local config.
- Validate all external API calls with proper error handling.

O Mecanismo de Override

AGENTS.override.md em qualquer nível de diretório substitui o AGENTS.md normal para aquele escopo. Use para:

• Congelamento de releases: “Nenhum recurso novo, apenas correções”
• Modo de incidente: “Todas as alterações devem ser revisadas pelo plantonista”
• Endurecimento temporário: “Nenhuma atualização de dependências neste sprint”

Configuração

# Custom fallback filenames (in addition to AGENTS.md)
project_doc_fallback_filenames = ["TEAM_GUIDE.md", ".agents.md"]

# Increase max size for large instruction files
project_doc_max_bytes = 65536    # 64 KiB (default: 32 KiB)

Geração de Scaffold

codex                           # Launch TUI
/init                           # Generate AGENTS.md scaffold

Ou verifique sua cadeia de instruções:

codex --ask-for-approval never "Summarize your current instructions"

O Que É MCP (Model Context Protocol)? [experimental]

MCP estende as capacidades do Codex conectando-o a ferramentas e serviços externos. O grupo de comandos codex mcp está atualmente marcado como experimental — os comandos e o formato de configuração podem mudar entre versões. O Codex suporta dois tipos de transporte: STDIO (processos locais) e Streamable HTTP (servidores remotos).¹²

Configurando Servidores MCP

Servidores STDIO (processos locais):

# In ~/.codex/config.toml or .codex/config.toml

[mcp_servers.context7]
enabled = true
required = true                         # Fail startup if unavailable
command = "npx"
args = ["-y", "@upstash/context7-mcp"]
env = { "MY_VAR" = "value" }            # Static env vars
env_vars = ["PATH", "HOME"]             # Forward host env vars
cwd = "/path/to/project"                # Optional working directory
startup_timeout_sec = 10
tool_timeout_sec = 60
enabled_tools = ["search", "summarize"]  # Tool allowlist
disabled_tools = ["slow-tool"]           # Tool denylist

Servidores HTTP (remotos):

[mcp_servers.figma]
enabled = true
url = "https://mcp.figma.com/mcp"
bearer_token_env_var = "FIGMA_OAUTH_TOKEN"
http_headers = { "X-Figma-Region" = "us-east-1" }
env_http_headers = { "X-Org-Id" = "FIGMA_ORG_ID" }  # Headers from env vars
startup_timeout_sec = 10
tool_timeout_sec = 60

Gerenciamento via CLI

codex mcp add context7 -- npx -y @upstash/context7-mcp
codex mcp add context7 --env API_KEY=... -- npx -y @upstash/context7-mcp   # With env vars
codex mcp add figma --url https://mcp.figma.com/mcp --bearer-token-env-var FIGMA_OAUTH_TOKEN
codex mcp list                          # List all configured servers
codex mcp list --json                   # JSON output
codex mcp get context7                  # Show server config
codex mcp get context7 --json           # JSON output
codex mcp login <server>                # OAuth flow for HTTP servers
codex mcp logout <server>               # Remove OAuth credentials
codex mcp remove <server>               # Delete server definition

Na sessão: /mcp exibe os servidores ativos e as ferramentas disponíveis.

Executando o Codex COMO um Servidor MCP

O Codex pode se expor como um servidor MCP para orquestração multi-agente:¹³

codex mcp-server                        # Start as MCP server (stdio transport)

Isso expõe duas ferramentas: 1. codex(): Inicia uma nova sessão com parâmetros de prompt, sandbox, modelo e aprovação 2. codex-reply(): Continua uma sessão existente com threadId e prompt

Uso com o Agents SDK (Python):

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    name="Codex CLI",
    params={"command": "npx", "args": ["-y", "codex", "mcp-server"]},
    client_session_timeout_seconds=360000,
) as codex_mcp_server:
    agent = Agent(name="Developer", mcp_servers=[codex_mcp_server])
    result = await Runner.run(agent, "Fix the failing tests")

Servidores MCP Notáveis

O Que São Skills?

Skills são pacotes de capacidades reutilizáveis e específicos por tarefa que o Codex carrega sob demanda. Elas seguem o padrão aberto de skills para agentes.¹⁴

Estrutura de uma Skill

my-skill/
  SKILL.md           (required — instructions)
  scripts/           (optional — executable scripts)
  references/        (optional — reference docs)
  assets/            (optional — images, icons)
  agents/openai.yaml (optional — metadata, UI, dependencies)

Locais de Descoberta

As skills instaladas pelo usuário são gerenciadas em $CODEX_HOME/skills (padrão: ~/.codex/skills), incluindo skills de sistema integradas em .system/. O Codex suporta pastas de skills com links simbólicos.

Criando uma Skill

Formato do SKILL.md:

---
name: security-audit
description: Run a comprehensive security audit on the codebase.
---

## Procedimento de auditoria de segurança

1. Procure por segredos hardcoded usando `rg -i "(api_key|password|secret|token)\s*=" --type py`
2. Verifique vulnerabilidades de SQL injection: procure por interpolação de strings em queries
3. Valide a validação de entrada em todos os endpoints da API
4. Verifique vulnerabilidades de dependências: `pip audit` ou `npm audit`
5. Revise os padrões de autenticação e autorização
6. Relate as descobertas com níveis de severidade (Crítico/Alto/Médio/Baixo)

Metadados (agents/openai.yaml):

interface:
  display_name: "Security Audit"
  short_description: "Comprehensive codebase security review"
  icon_small: "./assets/shield.svg"
  brand_color: "#DC2626"
  default_prompt: "Run a security audit on this repository"

policy:
  allow_implicit_invocation: false    # Require explicit $skill

dependencies:
  tools:
    - type: "mcp"
      value: "snyk"
      transport: "streamable_http"
      url: "https://mcp.snyk.io/mcp"

Invocando skills

• Explícita: Menu /skills ou menção $skill-name no prompt
• Implícita: Codex detecta automaticamente skills correspondentes a partir da descrição da tarefa (se allow_implicit_invocation: true)
• Criador: Use $skill-creator para construir interativamente uma nova skill
• Instalador: Use $skill-installer install <name> para instalar skills da comunidade

Ativar/Desativar

[[skills.config]]
path = "/path/to/skill/SKILL.md"
enabled = false

Plan mode e colaboração

O plan mode permite que o Codex projete uma abordagem antes de executar alterações. Ele é ativado por padrão (desde a v0.94.0).¹⁵

Entrando no plan mode

/plan                              # Switch to plan mode
/plan "redesign the API layer"     # Plan mode with initial prompt

No plan mode, o Codex: - Lê arquivos e analisa o codebase - Propõe um plano de implementação - Não faz alterações até que você aprove - Transmite o plano em uma visualização dedicada na TUI

Steer mode

O steer mode (ativado por padrão desde a v0.98.0) permite que você injete novas instruções enquanto o Codex está trabalhando:

• Enter: Envia instruções imediatamente durante uma execução em andamento
• Tab: Enfileira um acompanhamento para após a conclusão da execução atual

Isso possibilita correção de curso em tempo real sem interromper o agente.

Bifurcação de conversas

Bifurque conversas para explorar alternativas sem perder seu progresso atual:

/fork                              # Fork current conversation
/fork "try a different approach"   # Fork with new prompt

Bifurcações criam threads independentes — alterações em uma bifurcação não afetam a outra.

Modo não interativo (codex exec)

codex exec executa o Codex de forma não interativa para scripting, CI/CD e automação.¹⁶

Uso básico

codex exec "summarize the repository structure"
codex exec --full-auto "fix the CI failure"
codex exec --json "triage open bugs" -o result.txt

Por padrão, codex exec escreve progresso/eventos em stderr e a mensagem final do agente em stdout. Isso o torna componível com pipelines Unix padrão.

Saída em JSON Lines

Com --json, o stdout se torna um fluxo de eventos JSONL:

codex exec --json "fix the tests" | jq

Tipos de eventos: thread.started, turn.started/completed/failed, item.started/completed, error

{"type":"thread.started","thread_id":"019c5c94-..."}
{"type":"turn.started"}
{"type":"item.started","item":{"id":"item_1","type":"command_execution","status":"in_progress"}}
{"type":"item.completed","item":{"id":"item_3","type":"agent_message","text":"..."}}
{"type":"turn.completed","usage":{"input_tokens":24763,"cached_input_tokens":24448,"output_tokens":122}}

Saída estruturada

Imponha o formato da resposta com JSON Schema:

codex exec "Extract project metadata" \
  --output-schema ./schema.json \
  -o ./project-metadata.json

-o / --output-last-message salva a mensagem final em um arquivo.

Retomar e revisar sessões

codex exec resume --last "continue where you left off"
codex exec resume <SESSION_ID> "fix the remaining issues"
codex exec review --base main           # Code review against a branch

Flags principais

Autenticação em CI

codex exec suporta CODEX_API_KEY para autenticação não interativa em ambientes de automação.

Codex Cloud e tarefas em segundo plano [EXPERIMENTAL]

Status: Codex Cloud é um recurso experimental. Interfaces, preços e disponibilidade podem mudar. Os ambientes cloud são gerenciados pela OpenAI — você não controla a infraestrutura.

O Codex Cloud executa tarefas de forma assíncrona em ambientes gerenciados pela OpenAI.⁴

Como funciona

1. Envie uma tarefa (via chatgpt.com/codex, integração com Slack ou CLI)
2. O Codex clona seu repositório em um sandbox cloud isolado
3. O agente trabalha de forma independente — lê código, executa testes, faz alterações
4. Quando finalizado, o Codex cria um PR ou fornece um diff para revisão
5. Aplique os resultados localmente com codex apply <TASK_ID>

Acesso à internet no cloud

O acesso à internet do agente está desativado por padrão e é configurado por ambiente:

• Desativado: Sem acesso à internet para o agente (padrão)
• Ativado: Lista de domínios permitidos opcional + restrições de métodos HTTP

Allowed domains: pypi.org, npmjs.com, github.com
Allowed methods: GET, HEAD, OPTIONS

Scripts de configuração ainda podem usar a internet para instalar dependências, mesmo quando o acesso à internet do agente está desativado.

Integração com Slack

Mencione @Codex em um canal ou thread do Slack para iniciar uma tarefa cloud.

Pré-requisitos: 1. Plano ChatGPT elegível (Plus, Pro, Business, Enterprise ou Edu) 2. Conta GitHub conectada 3. Pelo menos um ambiente cloud configurado 4. App do Slack instalado no seu workspace

O Codex responde com um link da tarefa e publica os resultados quando concluído.

CLI para cloud

codex cloud exec --env <ENV_ID> "Fix failing tests"  # Start a cloud task
codex cloud status <TASK_ID>                          # Check task progress
codex cloud diff <TASK_ID>                            # View task diff
codex cloud list                                      # List recent tasks
codex cloud list --json                               # JSON output
codex cloud apply <TASK_ID>                           # Apply from cloud subcommand
codex apply <TASK_ID>                                 # Apply diff (top-level shortcut)

O Codex Desktop App

O Codex Desktop App (somente macOS, Apple Silicon) oferece uma interface gráfica otimizada para gerenciamento de múltiplos projetos.¹⁷

Instalação

codex app                      # Auto-downloads and installs on first run

Ou baixe diretamente: Codex.dmg

Principais recursos

Automações

As automações são executadas localmente no app — o app deve estar em execução e o projeto disponível no disco:

• Em repositórios Git, as automações usam worktrees dedicadas em segundo plano
• Em projetos não-Git, as execuções ocorrem diretamente no diretório do projeto
• As automações utilizam suas configurações padrão de sandbox

Exemplos de casos de uso: - Triagem de issues: Categorize e priorize automaticamente novas issues - Monitoramento de CI: Acompanhe falhas de build e sugira correções - Resposta a alertas: Reaja a alertas de monitoramento com análise diagnóstica - Atualização de dependências: Verifique e aplique patches de segurança

Os resultados aparecem em uma fila de revisão para aprovação humana.

Suporte para Windows

Os testes alpha para Windows foram abertos em fevereiro de 2026. Inscreva-se em openai.com para acesso antecipado.¹⁸

GitHub Action e CI/CD

A GitHub Action oficial integra o Codex ao seu pipeline de CI/CD.¹⁹

Uso básico

# .github/workflows/codex.yml
name: Codex
on:
  pull_request:
    types: [opened]

jobs:
  codex:
    runs-on: ubuntu-latest
    outputs:
      final_message: ${{ steps.run_codex.outputs.final-message }}
    steps:
      - uses: actions/checkout@v5
      - name: Run Codex
        id: run_codex
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          prompt-file: .github/codex/prompts/review.md
          sandbox: workspace-write
          safety-strategy: drop-sudo

Opções de configuração

Saída: final-message — texto da resposta final do Codex para steps/jobs subsequentes.

Estratégias de segurança

Controles de acesso

with:
  allow-users: "admin,maintainer"     # Limit who can trigger
  allow-bots: false                   # Block bot-triggered runs

Padrão: Somente colaboradores com acesso de escrita podem acionar workflows do Codex.

Codex SDK

O SDK TypeScript incorpora as capacidades de agente do Codex em aplicações personalizadas.²⁰

Instalação

npm install @openai/codex-sdk

Uso básico

import { Codex } from "@openai/codex-sdk";

const codex = new Codex();
const thread = codex.startThread();

// Multi-turn conversation
const turn1 = await thread.run("Diagnose CI failures and propose a fix");
console.log(turn1.finalResponse);

const turn2 = await thread.run("Implement the fix and add tests");
console.log(turn2.items);

// Resume a previous session
const resumed = codex.resumeThread("<thread-id>");
await resumed.run("Continue from previous work");

Recursos avançados do SDK

• runStreamed(...): Stream de eventos assíncronos para atualizações intermediárias
• outputSchema: Impõe formato JSON na saída final
• Entrada multimodal: Passe texto + imagens locais ({ type: "local_image", path: "..." })

Configuração de thread e cliente

// Custom working directory, skip git check
const thread = codex.startThread({
  workingDirectory: "/path/to/project",
  skipGitRepoCheck: true,
});

// Custom environment and config overrides
const codex = new Codex({
  env: { CODEX_API_KEY: process.env.MY_KEY },
  config: { model: "gpt-5.2-codex" },
});

As sessões persistem em ~/.codex/sessions.

Runtime: Node.js 18+.

Quanto custa o Codex?

Acesso via planos do ChatGPT

A disponibilidade do Codex depende do seu plano do ChatGPT e das configurações da organização:

Os limites e o throughput dos planos estão sujeitos a alterações. Verifique os direitos atuais no ChatGPT e nas configurações de administração.

Cobrança da API

Ao usar o Codex através da API, o uso é cobrado por token conforme a precificação padrão da API da OpenAI para o modelo selecionado (mais quaisquer descontos aplicáveis de cache de prompts). Consulte a página oficial de preços da API para as taxas atuais.

Estratégias de otimização de custos

1. Use profiles: Crie um profile fast com gpt-5.1-codex-mini e model_reasoning_effort = "low" para tarefas rotineiras
2. Reserve raciocínio alto: Use xhigh apenas para problemas genuinamente difíceis — custa de 3 a 5x mais tokens
3. Use --ephemeral: Pule a persistência de sessão em CI/CD para reduzir overhead
4. Minimize resumos de raciocínio: Defina model_reasoning_summary = "none" quando não precisar de explicações
5. Agrupe com exec mode: codex exec evita o overhead do TUI para fluxos de automação
6. Monitore o uso: Verifique /status no TUI e os painéis de cobrança da sua organização

Otimização de desempenho

Gerenciamento de contexto

Os modelos principais têm janelas de contexto de 272K, mas elas ainda se esgotam mais rápido do que você imagina. Gerencie proativamente:

1. Use /compact regularmente: Resume o histórico da conversa para liberar tokens
2. Forneça documentação local: AGENTS.md de alta qualidade e documentação local reduzem o overhead de exploração (que consome contexto)
3. Use @ para anexar arquivos específicos: Referencie arquivos diretamente em vez de pedir ao Codex para encontrá-los
4. Mantenha os prompts focados: Prompts com escopo definido e arquivos exatos consomem menos contexto do que exploração aberta

Eficiência de tokens

Otimização de velocidade

1. gpt-5.3-codex-spark: Variante de menor latência para pareamento interativo
2. --profile fast: Modelo mini pré-configurado com raciocínio baixo
3. Execução paralela de ferramentas: O Codex executa leituras/verificações independentes simultaneamente — estruture prompts para habilitar isso
4. Loops orientados a resultado: Peça “implemente, teste, corrija, pare quando estiver verde” em vez de instruções passo a passo

Como depurar problemas?

Problemas comuns e soluções

Ferramentas de diagnóstico

codex --version                        # Check CLI version
codex login status                     # Verify authentication
codex mcp list                         # Check MCP server status
codex debug app-server --help          # Debug app server issues

Diagnósticos no TUI durante a sessão:

/status                                # Token/session overview
/config                                # Inspect effective config values and sources
/compact                               # Summarize history to reclaim context

Nota: codex --verbose não é um flag válido de nível superior. Use os subcomandos de debug e os diagnósticos do TUI acima.

Reinstalação limpa

npm uninstall -g @openai/codex && npm install -g @openai/codex@latest

Modo de debug

codex debug app-server send-message-v2  # Test app-server client

Reportando problemas

/feedback                              # Send logs to Codex maintainers (in TUI)

Ou registre issues em github.com/openai/codex/issues.¹

Implantação empresarial

Controles administrativos (Managed Admin Config)

A política empresarial é aplicada via managed admin config (nível de sistema), que pode exigir modos de execução seguros e restringir configurações do usuário:²²

# /etc/codex/managed-admin-config.toml

model_reasoning_effort = "high"
model_reasoning_summary = "auto"
model = "gpt-5.3-codex"

require_approval = "untrusted"
require_sandbox = "workspace-write"

O managed admin config atua como uma camada de restrição — ele força ou bloqueia valores após a mesclagem normal de configurações, não como apenas mais um nível de override.

Configuração via MDM no macOS

Distribua via MDM usando o domínio de preferência com.openai.codex:

Integração com OpenTelemetry

O Codex suporta propagação de trace-context do OpenTelemetry a partir de variáveis de ambiente OTel padrão até as chamadas à API da OpenAI. Configure o OTel no seu stack de runtime/coletor:

• Variáveis de ambiente OTEL_* padrão são respeitadas
• O contexto de trace propaga através do Codex até as chamadas de API
• Considere os requisitos de privacidade ao habilitar o logging de prompts/ferramentas

Acesso empresarial

• ChatGPT Business / Enterprise / Edu: Acesso controlado pelo administrador da organização
• API: Autenticação padrão de API, cobrança e controles de organização/projeto
• Codex SDK: Incorpore em ferramentas internas e fluxos de trabalho
• Managed config: Use managed config + managed admin config para aplicação de políticas em escala

Dicas e técnicas da comunidade

Padrões de prompting

1. Prompts orientados por restrições: Comece com limites — “NÃO altere os contratos da API. Refatore apenas a implementação interna.”
2. Passos de reprodução estruturados: Passos numerados produzem correções de bugs melhores do que descrições vagas
3. Solicitações de verificação: Termine com “Execute o lint + a menor suíte de testes relevante. Reporte os comandos e resultados.”
4. Referências a arquivos: Use @filename para anexar arquivos específicos ao contexto
5. Loops orientados a resultado: “Implemente, execute os testes, corrija falhas, pare somente quando todos os testes passarem” — o Codex itera até concluir

Filosofia de testes

A comunidade converge para colaboração com IA orientada por testes:²³

• Defina testes antecipadamente como sinais de conclusão
• Deixe o Codex iterar até os testes passarem (red → green → refactor)
• Adote padrões de programação Tiger Style
• Forneça o texto exato do arquivo ao solicitar patches — o Codex usa correspondência estrita, não patching fuzzy baseado em AST

Melhores práticas de gerenciamento de contexto

• Forneça documentação local de alta qualidade em vez de depender de busca na web
• Mantenha markdown estruturado com sumários e arquivos de progresso (“divulgação progressiva”)
• Normalize finais de linha (LF vs CRLF) em todos os arquivos rastreados para evitar falhas de patch
• Mantenha o AGENTS.md conciso — instruções longas são empurradas para fora do contexto

Fluxo de trabalho com Git

• Sempre crie um novo branch antes de executar o Codex em repositórios desconhecidos
• Use fluxos baseados em patch (git diff / git apply) em vez de edições diretas
• Revise as sugestões do Codex como PRs de code review
• Use /diff para verificar alterações antes de fazer commit

Skills e prompts da comunidade

O repositório feiskyer/codex-settings fornece configurações testadas em batalha:²⁴

Prompts reutilizáveis (em ~/.codex/prompts/): - deep-reflector: Extraia aprendizados de sessões de desenvolvimento - github-issue-fixer [issue-number]: Análise sistemática de bugs e criação de PRs - github-pr-reviewer [pr-number]: Fluxos de code review - ui-engineer [requirements]: Desenvolvimento frontend de qualidade de produção

Skills da comunidade: - claude-skill: Transfira tarefas para o Claude Code com modos de permissão - autonomous-skill: Automação de tarefas multi-sessão com rastreamento de progresso - deep-research: Orquestração paralela de sub-tarefas - kiro-skill: Pipeline de requisitos → design → tarefas → execução

Guia de migração

A partir do Claude Code

Diferenças importantes para entender:

• O sandbox é no nível do SO: o Codex usa Seatbelt/Landlock, não contêineres. As restrições são mais difíceis de contornar.
• Sem hooks: o Codex não possui um equivalente direto 1:1 aos hooks do Claude Code. Use instruções no AGENTS.md ou skills.
• Sem subagents: o Codex não possui um modelo local de subagents 1:1. Use tarefas na nuvem ou orquestração via SDK para delegação.
• AGENTS.md é multiplataforma: seu AGENTS.md funciona no Cursor, Amp e Jules também. O CLAUDE.md é exclusivo do Claude.
• Profiles substituem a troca manual: em vez de alterar flags a cada execução, defina profiles no config.toml.

A partir do GitHub Copilot

O que você ganha: - Capacidade agêntica completa (edição de arquivos, execução de comandos, operações git) - Delegação de tarefas na nuvem - Sandboxing no nível do SO - Integrações MCP

A partir do Cursor

Cartão de referência rápida

╔═══════════════════════════════════════════════════════════════╗
║                    CODEX CLI QUICK REFERENCE                  ║
╠═══════════════════════════════════════════════════════════════╣
║                                                               ║
║  LAUNCH                                                       ║
║  codex                      Interactive TUI                   ║
║  codex "prompt"             TUI with initial prompt           ║
║  codex exec "prompt"        Non-interactive mode              ║
║  codex app                  Desktop app                       ║
║  codex resume               Resume previous session           ║
║  codex fork                 Fork a session                    ║
║                                                               ║
║  FLAGS                                                        ║
║  -m, --model <model>        Select model                      ║
║  -p, --profile <name>       Load config profile               ║
║  -s, --sandbox <mode>       Sandbox mode                      ║
║  -C, --cd <dir>             Working directory                 ║
║  -i, --image <file>         Attach image(s)                   ║
║  -c, --config <key=value>   Override config                   ║
║  --full-auto                workspace-write + on-request      ║
║  --oss                      Use local models (Ollama)         ║
║  --search                   Enable live web search            ║
║                                                               ║
║  SLASH COMMANDS (in TUI)                                      ║
║  /compact      Free tokens   /diff        Git diff            ║
║  /review       Code review   /plan        Plan mode           ║
║  /model        Switch model  /status      Session info        ║
║  /fork         Fork thread   /init        AGENTS.md scaffold  ║
║  /mcp          MCP tools     /skills      Invoke skills       ║
║  /ps           Background    /personality Style               ║
║  /permissions  Approval mode /statusline  Footer config       ║
║                                                               ║
║  TUI SHORTCUTS                                                ║
║  @              Fuzzy file search                             ║
║  !command       Run shell command                             ║
║  Ctrl+G         External editor                               ║
║  Enter          Inject instructions (while running)           ║
║  Esc Esc        Edit previous messages                        ║
║                                                               ║
║  EXEC MODE (CI/CD)                                            ║
║  codex exec --full-auto "task"          Sandboxed auto        ║
║  codex exec --json -o out.txt "task"    JSON + file output    ║
║  codex exec --output-schema s.json      Structured output     ║
║  codex exec resume --last "continue"    Resume session        ║
║                                                               ║
║  MCP MANAGEMENT [experimental]                                ║
║  codex mcp add <name> -- <cmd>    Add STDIO server            ║
║  codex mcp add <name> --url <u>   Add HTTP server             ║
║  codex mcp list                    List servers                ║
║  codex mcp login <name>           OAuth flow                  ║
║  codex mcp remove <name>          Delete server               ║
║                                                               ║
║  CLOUD [EXPERIMENTAL]                                         ║
║  codex cloud exec --env <ID> Start cloud task                 ║
║  codex cloud status <ID>     Check task progress              ║
║  codex cloud diff <ID>       View task diff                   ║
║  codex cloud list            List tasks                       ║
║  codex apply <TASK_ID>       Apply cloud diff locally         ║
║                                                               ║
║  CONFIG FILES                                                 ║
║  ~/.codex/config.toml        User config                      ║
║  .codex/config.toml          Project config                   ║
║  ~/.codex/AGENTS.md          Global instructions              ║
║  AGENTS.md                   Project instructions             ║
║  managed-admin-config.toml   Enterprise policy constraints    ║
║                                                               ║
║  SANDBOX MODES                                                ║
║  read-only          Read files only, no mutations             ║
║  workspace-write    Read/write in workspace + /tmp            ║
║  danger-full-access Full machine access                       ║
║                                                               ║
║  APPROVAL POLICIES                                            ║
║  untrusted     Prompt for all mutations                       ║
║  on-failure    Auto-run until failure                         ║
║  on-request    Prompt for boundary violations                 ║
║  never         No prompts                                     ║
║                                                               ║
║  MODELS (Feb 2026)                                            ║
║  gpt-5.3-codex         Default flagship (272K)               ║
║  gpt-5.3-codex-spark   Interactive, lower latency (128K)     ║
║  gpt-5.2-codex         Long-horizon refactors (272K)         ║
║  gpt-5.1-codex-mini    Quick tasks, cost-efficient (272K)    ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Registro de alterações

Referências