Codex CLI: The Definitive Technical Reference

Codex opera como un agente de codificación multi-superficie, no como un chatbot que escribe código. El CLI lee su base de código, ejecuta comandos en un sandbox, aplica parches a archivos, se conecta a servicios externos mediante MCP y delega tareas de larga duración a la nube. Se ejecuta localmente pero piensa globalmente — la misma inteligencia impulsa cuatro superficies distintas según su forma de trabajar.

La diferencia entre un uso casual y uno efectivo de Codex se reduce a cinco sistemas fundamentales. Domínelos y Codex se convertirá en un multiplicador de fuerza:

1. Sistema de configuración — controla el comportamiento mediante config.toml
2. Sandbox y modelo de aprobación — regula lo que Codex puede hacer
3. AGENTS.md — define contratos operativos a nivel de proyecto
4. Protocolo MCP — extiende las capacidades hacia servicios externos
5. Sistema de skills — empaqueta experiencia de dominio reutilizable

Dediqué meses ejecutando Codex junto con Claude Code en bases de código en producción, pipelines de CI/CD y flujos de trabajo en equipo. Esta guía destila esa experiencia en la referencia integral que me hubiera gustado tener cuando comencé. Cada función incluye la sintaxis real, ejemplos de configuración prácticos y los casos límite que confunden incluso a usuarios experimentados.

Nota de estabilidad: Las funciones marcadas como [EXPERIMENTAL] están sujetas a cambios entre versiones. Codex Cloud y el grupo de comandos MCP son experimentales a partir de la v0.101.0. El CLI principal, sandbox, AGENTS.md, config.toml y Skills son estables.

Cómo funciona Codex: El modelo mental

Antes de profundizar en las funciones, es importante comprender cómo la arquitectura de Codex da forma a todo lo que hace con él. El sistema opera a través de cuatro superficies respaldadas por una capa de inteligencia compartida:

┌─────────────────────────────────────────────────────────┐
│                    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          │
└─────────────────────────────────────────────────────────┘

Capa central: La familia de modelos GPT-5.x-Codex impulsa todo el sistema. A partir de la versión v0.101.0, gpt-5.3-codex es el modelo predeterminado con una ventana de contexto de 272K tokens. Lee archivos, escribe parches, ejecuta comandos de shell y razona sobre su base de código. Cuando el contexto se llena, Codex compacta la conversación para liberar espacio. Esta capa consume tokens.

Capa de seguridad: Cada comando que Codex ejecuta pasa por un sandbox a nivel del sistema operativo. En macOS, el framework Seatbelt de Apple aplica restricciones a nivel del kernel. En Linux, Landlock + seccomp filtran el acceso al sistema de archivos y a las llamadas del sistema. Esto no se basa en contenedores: está integrado en el sistema operativo. La política de aprobación determina entonces cuándo solicitar confirmación humana.

Capa de extensiones: MCP conecta servicios externos (GitHub, Figma, Sentry). Skills empaqueta flujos de trabajo reutilizables que Codex carga bajo demanda. Apps se conecta a conectores de ChatGPT. La búsqueda web añade contexto en tiempo real desde internet.

Capa de superficie: CLI para usuarios avanzados de terminal y automatización. Codex Desktop App para gestión de proyectos con múltiples hilos. Extensión de IDE para ciclos de edición-compilación-prueba. Cloud para tareas asíncronas que se ejecutan de forma independiente.

La perspectiva clave: La mayoría de los usuarios solo utiliza una superficie. Los usuarios avanzados emplean las cuatro: Cloud para tareas de larga duración, CLI para operaciones deterministas en repositorios, la extensión de IDE para ciclos de codificación ajustados y Codex Desktop App para planificación y coordinación.

Tabla de contenidos

1. ¿Cómo instalo Codex?
2. Superficies de interacción principales
3. Análisis profundo del sistema de configuración
4. ¿Qué modelo debo elegir?
5. Marcos de decisión
6. ¿Cómo funciona el sistema de sandbox y aprobación?
7. ¿Cómo funciona AGENTS.md?
8. ¿Qué es MCP (Model Context Protocol)?
9. ¿Qué son los Skills?
10. Modo de planificación y colaboración
11. Modo no interactivo (codex exec)
12. Codex Cloud y tareas en segundo plano
13. Codex Desktop App
14. GitHub Action y CI/CD
15. Codex SDK
16. ¿Cuánto cuesta Codex?
17. Optimización del rendimiento
18. ¿Cómo depuro problemas?
19. Implementación empresarial
20. Consejos y técnicas de la comunidad
21. Guía de migración
22. Tarjeta de referencia rápida
23. Registro de cambios
24. Referencias

¿Cómo instalo Codex?

Gestores de paquetes

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

# Homebrew (macOS)
brew install --cask codex

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

Descargas de binarios

Para entornos sin npm o Homebrew, descargue binarios específicos para cada plataforma desde GitHub Releases¹:

Requisitos del sistema

• macOS: Apple Silicon o Intel (soporte completo de sandbox vía Seatbelt)
• Linux: x86_64 o arm64 (sandbox vía Landlock + seccomp)
• Windows: Experimental (se recomienda WSL para soporte completo de sandbox)²

Autenticación

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

Dos rutas de autenticación:

1. Cuenta de ChatGPT (recomendada): Inicie sesión con su suscripción existente de Plus, Pro, Team, Business, Edu o Enterprise. Acceso completo a todas las funciones, incluidas las tareas en la nube.
2. API Key: Configúrela mediante la variable de entorno CODEX_API_KEY o con codex login --with-api-key. Algunas funciones (hilos en la nube) podrían no estar disponibles.

Consejo avanzado: El almacenamiento de credenciales es configurable mediante cli_auth_credentials_store en config.toml. Opciones: file (predeterminado), keyring (llavero del sistema operativo) o auto (llavero si está disponible, archivo como respaldo).

Autocompletado de 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 la instalación

codex --version
# Codex CLI v0.101.0

Superficies de interacción principales

Codex ofrece cuatro interfaces distintas respaldadas por la misma inteligencia. Cada superficie está optimizada para un patrón de flujo de trabajo diferente.

1. CLI interactivo (TUI de terminal)

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

La TUI de terminal es una aplicación de pantalla completa con:

• Compositor: Escriba indicaciones, adjunte archivos con @, ejecute comandos de shell con el prefijo !
• Panel de salida: Respuestas del modelo en streaming, llamadas a herramientas y salida de comandos
• Barra de estado: Modelo, uso de tokens, rama de git, modo de sandbox

Atajos clave de la TUI:

Slash commands disponibles en la TUI:

2. Codex Desktop App (macOS)

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

Codex Desktop App añade capacidades que el CLI no tiene:

• Multitarea: Ejecute múltiples agentes en paralelo en diferentes proyectos simultáneamente
• Aislamiento con git worktrees: Cada hilo trabaja sobre una copia aislada de su repositorio
• Revisión de diffs integrada: Prepare, revierta y confirme cambios sin salir de la aplicación
• Terminal integrada: Terminal por hilo para ejecutar comandos
• Bifurcación de conversaciones: Ramifique conversaciones para explorar alternativas
• Ventanas emergentes flotantes: Separe conversaciones en ventanas portátiles
• Automatizaciones: Programe tareas recurrentes (triaje de issues, monitoreo de CI, respuesta a alertas)

¿Cuándo usar la aplicación vs. el CLI?: Use Codex Desktop App cuando esté coordinando múltiples flujos de trabajo o necesite revisión visual de diffs. Use el CLI cuando desee composabilidad en terminal, scripting o integración con CI/CD.

3. Extensión de IDE (VS Code, Cursor, Windsurf)

La extensión de Codex para IDE se integra directamente en su editor:

• Modo agente por defecto: Lee archivos, realiza ediciones, ejecuta comandos
• Ediciones en línea: Sugerencias con reconocimiento de contexto en sus archivos activos
• Sesiones compartidas: Las sesiones se sincronizan entre el CLI y la extensión de IDE
• Misma autenticación: Inicie sesión con su cuenta de ChatGPT o API key

Instale desde el VS Code Marketplace o las tiendas de extensiones de Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Las tareas en la nube se ejecutan de forma asíncrona en entornos administrados por OpenAI:

• Enviar y olvidar: Encole tareas que se ejecutan independientemente de su computadora local
• Ejecución en paralelo: Ejecute múltiples tareas en la nube simultáneamente
• Creación de PR: Codex crea pull requests a partir del trabajo completado
• Aplicación local: Incorpore los resultados de la nube a su repositorio local con codex apply <TASK_ID>

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

Las tareas en la nube también son accesibles desde chatgpt.com/codex.⁴

Inmersión en el sistema de configuración

Codex utiliza TOML para la configuración. Comprender la jerarquía de precedencia es fundamental — determina qué configuraciones prevalecen cuando entran en conflicto.

Precedencia (de mayor a menor)

1. Sobrecargas de sesión (máxima): Flags de CLI (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) y sobrecargas -c key=value
2. Configuración de proyecto (.codex/config.toml, descubierta desde el CWD hacia arriba hasta la raíz del proyecto — el directorio más cercano prevalece)
3. Configuración de usuario ($CODEX_HOME/config.toml, por defecto ~/.codex/config.toml)
4. Configuración del sistema (/etc/codex/config.toml en Unix)
5. Valores predeterminados incorporados (mínima)

La managed admin config actúa como una capa de restricción de políticas y puede forzar o prohibir valores después de la combinación normal. Consulte Enterprise Deployment.

Ubicaciones de archivos de configuración

Consejo avanzado: La variable de entorno CODEX_HOME sobrescribe el directorio predeterminado ~/.codex. Útil para CI/CD o configuraciones con múltiples cuentas.

Referencia completa de configuración

# ~/.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

Perfiles

Presets de configuración con nombre para diferentes modos de trabajo:

# 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"

Active un perfil:

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

Consejo avanzado: Establezca un perfil predeterminado con profile = "fast" en el nivel superior de su configuración. Sobrescríbalo por sesión con --profile.

Proveedores de modelos personalizados

Conéctese a Azure, modelos locales o servicios 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 locales con el 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

O establézcalo en la configuración:

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

Sobrecargas de configuración en línea

Sobrescriba cualquier valor de configuración desde la línea de comandos:

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"

¿Qué modelo debería elegir?

Modelos disponibles (febrero de 2026)

La lista exacta de modelos varía según la cuenta y el despliegue. Consulte su caché local: ~/.codex/models_cache.json.

Diagrama de flujo para selección 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

Esfuerzo de razonamiento

Controle cuánto “piensa” el modelo antes de responder:

Los niveles compatibles dependen del modelo. No todos los modelos admiten todos los niveles.

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

Consejo avanzado: El razonamiento xhigh puede utilizar entre 3 y 5 veces más tokens que medium para el mismo prompt. Resérvelo para problemas genuinamente difíciles donde el pensamiento adicional realmente valga la pena.

Cambio de modelo

Cambie de modelo durante la sesión con el slash command /model, o configúrelo por ejecución mediante --model / -m:

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

Marcos de decisión

Cuándo usar cada superficie

Cuándo usar cada modo de sandbox

Cuándo usar cada nivel de razonamiento

¿Cómo funciona el sistema de Sandbox y aprobación?

Codex utiliza un modelo de seguridad de dos capas que separa lo que es técnicamente posible de cuándo se requiere aprobación humana. Esto es fundamentalmente diferente del sistema de permisos de Claude Code — Codex aplica restricciones a nivel del kernel del sistema operativo.⁵

Capa 1: Sandbox (lo que es posible)

El sandbox controla el acceso al sistema de archivos y a la red utilizando mecanismos nativos del sistema operativo:

Implementación específica por plataforma:

• macOS: Framework Seatbelt de Apple mediante sandbox-exec con perfiles específicos por modo, compilados en tiempo de ejecución y aplicados por el kernel⁶
• Linux: Landlock para restricciones del sistema de archivos + seccomp para filtrado de llamadas al sistema. Un proceso auxiliar independiente (codex-linux-sandbox) proporciona aislamiento con defensa en profundidad. Pipeline opcional con Bubblewrap (bwrap) disponible como alternativa⁷
• Windows: Sandbox nativo experimental con tokens restringidos. Se recomienda WSL para soporte completo de sandbox (hereda Landlock + seccomp de Linux)

Por qué esto importa: A diferencia del sandboxing basado en contenedores (Docker), el sandboxing a nivel del sistema operativo es más rápido, más ligero y más difícil de evadir. El kernel aplica las restricciones antes de que Codex siquiera vea la llamada al sistema.

Capa 2: Política de aprobación (cuándo preguntar)

La política de aprobación determina cuándo Codex se detiene para solicitar confirmación humana:

La flag --full-auto

--full-auto es un alias de conveniencia para:

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

Advertencia importante: --full-auto anula cualquier valor explícito de --sandbox. Si pasa --full-auto --sandbox read-only, obtiene workspace-write porque --full-auto tiene prioridad.⁸

Configuraciones recomendadas

Desarrollo diario (valor predeterminado seguro):

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

Usuario avanzado (acceso completo, supervisión humana):

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

Esta es la configuración recomendada por la comunidad como el punto óptimo — máxima capacidad pero con aprobación requerida para cada comando.⁹

Automatización CI/CD:

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

Habilitar acceso a la red

La red está bloqueada por defecto en el modo workspace-write. Habilítela cuando sea necesario:

# 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

Probar el sandbox

Verifique el comportamiento del sandbox antes de confiar en él:

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

¿Cómo funciona AGENTS.md?

AGENTS.md es el sistema de instrucciones de proyecto de Codex — un estándar abierto¹⁰ compatible con Codex, Cursor, Amp, Jules (Google) y Factory. Define cómo Codex debe comportarse dentro de un repositorio o directorio específico.

Jerarquía de descubrimiento

Codex construye una cadena de instrucciones al inicio de la sesión recorriendo el árbol de directorios:

1. Global (~/.codex/): AGENTS.override.md > AGENTS.md
2. Proyecto (raíz de git hasta el directorio actual): Cada nivel se verifica para AGENTS.override.md > AGENTS.md > nombres de archivo alternativos
3. Combinación: Los archivos se concatenan desde la raíz hacia abajo; los archivos más cercanos aparecen después en el prompt y anulan las instrucciones 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

Qué hace un gran AGENTS.md

Basado en orientación directa de Codex y patrones de la comunidad¹¹:

SÍ: - Sea específico: "Use rg --files for discovery" es mejor que "search efficiently" - Defina el cierre: ¿Qué significa “hecho”? (pruebas pasan, lint limpio, etc.) - Incluya comandos: Build, test, lint, format — invocaciones exactas - Organice por tarea: Secciones de codificación, revisión, lanzamiento, incidentes/depuración - Defina la escalación: Qué hacer cuando se está bloqueado o se encuentra un estado inesperado

NO: - No incluya guías de estilo completas sin reglas de ejecución - No use directivas ambiguas (“tenga cuidado”, “optimice”) - No mezcle prioridades contradictorias (velocidad + verificación exhaustiva + sin presupuesto de ejecución) - No escriba documentación en prosa — AGENTS.md es política operativa, no README

Ejemplo: AGENTS.md de producción

# 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.

El mecanismo de anulación

AGENTS.override.md en cualquier nivel de directorio reemplaza el AGENTS.md normal para ese alcance. Úselo para:

• Congelaciones de lanzamiento: “Sin funciones nuevas, solo correcciones”
• Modo de incidentes: “Todos los cambios deben ser revisados por el equipo de guardia”
• Endurecimiento temporal: “Sin actualizaciones de dependencias este sprint”

Configuración

# 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)

Generación del scaffold

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

O verifique su cadena de instrucciones:

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

¿Qué es MCP (Model Context Protocol)? [experimental]

MCP extiende las capacidades de Codex conectándolo con herramientas y servicios externos. El grupo de comandos codex mcp está actualmente marcado como experimental — los comandos y el formato de configuración pueden cambiar entre versiones. Codex admite dos tipos de transporte: STDIO (procesos locales) y Streamable HTTP (servidores remotos).¹²

Configuración de servidores MCP

Servidores STDIO (procesos locales):

# 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

Gestión por 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

Durante la sesión: /mcp muestra los servidores activos y las herramientas disponibles.

Ejecutar Codex COMO un servidor MCP

Codex puede exponerse como un servidor MCP para orquestación multiagente:¹³

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

Esto expone dos herramientas: 1. codex(): Iniciar una nueva sesión con parámetros de prompt, sandbox, modelo y aprobación 2. codex-reply(): Continuar una sesión existente con threadId y prompt

Uso con el 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 destacados

¿Qué son los skills?

Los skills son paquetes de capacidades reutilizables y específicos para tareas que Codex carga bajo demanda. Siguen el estándar abierto de skills para agentes.¹⁴

Estructura de un 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)

Ubicaciones de descubrimiento

Los skills instalados por el usuario se gestionan en $CODEX_HOME/skills (predeterminado: ~/.codex/skills), incluyendo los skills del sistema integrados en .system/. Codex admite carpetas de skills enlazadas simbólicamente.

Crear un skill

Formato de SKILL.md:

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

## Procedimiento de auditoría de seguridad

1. Buscar secretos codificados directamente usando `rg -i "(api_key|password|secret|token)\s*=" --type py`
2. Verificar inyección SQL: buscar interpolación de cadenas en consultas
3. Confirmar la validación de entrada en todos los endpoints de API
4. Revisar vulnerabilidades en dependencias: `pip audit` o `npm audit`
5. Revisar patrones de autenticación y autorización
6. Reportar hallazgos con niveles de severidad (Crítico/Alto/Medio/Bajo)

Metadatos (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"

Invocar skills

• Explícita: Menú /skills o mención $skill-name en el prompt
• Implícita: Codex detecta automáticamente skills coincidentes a partir de la descripción de la tarea (si allow_implicit_invocation: true)
• Creador: Use $skill-creator para construir un nuevo skill de forma interactiva
• Instalador: Use $skill-installer install <name> para instalar skills de la comunidad

Habilitar/Deshabilitar

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

Plan Mode y colaboración

Plan mode permite que Codex diseñe un enfoque antes de ejecutar cambios. Está habilitado por defecto (desde la v0.94.0).¹⁵

Entrar en Plan Mode

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

En plan mode, Codex: - Lee archivos y analiza el código base - Propone un plan de implementación - No realiza cambios hasta que usted lo apruebe - Transmite el plan en una vista dedicada de la TUI

Steer Mode

Steer mode (habilitado por defecto desde la v0.98.0) le permite inyectar nuevas instrucciones mientras Codex está trabajando:

• Enter: Envía instrucciones inmediatamente durante un turno en ejecución
• Tab: Pone en cola un seguimiento para después de que el turno actual termine

Esto permite correcciones de rumbo en tiempo real sin detener al agente.

Bifurcación de conversaciones

Bifurque conversaciones para explorar alternativas sin perder su progreso actual:

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

Las bifurcaciones crean hilos independientes — los cambios en una bifurcación no afectan a la otra.

Modo no interactivo (codex exec)

codex exec ejecuta Codex de forma no interactiva para scripting, CI/CD y automatización.¹⁶

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 defecto, codex exec escribe el progreso/eventos en stderr y el mensaje final del agente en stdout. Esto lo hace componible con pipelines estándar de Unix.

Salida en JSON Lines

Con --json, stdout se convierte en un flujo 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}}

Salida estructurada

Imponga la forma de la respuesta con JSON Schema:

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

-o / --output-last-message escribe el mensaje final en un archivo.

Reanudación y revisión de sesiones

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 principales

Autenticación en CI

codex exec soporta CODEX_API_KEY para autenticación no interactiva en entornos de automatización.

Codex Cloud y tareas en segundo plano [EXPERIMENTAL]

Estado: Codex Cloud es una función experimental. Las interfaces, precios y disponibilidad pueden cambiar. Los entornos en la nube son administrados por OpenAI — usted no controla la infraestructura.

Codex Cloud ejecuta tareas de forma asíncrona en entornos administrados por OpenAI.⁴

Cómo funciona

1. Envíe una tarea (a través de chatgpt.com/codex, integración con Slack, o CLI)
2. Codex clona su repositorio en un sandbox aislado en la nube
3. El agente trabaja de forma independiente — lee código, ejecuta pruebas, realiza cambios
4. Al terminar, Codex crea un PR o proporciona un diff para revisión
5. Aplique los resultados localmente con codex apply <TASK_ID>

Acceso a internet en la nube

El acceso a internet del agente está desactivado por defecto y se configura por entorno:

• Desactivado: Sin acceso a internet para el agente (por defecto)
• Activado: Lista de dominios permitidos opcional + restricciones de métodos HTTP

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

Los scripts de configuración aún pueden usar internet para instalar dependencias, incluso cuando el acceso a internet del agente está desactivado.

Integración con Slack

Mencione @Codex en un canal o hilo de Slack para iniciar una tarea en la nube.

Requisitos previos: 1. Plan elegible de ChatGPT (Plus, Pro, Business, Enterprise o Edu) 2. Cuenta de GitHub conectada 3. Al menos un entorno en la nube configurado 4. Aplicación de Slack instalada para su espacio de trabajo

Codex responde con un enlace a la tarea y publica los resultados cuando se completa.

CLI en la nube

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)

La Codex Desktop App

La Codex Desktop App (solo macOS, Apple Silicon) proporciona una interfaz gráfica optimizada para la gestión de múltiples proyectos.¹⁷

Instalación

codex app                      # Auto-downloads and installs on first run

O descargue directamente: Codex.dmg

Funciones principales

Automatizaciones

Las automatizaciones se ejecutan localmente en la aplicación — la aplicación debe estar en ejecución y el proyecto disponible en disco:

• En repositorios Git, las automatizaciones usan worktrees dedicados en segundo plano
• En proyectos sin Git, las ejecuciones se realizan directamente en el directorio del proyecto
• Las automatizaciones usan su configuración de sandbox predeterminada

Casos de uso de ejemplo: - Triaje de issues: Categorizar y priorizar automáticamente nuevos issues - Monitoreo de CI: Vigilar fallos de compilación y sugerir correcciones - Respuesta a alertas: Reaccionar a alertas de monitoreo con análisis de diagnóstico - Actualizaciones de dependencias: Verificar y aplicar parches de seguridad

Los resultados aparecen en una cola de revisión para aprobación humana.

Soporte para Windows

Las pruebas alfa de Windows comenzaron en febrero de 2026. Regístrese en openai.com para acceso anticipado.¹⁸

GitHub Action y CI/CD

La GitHub Action oficial integra Codex en su 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

Opciones de configuración

Salida: final-message — texto de respuesta final de Codex para pasos/trabajos posteriores.

Estrategias de seguridad

Controles de acceso

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

Por defecto: Solo los colaboradores con acceso de escritura pueden activar flujos de trabajo de Codex.

Codex SDK

El SDK de TypeScript incorpora las capacidades de agente de Codex en aplicaciones personalizadas.²⁰

Instalación

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");

Funciones avanzadas del SDK

• runStreamed(...): Flujo de eventos asíncrono para actualizaciones intermedias
• outputSchema: Impone una salida final con formato JSON
• Entrada multimodal: Permite pasar texto + imágenes locales ({ type: "local_image", path: "..." })

Configuración de hilos y 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" },
});

Las sesiones se almacenan en ~/.codex/sessions.

Entorno de ejecución: Node.js 18+.

¿Cuánto cuesta Codex?

Acceso mediante planes de ChatGPT

La disponibilidad de Codex depende de su plan de ChatGPT y de la configuración de su organización:

Los límites y el rendimiento de cada plan están sujetos a cambios. Consulte las asignaciones vigentes en ChatGPT y en la configuración de administración.

Facturación de la API

Cuando utiliza Codex a través de la API, el uso se factura por token según los precios estándar de la API de OpenAI para el modelo seleccionado (más los descuentos aplicables por almacenamiento en caché de prompts). Consulte la página oficial de precios de la API para conocer las tarifas vigentes.

Estrategias de optimización de costos

1. Use perfiles: Cree un perfil fast con gpt-5.1-codex-mini y model_reasoning_effort = "low" para tareas rutinarias
2. Reserve el razonamiento alto: Solo use xhigh para problemas genuinamente difíciles — consume entre 3 y 5 veces más tokens
3. Use --ephemeral: Omita la persistencia de sesión en CI/CD para reducir la sobrecarga
4. Minimice los resúmenes de razonamiento: Configure model_reasoning_summary = "none" cuando no necesite explicaciones
5. Agrupe con el modo exec: codex exec evita la sobrecarga del TUI en flujos de automatización
6. Monitoree el uso: Consulte /status en el TUI y los paneles de facturación de su organización

Optimización de rendimiento

Gestión del contexto

Los modelos principales tienen ventanas de contexto de 272K, pero aun así se llenan más rápido de lo que se imagina. Adminístrelo de forma proactiva:

1. Use /compact con frecuencia: Resume el historial de la conversación para liberar tokens
2. Proporcione documentación local: Un AGENTS.md de alta calidad y documentación local reducen la exploración innecesaria (que consume contexto)
3. Use @ para adjuntar archivos específicos: Haga referencia directa a los archivos en lugar de pedirle a Codex que los busque
4. Mantenga los prompts enfocados: Los prompts acotados con archivos exactos consumen menos contexto que la exploración abierta

Eficiencia de tokens

Optimización de velocidad

1. gpt-5.3-codex-spark: Variante de menor latencia para programación interactiva en pareja
2. --profile fast: Modelo mini preconfigurado con razonamiento bajo
3. Ejecución paralela de herramientas: Codex ejecuta lecturas y verificaciones independientes de forma concurrente — estructure los prompts para aprovechar esto
4. Ciclos orientados a resultados: Solicite “implementar, probar, corregir, detenerse cuando todo esté verde” en lugar de instrucciones paso a paso

¿Cómo depuro problemas?

Problemas comunes y soluciones

Herramientas 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 del TUI durante la sesión:

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

Nota: codex --verbose no es un flag válido de nivel superior. Use los subcomandos de depuración y los diagnósticos del TUI indicados arriba.

Reinstalación limpia

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

Modo de depuración

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

Reportar problemas

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

O registre problemas en github.com/openai/codex/issues.¹

Implementación empresarial

Controles de administración (Managed Admin Config)

La política empresarial se aplica mediante managed admin config (a nivel del sistema), que puede exigir modos de ejecución seguros y restringir la configuración de los usuarios:²²

# /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"

Managed admin config actúa como una capa de restricción — fuerza o prohíbe valores después de la combinación normal de configuración, no como un simple nivel adicional de sobreescritura.

Configuración MDM para macOS

Distribúyalo mediante MDM usando el dominio de preferencias com.openai.codex:

Integración con OpenTelemetry

Codex es compatible con la propagación de contexto de trazas de OpenTelemetry desde las variables de entorno estándar de OTel hasta las llamadas a la API de OpenAI. Configure OTel en su stack de tiempo de ejecución/recolector:

• Se respetan las variables de entorno estándar OTEL_*
• El contexto de traza se propaga a través de Codex hacia las llamadas de la API
• Tenga en cuenta los requisitos de privacidad al habilitar el registro de prompts y herramientas

Acceso empresarial

• ChatGPT Business / Enterprise / Edu: Acceso controlado por el administrador de la organización
• API: Autenticación estándar de la API, facturación y controles de organización/proyecto
• Codex SDK: Incorpórelo en herramientas y flujos de trabajo internos
• Managed config: Use managed config + managed admin config para aplicar políticas a escala

Consejos y técnicas de la comunidad

Patrones de prompts

1. Prompts basados en restricciones: Comience con los límites — “Do NOT change the API contracts. Only refactor internal implementation.”
2. Pasos de reproducción estructurados: Los pasos numerados producen mejores correcciones de errores que las descripciones vagas
3. Solicitudes de verificación: Termine con “Run lint + the smallest relevant test suite. Report commands and results.”
4. Referencias a archivos: Use @filename para adjuntar archivos específicos al contexto
5. Ciclos orientados a resultados: “Implement, run tests, fix failures, stop only when all tests pass” — Codex itera hasta completar la tarea

Filosofía de pruebas

La comunidad converge en la colaboración de IA dirigida por pruebas:²³

• Defina las pruebas por adelantado como señales de finalización
• Permita que Codex itere hasta que las pruebas pasen (rojo → verde → refactorizar)
• Adopte patrones de programación Tiger Style
• Proporcione el texto exacto del archivo al solicitar parches — Codex usa coincidencia estricta, no parches difusos basados en AST

Mejores prácticas de gestión de contexto

• Proporcione documentación local de alta calidad en lugar de depender de búsquedas web
• Mantenga documentación estructurada en markdown con tablas de contenido y archivos de progreso (“divulgación progresiva”)
• Normalice los finales de línea (LF vs CRLF) en todos los archivos rastreados para prevenir fallos de parches
• Mantenga AGENTS.md conciso — las instrucciones largas se desplazan fuera del contexto

Flujo de trabajo con Git

• Siempre cree una rama nueva antes de ejecutar Codex en repositorios desconocidos
• Use flujos de trabajo basados en parches (git diff / git apply) en lugar de ediciones directas
• Revise las sugerencias de Codex como revisiones de código en pull requests
• Use /diff para verificar los cambios antes de confirmarlos

Skills y prompts de la comunidad

El repositorio feiskyer/codex-settings ofrece configuraciones probadas en producción:²⁴

Prompts reutilizables (en ~/.codex/prompts/): - deep-reflector: Extrae aprendizajes de sesiones de desarrollo - github-issue-fixer [issue-number]: Análisis sistemático de errores y creación de pull requests - github-pr-reviewer [pr-number]: Flujos de revisión de código - ui-engineer [requirements]: Desarrollo frontend de calidad profesional

Skills de la comunidad: - claude-skill: Delega tareas a Claude Code con modos de permisos - autonomous-skill: Automatización de tareas en múltiples sesiones con seguimiento de progreso - deep-research: Orquestación paralela de subtareas - kiro-skill: Pipeline de requisitos → diseño → tareas → ejecución

Guía de migración

Desde Claude Code

Diferencias clave que debe comprender:

• El sandbox opera a nivel del sistema operativo: Codex usa Seatbelt/Landlock, no contenedores. Las restricciones son más difíciles de evadir.
• Sin hooks: Codex no tiene un equivalente directo 1:1 a los hooks de Claude Code. Use instrucciones en AGENTS.md o skills en su lugar.
• Sin subagents: Codex no tiene un modelo local de subagents directo 1:1. Use tareas en la nube u orquestación con SDK para delegación.
• AGENTS.md es compatible entre herramientas: Su AGENTS.md funciona también en Cursor, Amp y Jules. CLAUDE.md es exclusivo de Claude.
• Los perfiles reemplazan el cambio manual: En lugar de cambiar flags por ejecución, defina perfiles en config.toml.

Desde GitHub Copilot

Lo que obtiene: - Capacidad agéntica completa (edición de archivos, ejecución de comandos, operaciones git) - Delegación de tareas en la nube - Sandboxing a nivel del sistema operativo - Integraciones MCP

Desde Cursor

Tarjeta de referencia 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 cambios

Referencias