Codex CLI: The Definitive Technical Reference

Codex fonctionne comme un agent de développement multi-surface, et non comme un chatbot qui écrit du code. Le CLI lit votre codebase, exécute des commandes dans un sandbox, modifie des fichiers, se connecte à des services externes via MCP, et délègue les tâches de longue durée au cloud. Il s’exécute localement mais pense globalement — la même intelligence alimente quatre surfaces distinctes selon votre façon de travailler.

La différence entre une utilisation occasionnelle et une utilisation efficace de Codex repose sur cinq systèmes fondamentaux. Maîtrisez-les et Codex devient un multiplicateur de force :

1. Système de configuration — contrôle le comportement via config.toml
2. Sandbox et modèle d’approbation — encadre ce que Codex peut faire
3. AGENTS.md — définit les contrats opérationnels au niveau du projet
4. Protocole MCP — étend les capacités aux services externes
5. Système de Skills — encapsule une expertise métier réutilisable

J’ai passé des mois à utiliser Codex aux côtés de Claude Code sur des codebases de production, des pipelines CI/CD et des workflows d’équipe. Ce guide condense cette expérience en la référence exhaustive que j’aurais aimé avoir quand j’ai commencé. Chaque fonctionnalité inclut la syntaxe réelle, des exemples de configuration concrets et les cas limites qui piègent même les utilisateurs expérimentés.

Note de stabilité : les fonctionnalités marquées [EXPERIMENTAL] sont susceptibles de changer entre les versions. Codex Cloud et le groupe de commandes MCP sont tous deux expérimentaux à partir de la v0.101.0. Le CLI principal, le sandbox, AGENTS.md, config.toml et les Skills sont stables.

Comment fonctionne Codex : le modèle mental

Avant de plonger dans les fonctionnalités, comprenez comment l’architecture de Codex façonne tout ce que vous faites avec lui. Le système opère à travers quatre surfaces soutenues par une couche d’intelligence partagée :

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

Couche centrale (Core Layer) : La famille de modèles GPT-5.x-Codex alimente l’ensemble du système. Depuis la version v0.101.0, gpt-5.3-codex est le modèle par défaut avec une fenêtre de contexte de 272 000 tokens. Il lit les fichiers, écrit des correctifs, exécute des commandes shell et raisonne sur votre base de code. Lorsque le contexte se remplit, Codex compacte la conversation pour libérer de l’espace. Cette couche consomme des tokens.

Couche de sécurité (Security Layer) : Chaque commande exécutée par Codex passe par un sandbox au niveau du système d’exploitation. Sur macOS, le framework Seatbelt d’Apple applique des restrictions au niveau du noyau. Sur Linux, Landlock + seccomp filtrent les accès au système de fichiers et aux appels système. Il ne s’agit pas d’une solution basée sur des conteneurs — c’est intégré directement dans le système d’exploitation. La politique d’approbation détermine ensuite quand demander une confirmation humaine.

Couche d’extension (Extension Layer) : MCP connecte des services externes (GitHub, Figma, Sentry). Les skills encapsulent des flux de travail réutilisables que Codex charge à la demande. Les Apps se connectent aux connecteurs ChatGPT. La recherche web ajoute du contexte en temps réel depuis Internet.

Couche de surface (Surface Layer) : Le CLI pour les utilisateurs avancés du terminal et l’automatisation. L’application de bureau pour la gestion de projet multi-thread. L’extension IDE pour les boucles édition-compilation-test. Le Cloud pour les tâches asynchrones qui s’exécutent de manière indépendante.

L’insight clé : La plupart des utilisateurs n’utilisent qu’une seule surface. Les utilisateurs avancés utilisent les quatre — Cloud pour les tâches de longue durée, CLI pour les opérations déterministes sur le dépôt, l’extension IDE pour les boucles de codage rapides, et l’application de bureau pour la planification et la coordination.

Table des matières

1. Comment installer Codex ?
2. Surfaces d’interaction principales
3. Exploration approfondie du système de configuration
4. Quel modèle choisir ?
5. Cadres de décision
6. Comment fonctionnent le sandbox et le système d’approbation ?
7. Comment fonctionne AGENTS.md ?
8. Qu’est-ce que MCP (Model Context Protocol) ?
9. Que sont les skills ?
10. Mode plan et collaboration
11. Mode non interactif (codex exec)
12. Codex Cloud et tâches en arrière-plan
13. L’application Codex Desktop
14. GitHub Action et CI/CD
15. Codex SDK
16. Combien coûte Codex ?
17. Optimisation des performances
18. Comment déboguer les problèmes ?
19. Déploiement en entreprise
20. Astuces et techniques de la communauté
21. Guide de migration
22. Carte de référence rapide
23. Journal des modifications
24. Références

Comment installer Codex ?

Gestionnaires de paquets

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

# Homebrew (macOS)
brew install --cask codex

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

Téléchargements de binaires

Pour les environnements sans npm ni Homebrew, téléchargez les binaires spécifiques à votre plateforme depuis les GitHub Releases¹ :

Configuration requise

• macOS : Apple Silicon ou Intel (prise en charge complète du sandbox via Seatbelt)
• Linux : x86_64 ou arm64 (sandbox via Landlock + seccomp)
• Windows : Expérimental (WSL recommandé pour une prise en charge complète du sandbox)²

Authentification

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

Deux chemins d’authentification :

1. Compte ChatGPT (recommandé) : Connectez-vous avec votre abonnement Plus, Pro, Team, Business, Edu ou Enterprise existant. Accès complet à toutes les fonctionnalités, y compris les tâches cloud.
2. Clé API : Configurez-la via la variable d’environnement CODEX_API_KEY ou codex login --with-api-key. Certaines fonctionnalités (cloud threads) peuvent ne pas être disponibles.

Astuce avancée : Le stockage des identifiants est configurable via cli_auth_credentials_store dans config.toml. Options : file (par défaut), keyring (trousseau du système d’exploitation), ou auto (keyring si disponible, sinon fichier).

Complétions 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

Vérification de l’installation

codex --version
# Codex CLI v0.101.0

Surfaces d’interaction principales

Codex propose quatre interfaces distinctes soutenues par la même intelligence. Chaque surface est optimisée pour un schéma de flux de travail différent.

1. CLI interactif (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

Le TUI est une application plein écran avec :

• Compositeur : Saisissez des invites, joignez des fichiers avec @, exécutez des commandes shell avec le préfixe !
• Panneau de sortie : Réponses en streaming du modèle, appels d’outils et sortie des commandes
• Barre d’état : Modèle, consommation de tokens, branche git, mode sandbox

Raccourcis clés du TUI :

Slash commands disponibles dans le TUI :

2. Application Codex Desktop (macOS)

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

L’application de bureau ajoute des fonctionnalités que le CLI n’offre pas :

• Multi-tâches : Exécutez plusieurs agents en parallèle sur différents projets simultanément
• Isolation par worktrees git : Chaque fil de discussion travaille sur une copie isolée de votre dépôt
• Revue de diff intégrée : Indexez, annulez et validez les modifications sans quitter l’application
• Terminal intégré : Un terminal par fil de discussion pour exécuter des commandes
• Duplication de conversation : Créez des branches de conversation pour explorer des alternatives
• Fenêtres flottantes détachables : Détachez les conversations dans des fenêtres portables
• Automatisations : Planifiez des tâches récurrentes (tri des issues, surveillance CI, réponse aux alertes)

Quand utiliser l’application vs le CLI : Utilisez l’application de bureau lorsque vous coordonnez plusieurs flux de travail ou que vous avez besoin d’une revue visuelle des diffs. Utilisez le CLI lorsque vous souhaitez la composabilité du terminal, le scripting ou l’intégration CI/CD.

3. Extension IDE (VS Code, Cursor, Windsurf)

L’extension IDE de Codex s’intègre directement dans votre éditeur :

• Mode agent par défaut : Lit les fichiers, effectue des modifications, exécute des commandes
• Modifications en ligne : Suggestions contextuelles dans vos fichiers actifs
• Sessions partagées : Les sessions se synchronisent entre le CLI et l’extension IDE
• Même authentification : Connectez-vous avec votre compte ChatGPT ou votre clé API

Installez depuis le VS Code Marketplace ou les magasins d’extensions Cursor/Windsurf.³

4. Codex Cloud [EXPÉRIMENTAL]

Les tâches Cloud s’exécutent de manière asynchrone dans des environnements gérés par OpenAI :

• Lancer et oublier : Mettez en file d’attente des tâches qui s’exécutent indépendamment de votre machine locale
• Exécution parallèle : Exécutez plusieurs tâches cloud simultanément
• Création de PR : Codex crée des pull requests à partir du travail terminé
• Application locale : Récupérez les résultats cloud dans votre dépôt local avec codex apply <TASK_ID>

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

Les tâches cloud sont également accessibles depuis chatgpt.com/codex.⁴

Exploration approfondie du système de configuration

Codex utilise TOML pour la configuration. Comprendre la hiérarchie de précédence est essentiel : elle détermine quels paramètres l’emportent en cas de conflit.

Précédence (de la plus haute à la plus basse)

1. Substitutions de session (la plus haute) : flags CLI (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) et substitutions -c key=value
2. Configuration projet (.codex/config.toml, découverte depuis le répertoire courant en remontant vers la racine du projet — le répertoire le plus proche l’emporte)
3. Configuration utilisateur ($CODEX_HOME/config.toml, par défaut ~/.codex/config.toml)
4. Configuration système (/etc/codex/config.toml sous Unix)
5. Valeurs par défaut intégrées (la plus basse)

La configuration administrateur gérée agit comme une couche de contraintes de politique et peut imposer ou interdire des valeurs après la fusion normale. Voir Déploiement en entreprise.

Emplacements des fichiers de configuration

Astuce avancée : la variable d’environnement CODEX_HOME remplace le répertoire par défaut ~/.codex. Utile pour les environnements CI/CD ou les configurations multi-comptes.

Référence complète de la configuration

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

Profils

Préréglages de configuration nommés pour différents modes de travail :

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

Activer un profil :

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

Astuce avancée : définissez un profil par défaut avec profile = "fast" au niveau supérieur de votre configuration. Remplacez-le par session avec --profile.

Fournisseurs de modèles personnalisés

Connexion à Azure, aux modèles locaux ou aux services 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"

Utilisez les modèles locaux avec le 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 définissez-le dans la configuration :

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

Substitutions de configuration en ligne

Remplacez n’importe quelle valeur de configuration depuis la ligne de commande :

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"

Quel modèle choisir ?

Modèles disponibles (février 2026)

La liste exacte des modèles varie selon le compte et le déploiement. Consultez votre cache local : ~/.codex/models_cache.json.

Diagramme de sélection du modèle

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

Effort de raisonnement

Contrôlez l’intensité de « réflexion » du modèle avant de répondre :

Les niveaux pris en charge dépendent du modèle. Tous les modèles ne prennent pas en charge tous les niveaux.

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

Astuce avancée : le raisonnement xhigh peut consommer 3 à 5 fois plus de tokens que medium pour le même prompt. Réservez-le aux problèmes véritablement difficiles où la réflexion supplémentaire en vaut la peine.

Changement de modèle

Changez de modèle en cours de session avec la slash command /model, ou définissez-le par exécution via --model / -m :

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

Cadres de décision

Quand utiliser chaque interface

Quand utiliser chaque mode sandbox

Quand utiliser chaque niveau de raisonnement

Comment fonctionne le système de Sandbox et d’approbation ?

Codex utilise un modèle de sécurité à deux couches qui sépare ce qui est techniquement possible de quand une approbation humaine est requise. Ce système est fondamentalement différent du système de permissions de Claude Code — Codex applique les restrictions au niveau du noyau du système d’exploitation.⁵

Couche 1 : Sandbox (ce qui est possible)

Le sandbox contrôle l’accès au système de fichiers et au réseau en utilisant des mécanismes natifs du système d’exploitation :

Application spécifique par plateforme :

• macOS : Le framework Seatbelt d’Apple via sandbox-exec avec des profils spécifiques au mode compilés à l’exécution et appliqués par le noyau⁶
• Linux : Landlock pour les restrictions du système de fichiers + seccomp pour le filtrage des appels système. Un processus auxiliaire autonome (codex-linux-sandbox) fournit une isolation en profondeur. Un pipeline Bubblewrap (bwrap) optionnel est disponible comme alternative⁷
• Windows : Sandbox natif expérimental avec des jetons restreints. WSL recommandé pour une prise en charge complète du sandbox (hérite de Landlock + seccomp de Linux)

Pourquoi c’est important : Contrairement au sandboxing basé sur les conteneurs (Docker), le sandboxing au niveau du système d’exploitation est plus rapide, plus léger et plus difficile à contourner. Le noyau applique les restrictions avant même que Codex ne voie l’appel système.

Couche 2 : Politique d’approbation (quand demander)

La politique d’approbation détermine quand Codex s’arrête pour demander une confirmation humaine :

Le flag --full-auto

--full-auto est un alias pratique pour :

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

Piège important : --full-auto remplace toute valeur explicite de --sandbox. Si vous passez --full-auto --sandbox read-only, vous obtiendrez workspace-write car --full-auto a la priorité.⁸

Configurations recommandées

Développement quotidien (valeur par défaut sûre) :

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

Utilisateur avancé (accès complet, humain dans la boucle) :

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

C’est la configuration recommandée par la communauté comme « point idéal » — capacité maximale mais approbation requise pour chaque commande.⁹

Automatisation CI/CD :

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

Activer l’accès réseau

Le réseau est bloqué par défaut en mode workspace-write. Activez-le lorsque nécessaire :

# Par exécution
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

Tester le sandbox

Vérifiez le comportement du sandbox avant de vous y fier :

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

Comment fonctionne AGENTS.md ?

AGENTS.md est le système d’instructions de projet de Codex — un standard ouvert¹⁰ pris en charge par Codex, Cursor, Amp, Jules (Google) et Factory. Il définit comment Codex doit se comporter au sein d’un dépôt ou d’un répertoire spécifique.

Hiérarchie de découverte

Codex construit une chaîne d’instructions au démarrage de la session en parcourant l’arborescence des répertoires :

1. Global (~/.codex/) : AGENTS.override.md > AGENTS.md
2. Projet (racine git jusqu’au répertoire courant) : Chaque niveau est vérifié pour AGENTS.override.md > AGENTS.md > noms de fichiers de repli
3. Fusion : Les fichiers sont concaténés de la racine vers le bas ; les fichiers les plus proches apparaissent plus tard dans le prompt et remplacent les instructions précédentes

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

Ce qui fait un bon AGENTS.md

Basé sur les recommandations directes de Codex et les pratiques de la communauté¹¹ :

À FAIRE : - Soyez spécifique : "Use rg --files for discovery" est mieux que "search efficiently" - Définissez la clôture : Que signifie « terminé » ? (tests réussis, lint propre, etc.) - Incluez les commandes : Build, test, lint, format — les invocations exactes - Organisez par tâche : Sections codage, revue, release, incident/débogage - Définissez l’escalade : Que faire en cas de blocage ou d’état inattendu

À NE PAS FAIRE : - Copier des guides de style entiers sans règles d’exécution - Utiliser des directives ambiguës (« soyez prudent », « optimisez ») - Mélanger des priorités contradictoires (rapidité + vérification exhaustive + pas de budget d’exécution) - Rédiger de la documentation en prose — AGENTS.md est une politique opérationnelle, pas un README

Exemple : AGENTS.md de production

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

Le mécanisme de remplacement

AGENTS.override.md à n’importe quel niveau de répertoire remplace le fichier AGENTS.md normal pour cette portée. À utiliser pour :

• Gels de release : « Pas de nouvelles fonctionnalités, corrections uniquement »
• Mode incident : « Toutes les modifications doivent être revues par l’astreinte »
• Durcissement temporaire : « Pas de mises à jour de dépendances ce sprint »

Configuration

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

Génération de squelette

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

Ou vérifiez votre chaîne d’instructions :

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

Qu’est-ce que MCP (Model Context Protocol) ? [experimental]

MCP étend les capacités de Codex en le connectant à des outils et services externes. Le groupe de commandes codex mcp est actuellement marqué comme expérimental — les commandes et le format de configuration peuvent changer entre les versions. Codex prend en charge deux types de transport : STDIO (processus locaux) et Streamable HTTP (serveurs distants).¹²

Configurer les serveurs MCP

Serveurs STDIO (processus locaux) :

# 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

Serveurs HTTP (distants) :

[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

Gestion 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

En session : /mcp affiche les serveurs actifs et les outils disponibles.

Exécuter Codex EN TANT QUE serveur MCP

Codex peut s’exposer en tant que serveur MCP pour l’orchestration multi-agents :¹³

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

Cela expose deux outils : 1. codex() : Démarrer une nouvelle session avec les paramètres de prompt, sandbox, modèle et approbation 2. codex-reply() : Continuer une session existante avec threadId et un prompt

Utilisation avec le 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")

Serveurs MCP notables

Que sont les skills ?

Les skills sont des paquets de capacités réutilisables et spécifiques à une tâche que Codex charge à la demande. Ils suivent le standard ouvert des agent skills.¹⁴

Structure d’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)

Emplacements de découverte

Les skills installés par l’utilisateur sont gérés dans $CODEX_HOME/skills (par défaut : ~/.codex/skills), y compris les skills système intégrés sous .system/. Codex prend en charge les dossiers de skills liés par des liens symboliques.

Créer un skill

Format de SKILL.md :

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

## Procédure d'audit de sécurité

1. Rechercher les secrets codés en dur avec `rg -i "(api_key|password|secret|token)\s*=" --type py`
2. Vérifier les injections SQL : rechercher l'interpolation de chaînes dans les requêtes
3. Vérifier la validation des entrées sur tous les endpoints API
4. Vérifier les vulnérabilités des dépendances : `pip audit` ou `npm audit`
5. Examiner les patterns d'authentification et d'autorisation
6. Rapporter les résultats avec des niveaux de gravité (Critical/High/Medium/Low)

Métadonnées (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"

Invoquer des skills

• Explicite : menu /skills ou mention $skill-name dans le prompt
• Implicite : Codex détecte automatiquement les skills correspondants à partir de la description de la tâche (si allow_implicit_invocation: true)
• Créateur : utilisez $skill-creator pour construire interactivement un nouveau skill
• Installateur : utilisez $skill-installer install <name> pour installer des skills communautaires

Activer/Désactiver

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

Plan Mode et collaboration

Plan mode permet à Codex de concevoir une approche avant d’exécuter des modifications. Il est activé par défaut (depuis la v0.94.0).¹⁵

Entrer en Plan Mode

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

En plan mode, Codex : - Lit les fichiers et analyse le codebase - Propose un plan d’implémentation - Ne fait aucune modification tant que vous n’avez pas approuvé - Affiche le plan en continu dans une vue TUI dédiée

Steer Mode

Steer mode (activé par défaut depuis la v0.98.0) vous permet d’injecter de nouvelles instructions pendant que Codex travaille :

• Entrée : envoie les instructions immédiatement pendant un tour en cours
• Tab : met en file d’attente un suivi pour après la fin du tour en cours

Cela permet une correction de trajectoire en temps réel sans arrêter l’agent.

Bifurcation de conversation

Bifurquez les conversations pour explorer des alternatives sans perdre votre progression actuelle :

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

Les bifurcations créent des fils indépendants — les modifications dans une bifurcation n’affectent pas l’autre.

Mode non interactif (codex exec)

codex exec exécute Codex de manière non interactive pour le scripting, le CI/CD et l’automatisation.¹⁶

Utilisation de base

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

Par défaut, codex exec écrit la progression et les événements sur stderr et le message final de l’agent sur stdout. Cela le rend composable avec les pipelines Unix standard.

Sortie JSON Lines

Avec --json, stdout devient un flux d’événements JSONL :

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

Types d’événements : 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}}

Sortie structurée

Imposez la forme de la réponse avec un JSON Schema :

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

-o / --output-last-message écrit le message final dans un fichier.

Reprise et revue de session

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 principaux

Authentification CI

codex exec prend en charge CODEX_API_KEY pour l’authentification non interactive dans les environnements d’automatisation.

Codex Cloud et tâches en arrière-plan [EXPERIMENTAL]

Statut : Codex Cloud est une fonctionnalité expérimentale. Les interfaces, la tarification et la disponibilité peuvent changer. Les environnements cloud sont gérés par OpenAI — vous ne contrôlez pas l’infrastructure.

Codex Cloud exécute des tâches de manière asynchrone dans des environnements gérés par OpenAI.⁴

Fonctionnement

1. Soumettez une tâche (via chatgpt.com/codex, l’intégration Slack ou le CLI)
2. Codex clone votre dépôt dans un sandbox cloud isolé
3. L’agent travaille de manière indépendante — lit le code, exécute les tests, effectue des modifications
4. Une fois terminé, Codex crée une PR ou fournit un diff pour revue
5. Appliquez les résultats localement avec codex apply <TASK_ID>

Accès Internet dans le cloud

L’accès Internet de l’agent est désactivé par défaut et configuré par environnement :

• Désactivé : aucun accès Internet pour l’agent (par défaut)
• Activé : liste de domaines autorisés facultative + restrictions de méthodes HTTP

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

Les scripts d’installation peuvent toujours utiliser Internet pour installer les dépendances, même lorsque l’accès Internet de l’agent est désactivé.

Intégration Slack

Mentionnez @Codex dans un canal ou fil Slack pour lancer une tâche cloud.

Prérequis : 1. Plan ChatGPT éligible (Plus, Pro, Business, Enterprise ou Edu) 2. Compte GitHub connecté 3. Au moins un environnement cloud configuré 4. Application Slack installée pour votre espace de travail

Codex répond avec un lien vers la tâche et publie les résultats une fois terminé.

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

L’application Codex Desktop App

L’application Codex Desktop App (macOS uniquement, Apple Silicon) fournit une interface graphique optimisée pour la gestion multi-projets.¹⁷

Installation

codex app                      # Auto-downloads and installs on first run

Ou téléchargez directement : Codex.dmg

Fonctionnalités clés

Automatisations

Les automatisations s’exécutent localement dans l’application — l’application doit être en cours d’exécution et le projet disponible sur le disque :

• Dans les dépôts Git, les automatisations utilisent des worktrees dédiés en arrière-plan
• Dans les projets non-Git, les exécutions se font directement dans le répertoire du projet
• Les automatisations utilisent vos paramètres de sandbox par défaut

Exemples de cas d’usage : - Triage des issues : catégoriser et prioriser automatiquement les nouvelles issues - Surveillance CI : surveiller les échecs de build et suggérer des correctifs - Réponse aux alertes : réagir aux alertes de monitoring avec une analyse diagnostique - Mises à jour des dépendances : vérifier et appliquer les correctifs de sécurité

Les résultats apparaissent dans une file d’attente de revue pour approbation humaine.

Support Windows

Les tests alpha pour Windows ont débuté en février 2026. Inscrivez-vous sur openai.com pour un accès anticipé.¹⁸

GitHub Action et CI/CD

La GitHub Action officielle intègre Codex dans votre pipeline CI/CD.¹⁹

Utilisation de base

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

Options de configuration

Sortie : final-message — texte de la réponse finale de Codex pour les étapes/jobs en aval.

Stratégies de sécurité

Contrôles d’accès

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

Par défaut : seuls les collaborateurs avec un accès en écriture peuvent déclencher les workflows Codex.

Codex SDK

Le SDK TypeScript intègre les capacités d’agent de Codex dans des applications personnalisées.²⁰

Installation

npm install @openai/codex-sdk

Utilisation de base

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

Fonctionnalités avancées du SDK

• runStreamed(...) : Flux d’événements asynchrone pour les mises à jour intermédiaires
• outputSchema : Impose une sortie finale au format JSON structuré
• Entrée multimodale : Transmettez du texte et des images locales ({ type: "local_image", path: "..." })

Configuration du thread et du client

// 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" },
});

Les sessions sont conservées dans ~/.codex/sessions.

Environnement d’exécution : Node.js 18+.

Combien coûte Codex ?

Accès via les forfaits ChatGPT

La disponibilité de Codex dépend de votre forfait ChatGPT et des paramètres de votre organisation :

Les limites et le débit des forfaits sont susceptibles de changer. Vérifiez vos droits actuels dans ChatGPT et dans vos paramètres d’administration.

Facturation API

Lorsque vous utilisez Codex via l’API, la consommation est facturée par token selon la tarification standard de l’API OpenAI pour le modèle sélectionné (plus les éventuelles réductions de mise en cache des prompts). Consultez la page officielle de tarification de l’API pour les tarifs en vigueur.

Stratégies d’optimisation des coûts

1. Utilisez les profils : Créez un profil fast avec gpt-5.1-codex-mini et model_reasoning_effort = "low" pour les tâches courantes
2. Réservez le raisonnement élevé : N’utilisez xhigh que pour les problèmes réellement complexes — cela consomme 3 à 5 fois plus de tokens
3. Utilisez --ephemeral : Ignorez la persistance de session en CI/CD pour réduire la surcharge
4. Minimisez les résumés de raisonnement : Définissez model_reasoning_summary = "none" lorsque vous n’avez pas besoin d’explications
5. Utilisez le mode exec pour les traitements par lots : codex exec évite la surcharge du TUI pour les flux d’automatisation
6. Surveillez votre consommation : Vérifiez /status dans le TUI et les tableaux de bord de facturation de votre organisation

Optimisation des performances

Gestion du contexte

Les modèles phares disposent de fenêtres de contexte de 272K tokens, mais elles se remplissent plus vite qu’on ne le pense. Gérez-les de manière proactive :

1. Utilisez /compact régulièrement : Résume l’historique de conversation pour libérer des tokens
2. Fournissez de la documentation locale : Un fichier AGENTS.md de qualité et une documentation locale réduisent la surcharge d’exploration (qui consomme du contexte)
3. Utilisez @ pour joindre des fichiers spécifiques : Référencez directement les fichiers au lieu de demander à Codex de les trouver
4. Gardez vos prompts ciblés : Des prompts précis avec les fichiers exacts consomment moins de contexte qu’une exploration ouverte

Efficacité en tokens

Optimisation de la vitesse

1. gpt-5.3-codex-spark : Variante à latence réduite pour le pair programming interactif
2. --profile fast : Modèle mini préconfiguré avec raisonnement bas
3. Exécution parallèle des outils : Codex exécute les lectures/vérifications indépendantes simultanément — structurez vos prompts pour le permettre
4. Boucles orientées résultat : Demandez « implémenter, tester, corriger, s’arrêter quand tout est vert » au lieu d’instructions étape par étape

Comment déboguer les problèmes ?

Problèmes courants et solutions

Outils de diagnostic

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

Diagnostics du TUI en cours de session :

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

Remarque : codex --verbose n’est pas un flag de premier niveau valide. Utilisez les sous-commandes de débogage et les diagnostics du TUI ci-dessus.

Réinstallation propre

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

Mode débogage

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

Signaler des problèmes

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

Ou créez un ticket sur github.com/openai/codex/issues.¹

Déploiement en entreprise

Contrôles administrateur (Managed Admin Config)

La politique d’entreprise est appliquée via la managed admin config (au niveau système), qui peut imposer des modes d’exécution sécurisés et contraindre les paramètres utilisateur :²²

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

La managed admin config agit comme une couche de contrainte — elle impose ou interdit des valeurs après la fusion normale de la configuration, et non comme un simple niveau de remplacement supplémentaire.

Configuration MDM pour macOS

Distribution via MDM en utilisant le domaine de préférences com.openai.codex :

Intégration OpenTelemetry

Codex prend en charge la propagation du contexte de trace OpenTelemetry depuis les variables d’environnement OTel standard jusqu’aux appels API OpenAI. Configurez OTel dans votre pile d’exécution/collecteur :

• Les variables d’environnement OTEL_* standard sont prises en compte
• Le contexte de trace se propage à travers Codex jusqu’aux appels API
• Tenez compte des exigences de confidentialité lors de l’activation de la journalisation des prompts/outils

Accès entreprise

• ChatGPT Business / Enterprise / Edu : Accès contrôlé par l’administrateur de l’organisation
• API : Authentification API standard, facturation et contrôles organisation/projet
• Codex SDK : Intégration dans les outils et flux de travail internes
• Configuration gérée : Utilisez la managed config et la managed admin config pour l’application des politiques à grande échelle

Astuces et techniques de la communauté

Modèles de prompts

1. Prompts orientés contraintes : Commencez par les limites — « NE PAS modifier les contrats d’API. Ne refactoriser que l’implémentation interne. »
2. Étapes de reproduction structurées : Des étapes numérotées produisent de meilleures corrections de bugs que des descriptions vagues
3. Demandes de vérification : Terminez par « Exécuter le lint + la plus petite suite de tests pertinente. Rapporter les commandes et résultats. »
4. Références de fichiers : Utilisez @nom_fichier pour joindre des fichiers spécifiques au contexte
5. Boucles orientées résultat : « Implémenter, exécuter les tests, corriger les échecs, s’arrêter uniquement quand tous les tests passent » — Codex itère jusqu’à la fin

Philosophie de test

La communauté converge vers une collaboration IA pilotée par les tests :²³

• Définissez les tests en amont comme signaux de complétion
• Laissez Codex itérer jusqu’à ce que les tests passent (rouge → vert → refactoring)
• Adoptez les modèles de programmation Tiger Style
• Fournissez le texte exact du fichier lors des demandes de patch — Codex utilise une correspondance stricte, pas un patching flou basé sur l’AST

Bonnes pratiques de gestion du contexte

• Fournissez de la documentation locale de qualité plutôt que de vous appuyer sur la recherche web
• Maintenez du markdown structuré avec des tables des matières et des fichiers de progression (« divulgation progressive »)
• Normalisez les fins de ligne (LF vs CRLF) dans les fichiers suivis pour éviter les échecs de patch
• Gardez AGENTS.md concis — les instructions longues sont repoussées hors du contexte

Flux de travail Git

• Créez toujours une nouvelle branche avant d’exécuter Codex sur des dépôts inconnus
• Utilisez des flux de travail basés sur les patchs (git diff / git apply) plutôt que des modifications directes
• Révisez les suggestions de Codex comme des revues de code de PR
• Utilisez /diff pour vérifier les modifications avant de commiter

Skills et prompts de la communauté

Le dépôt feiskyer/codex-settings fournit des configurations éprouvées :²⁴

Prompts réutilisables (dans ~/.codex/prompts/) : - deep-reflector : Extraire les apprentissages des sessions de développement - github-issue-fixer [issue-number] : Analyse systématique de bugs et création de PR - github-pr-reviewer [pr-number] : Flux de travail de revue de code - ui-engineer [requirements] : Développement frontend de qualité production

Skills communautaires : - claude-skill : Déléguer des tâches à Claude Code avec des modes de permission - autonomous-skill : Automatisation de tâches multi-sessions avec suivi de progression - deep-research : Orchestration parallèle de sous-tâches - kiro-skill : Pipeline exigences → conception → tâches → exécution

Guide de migration

Depuis Claude Code

Différences clés à comprendre :

• Le sandbox est au niveau OS : Codex utilise Seatbelt/Landlock, pas des conteneurs. Les restrictions sont plus difficiles à contourner.
• Pas de hooks : Codex n’a pas d’équivalent direct 1:1 aux hooks de Claude Code. Utilisez les instructions AGENTS.md ou les skills à la place.
• Pas de subagents : Codex n’a pas de modèle local de subagents direct 1:1. Utilisez les tâches cloud ou l’orchestration SDK pour la délégation.
• AGENTS.md est multi-outils : Votre AGENTS.md fonctionne aussi dans Cursor, Amp et Jules. CLAUDE.md est exclusif à Claude.
• Les profils remplacent la configuration manuelle : Au lieu de changer les flags à chaque exécution, définissez des profils dans config.toml.

Depuis GitHub Copilot

Ce que vous gagnez : - Capacité agentique complète (édition de fichiers, exécution de commandes, opérations git) - Délégation de tâches cloud - Sandboxing au niveau OS - Intégrations MCP

Depuis Cursor

Carte de référence rapide

╔═══════════════════════════════════════════════════════════════╗
║                    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)    ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Journal des modifications

Références