Codex CLI : la référence technique définitive

TL;DR : Codex est un agent de codage multi-surface qui lit votre codebase, exécute des commandes dans un sandbox au niveau de l’OS, applique des patchs aux fichiers et délègue des tâches au cloud. Maîtrisez cinq systèmes clés (config.toml, modèle sandbox/approval, AGENTS.md, MCP et skills) et Codex devient un multiplicateur de force. Utilisez les profils pour changer de contexte, /compact pour gérer le budget de contexte, /goal pour conserver des objectifs de travail persistants, et AGENTS.md pour des instructions de projet transversales qui fonctionnent dans Codex, Cursor, Amp et d’autres outils. GPT-5.5 (lancé le 23 avril 2026) est le choix par défaut recommandé dans Codex — fenêtre de contexte de 400K dans Codex (1M dans le API), 5 $/30 $ par MTok, 82,7 % sur Terminal-Bench 2.0 SOTA.⁸³ Depuis CLI v0.140.0 (stable, 15 juin 2026), /usage affiche l’activité quotidienne/hebdomadaire/cumulative des tokens du compte, les sessions peuvent être supprimées définitivement via codex delete / /delete (avec des confirmations de sécurité), /import migre sélectivement la configuration, la configuration de projet et les conversations récentes depuis Claude Code, taper @ ouvre par défaut un menu de mentions unifié pour les fichiers, plugins et skills, et l’authentification gérée par clé API Amazon Bedrock arrive avec le stockage local chiffré des identifiants OAuth CLI et MCP ; les contrôles vocaux expérimentaux /realtime ont été retirés du TUI.¹⁰² Depuis CLI v0.139.0 (stable, 9 juin 2026), le mode code peut appeler directement la recherche web autonome (y compris depuis des appels d’outils JavaScript imbriqués) et recevoir des résultats en texte brut, les schémas d’entrée des outils/connecteurs préservent désormais les constructions oneOf/allOf pour une meilleure compatibilité avec les grands schémas et MCP, codex doctor ajoute des détails sur l’environnement de l’éditeur et du pager (en expurgeant les valeurs sensibles dans JSON), et la marketplace de plugins expose les sources dans codex plugin marketplace list --json avec un listing plus rapide grâce au catalogue mis en cache.¹⁰⁵ v0.138.0 (8 juin) a ajouté /app pour transférer une session CLI vers l’application de bureau sur macOS et Windows, exposé les chemins d’images locales au modèle, rendu la sélection de l’effort de raisonnement plus flexible et fourni une sortie JSON structurée à l’automatisation des plugins.¹⁰⁶ v0.137.0 (4 juin) a livré multi-agent v2 (runtime conservé par thread, suivis et métadonnées par défaut plus propres, hide_spawn_agent_metadata à true par défaut), les raccourcis clavier TUI F13–F24 et une extension skills v1 avec résolution du catalogue à chaque tour.¹⁰⁷ Depuis CLI v0.135.0 (28 mai 2026), codex doctor fournit un inventaire plus riche de l’environnement, de Git, du terminal, de l’app-server et des threads ; /status affiche les détails de connexion distante et la version du serveur lorsque le TUI est connecté à distance ; le mode vim a gagné l’édition par text-object, un meilleur comportement sur les mots/fins de ligne et une interruption de tour configurable ; /permissions comprend désormais les profils d’autorisation nommés et affiche les profils personnalisés ; les builds packagés de Codex découvrent et utilisent l’assistant zsh patché inclus sur les macOS pris en charge ; et le SDK Python expose des préréglages Sandbox lisibles pour les APIs de thread et de tour.¹⁰⁹ v0.134.0 (26 mai 2026) a introduit la recherche dans l’historique local des conversations avec correspondances de contenu insensibles à la casse et aperçus des résultats, fait de --profile le sélecteur principal de profil dans CLI, les permissions TUI et les flux sandbox (les anciennes configurations de profils étant rejetées avec des indications de migration), amélioré la configuration MCP avec un ciblage d’environnement par serveur et des options OAuth pour les serveurs HTTP streamables, rendu les schémas d’outils de connecteurs plus fiables en préservant les $ref/$defs locaux et en compactant les schémas trop volumineux, permis aux outils MCP en lecture seule de s’exécuter simultanément lorsqu’ils annoncent readOnlyHint, et ajouté un contexte plus riche pour les extensions et hooks, y compris l’historique de conversation pour les outils d’extension.¹⁰¹ v0.133.0 (21 mai 2026) a activé les objectifs par défaut avec un stockage dédié et un suivi de progression ; codex remote-control a reçu l’état de préparation/statut au premier plan ainsi qu’un démarrage/arrêt façon daemon ; les profils d’autorisation ont gagné des APIs de liste, l’héritage, requirements.toml géré, l’actualisation au runtime et une intégration plus solide au sandbox Windows ; la découverte des plugins affiche les versions installées, les racines de marketplace et les collections distantes ; et les extensions peuvent observer le démarrage/arrêt des subagents, l’exécution des outils, les métadonnées de tour et le traitement asynchrone des approbations/tours. La mise à jour du 21 mai de l’application Codex a ajouté Appshots pour les fenêtres Mac au premier plan, Goal mode en disponibilité générale dans l’application/l’IDE/CLI, des améliorations des annotations dans le navigateur intégré et Computer Use verrouillé en opt-in pour les utilisateurs Mac éligibles.⁹⁹¹⁰⁰ v0.132.0 (20 mai 2026) a ajouté l’auth SDK Python de première classe, des APIs de tour plus simples en texte seul, un TurnResult plus riche, codex exec resume --output-schema, un démarrage TUI plus rapide, l’enregistrement d’exécuteur distant adossé à l’auth et la préservation de la fidélité des images dans les tours app-server. Continuez à privilégier les flags explicites de sandbox/approval ou les profils d’autorisation plutôt que l’ancien --full-auto ; js_repl reste supprimé.^{86878991969798}

Codex fonctionne comme un agent de codage multi-surface, pas comme un chatbot qui écrit du code. Le CLI lit votre codebase, exécute des commandes dans un sandbox, applique des patchs aux fichiers, se connecte à des services externes via MCP et délègue les tâches longues au cloud. Il s’exécute localement mais raisonne globalement ; la même intelligence alimente cinq surfaces distinctes selon votre façon de travailler, y compris la nouvelle extension Chrome qui exécute Codex dans votre navigateur sans en prendre le contrôle.⁹⁰

La différence entre une utilisation occasionnelle et une utilisation efficace de Codex tient à cinq systèmes clés. Maîtrisez-les et Codex devient un multiplicateur de force :

1. Système de configuration : contrôle le comportement via config.toml
2. Modèle sandbox et approval : encadre ce que Codex peut faire
3. AGENTS.md : définit les contrats d’exploitation au niveau du projet
4. Protocole MCP : étend les capacités vers des services externes
5. Système de skills : empaquette 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 dans la référence complète que j’aurais aimé avoir au départ. 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] ou under development peuvent changer d’une version à l’autre. Depuis v0.133.0 (21 mai 2026), les objectifs sont activés par défaut, les profils d’autorisation sont une surface gérée de première classe, la découverte des plugins est plus inspectable, et remote-control est plus simple à exécuter comme commande app-server au premier plan ou daemonisée. Codex Cloud et le mode code restent expérimentaux ou en développement, tandis que le cœur CLI, le sandboxing, AGENTS.md, config.toml, Skills, hooks, les outils multi-agent, plugins, Browser, Computer Use et Appshots sont stables ou documentés comme surfaces utilisateur selon la plateforme et l’offre. v0.132.0 complète l’auth SDK Python et l’automatisation structurée de reprise ; v0.131.0 a ajouté codex doctor, la recherche unifiée de mentions @, les commandes CLI de marketplace, le partage de plugins sensible aux versions, remote-control géré par daemon avec activation/désactivation au runtime, des environnements adossés au registre et un renforcement supplémentaire du sandbox Windows.⁹⁶⁹⁷⁹⁸ L’ancien --full-auto reste déprécié et js_repl reste supprimé.⁸⁶⁸⁷

Points clés

• Cinq surfaces, une même intelligence : CLI, l’application desktop, l’extension IDE, les tâches cloud et la nouvelle extension Chrome partagent toutes la même intelligence GPT-5.x-Codex ; choisissez donc la surface adaptée à votre workflow.⁹⁰
• Sandboxing au niveau de l’OS : Codex applique les restrictions de système de fichiers et de réseau au niveau du noyau (Seatbelt sur macOS, Landlock + seccomp sur Linux), et non dans des conteneurs.
• AGENTS.md fonctionne avec plusieurs outils : vos instructions de projet fonctionnent dans Codex, Cursor, Copilot, Amp, Jules, Gemini CLI, Windsurf, Cline, Aider, Zed et plus de 60 000 projets open source. Rédigez-les une fois, utilisez-les partout.
• Les profils évitent les changements de contexte coûteux : définissez des préréglages de configuration nommés (fast, careful, auto) et passez de l’un à l’autre avec --profile.
• La gestion du contexte compte : GPT-5.5 fournit une fenêtre de contexte de 400K dans Codex et de 1M dans API ; GPT-5.4 mini fournit aussi 400K pour le travail de subagent à latence réduite ; GPT-5.3-Codex fournit 272K en entrée. Utilisez /compact, des prompts ciblés et des références @file pour gérer les budgets de tokens de façon proactive.⁸³

Comment utiliser ce guide

Il s’agit d’une référence de plus de 2 500 lignes : commencez là où correspond votre niveau d’expérience :

La carte de référence rapide à la fin fournit un résumé facile à parcourir de toutes les commandes principales.

Fonctionnement de Codex : le modèle mental

Avant d’entrer dans les fonctionnalités, comprenez comment l’architecture de Codex façonne tout ce que vous faites avec lui. Le système fonctionne sur 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         │    │
│  │   (legacy artifact, read_file, grep_files       │    │
│  │    removed in v0.117.0)                          │    │
│  └─────────────────────────────────────────────────┘    │
│  Shared model across all surfaces; costs tokens          │
└─────────────────────────────────────────────────────────┘

Couche cœur : la famille de modèles GPT-5.x alimente l’ensemble. Au 23 avril 2026, gpt-5.5 est le modèle recommandé lorsqu’il est disponible : contexte de 400K dans Codex (1M dans API), 82,7 % sur Terminal-Bench 2.0 SOTA. gpt-5.4 reste le modèle par défaut de repli pendant le déploiement (contexte de 1M, utilisation native de l’ordinateur).⁸³⁶⁴ Il lit les fichiers, écrit des patches, exécute des commandes shell et raisonne sur votre codebase. Quand le contexte se remplit, Codex compacte la conversation pour libérer de l’espace. Cette couche consomme des tokens.

Couche de sécurité : chaque commande exécutée par Codex passe par un sandbox au niveau de l’OS. Sur macOS, le framework Seatbelt d’Apple applique des restrictions au niveau du noyau. Sur Linux, Landlock + seccomp filtrent l’accès au système de fichiers et aux syscalls. Le sandbox fonctionne au niveau du noyau, et non dans des conteneurs. La politique d’approbation décide ensuite quand demander une confirmation humaine.

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

Couche de surface : CLI pour les utilisateurs avancés du terminal et l’automatisation. Application desktop pour la gestion de projet multi-thread. Extension IDE pour les boucles edit-compile-test. Cloud pour les tâches asynchrones qui s’exécutent indépendamment.

L’idée clé : la plupart des utilisateurs n’utilisent qu’une seule surface. Les utilisateurs avancés utilisent les cinq : Cloud pour les tâches longues, CLI pour les opérations de dépôt déterministes, l’extension IDE pour les boucles de codage serrées, l’application desktop pour la planification et la coordination, et Chrome pour les workflows de navigateur avec session connectée.

Table des matières

1. Comment installer Codex ?
2. Démarrage rapide : votre première session
3. Surfaces d’interaction principales
4. Exploration approfondie du système de configuration
5. Quel modèle choisir ?
6. Combien coûte Codex ?
7. Cadres de décision
8. Comment fonctionne le système de Sandbox et d’approbation ?
9. Comment fonctionne AGENTS.md ?
10. Hooks
11. Qu’est-ce que MCP (Model Context Protocol) ?
12. Code Mode
13. Runtime REPL JavaScript
14. Que sont les Skills ?
15. Plugins
16. Plan Mode et collaboration
17. Système de mémoire
18. Gestion des sessions
19. Mode non interactif (codex exec)
20. Codex Cloud et tâches en arrière-plan
21. L’application Codex Desktop
22. Action GitHub et CI/CD
23. SDK Codex
24. Optimisation des performances
25. Comment déboguer les problèmes ?
26. Déploiement en entreprise
27. Bonnes pratiques et anti-patterns
28. Recettes de workflow
29. Guide de migration
30. Carte de référence rapide
31. Changelog
32. Références

Comment installer Codex ?

Gestionnaires de paquets

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

# Homebrew (macOS)
brew install --cask codex

# winget (Windows)
winget install OpenAI.Codex

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

Script d’installation directe (v0.106.0+)

Pour macOS et Linux, un script d’installation en une ligne est disponible comme asset de release GitHub :⁶⁰

curl -fsSL https://github.com/openai/codex/releases/latest/download/install.sh | sh

Le script détecte automatiquement votre plateforme et votre architecture, télécharge le bon binaire, puis le place dans votre PATH.

Téléchargements binaires

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

Prérequis système

• macOS : Apple Silicon ou Intel (prise en charge complète du sandbox via Seatbelt)
• Linux : x86_64 ou arm64 (sandbox via Landlock + seccomp)
• Windows : sandbox natif avec jetons restreints (promu depuis le statut expérimental en v0.100.0). WSL est également pris en charge²

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 modes d’authentification :

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

Astuce d’expert : 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, avec repli sur 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érifier l’installation

codex --version
# codex-cli 0.133.0

Démarrage rapide : votre première session

Passez de zéro à productif en 5 minutes.

1. Installez et authentifiez-vous :

npm i -g @openai/codex          # Install
codex login                      # Log in with your OpenAI account

2. Accédez à un projet :

cd ~/my-project                  # Any git repo works

3. Lancez Codex :

codex

Vous verrez la TUI interactive. Codex lit automatiquement la structure de votre projet.

4. Posez une question :

> What does this project do? Summarize the architecture.

Codex lit les fichiers clés et explique le codebase. Aucune modification n’est effectuée dans le mode suggest par défaut.

5. Effectuez une modification :

> Add input validation to the login endpoint

Codex propose les modifications sous forme de diff. Relisez-les et approuvez avec y, ou refusez avec n.

6. Utilisez une slash command :

> /plan Refactor the database layer to use connection pooling

Codex crée un plan sans l’exécuter. Relisez le plan, puis approuvez pour lancer l’exécution.

7. Vérifiez votre travail :

> /diff

Consultez toutes les modifications que Codex a effectuées dans la session actuelle.

Et maintenant : - Configurez AGENTS.md avec les instructions du projet (voir Comment fonctionne AGENTS.md ?) - Configurez un profil pour votre workflow (voir Profils) - Essayez codex exec pour l’automatisation non interactive (voir Mode non interactif)

Surfaces d’interaction principales

Codex propose quatre interfaces distinctes, fondées sur la même intelligence. Chaque surface est optimisée pour un modèle de workflow différent.

1. CLI interactive (Terminal UI)

codex                        # Launch TUI
codex "fix the failing tests" # Launch with initial prompt
codex -m gpt-5.5            # Specify model
codex --sandbox workspace-write --ask-for-approval on-request

L’interface terminal est une application plein écran avec :

• Composer : saisissez des prompts, joignez des fichiers avec @, exécutez des commandes shell avec le préfixe !
• Volet de sortie : réponses du modèle en streaming, appels d’outils et sortie de commandes
• Barre d’état : modèle, utilisation des tokens, branche git, mode sandbox

Raccourcis TUI clés :

Changement de ligne d’état (v0.121.0) : l’ancien compteur de fenêtre de contexte dans la ligne d’état a été remplacé par un indicateur de pourcentage de contexte montrant le niveau de remplissage de votre fenêtre de contexte. Si vous avez des scripts ou hooks qui analysent la ligne d’état, vérifiez ce changement de format.⁸² Codex affichera aussi une annonce de mise à jour de CLI lorsqu’une nouvelle version sera disponible.

Slash commands disponibles dans la TUI :

Refonte du sélecteur de workflow (v0.129.0) : Resume et fork sont maintenant plus faciles d’accès depuis un sélecteur repensé, et un nouveau mode raw scrollback vous permet de faire défiler la transcription non rendue lorsque vous devez copier des commandes ou la sortie du modèle mot pour mot. Utile pour trier une longue session de débogage ou transférer la sortie vers un autre outil.⁸⁹

Menu unifié de mentions @ (v0.140.0) : saisir @ dans le composer ouvre désormais par défaut un menu de mentions unique couvrant fichiers, plugins et skills, qui remplace le flux d’attachement limité aux fichiers : une seule touche pour référencer n’importe quelle ressource du projet.¹⁰²

2. Codex Desktop App (macOS + Windows)

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

L’application desktop ajoute des capacités que la CLI n’a pas :

• Multi-tâche : exécuter simultanément plusieurs agents parallèles sur différents projets
• Isolation par Git worktree : chaque fil travaille sur une copie isolée de votre repo
• Revue de diff intégrée : indexer, annuler et commit des changements sans quitter l’application
• Terminal intégré : terminal par fil pour exécuter des commandes
• Duplication de conversation : créer des branches de conversations pour explorer des alternatives
• Fenêtres flottantes détachables : détacher des conversations dans des fenêtres portables
• Automatisations : planifier des tâches récurrentes (triage d’issues, surveillance CI, réponse aux alertes)
• Appshots : joindre la fenêtre de l’application Mac au premier plan à un fil, avec une capture d’écran et le texte disponible
• Commentaires dans le navigateur intégré : prévisualiser des pages locales ou publiques, laisser des commentaires sur des éléments/zones et laisser Codex traiter un retour visuel précis
• Computer Use : laisser Codex piloter des applications Mac autorisées pour un travail GUI limité ; l’utilisation verrouillée est opt-in pour les tours Computer Use sur Mac distant éligibles

Quand utiliser l’application plutôt que la CLI : utilisez l’application desktop lorsque vous coordonnez plusieurs flux de travail ou avez besoin d’une revue visuelle de diff. Utilisez la CLI lorsque vous voulez la composabilité du terminal, du scripting ou une intégration CI/CD.

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

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

• Mode agent par défaut : lit des fichiers, effectue des modifications, exécute des commandes
• Modifications inline : suggestions contextuelles dans vos fichiers actifs
• Sessions partagées : les sessions se synchronisent entre la CLI et l’extension IDE
• Même authentification : connectez-vous avec un compte ChatGPT ou une clé API

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

4. Codex Cloud [EXPERIMENTAL]

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

• Fire and forget : mettre en file d’attente des tâches qui s’exécutent indépendamment de votre machine locale
• Exécution parallèle : exécuter plusieurs tâches cloud simultanément
• Création de PR : Codex crée des pull requests à partir du travail terminé
• Application locale : récupérer les résultats cloud dans votre repo 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.⁴

5. Codex for Chrome [NEW]

Codex est disponible sous forme d’extension de navigateur pour Chrome, ajoutant une cinquième surface aux côtés de la CLI, de l’application desktop, de l’extension IDE et du cloud. L’extension est conçue pour accompagner votre navigation habituelle plutôt que pour la remplacer : Codex travaille en parallèle entre les onglets en arrière-plan, et vous gardez le contrôle des sites auxquels il accède.⁹⁰

• Exécution parallèle dans les onglets : Codex opère dans plusieurs onglets à la fois sans verrouiller l’onglet au premier plan.
• Contrôle par site : vous définissez une liste d’autorisation des sites web avec lesquels Codex peut interagir ; par défaut, aucun accès n’est accordé.
• Navigateur comme établi de travail : l’extension est particulièrement adaptée au travail sur des applications et sites web où la page est la source de vérité — consoles d’administration, dashboards internes, interfaces de gestion de contenu, systèmes de tickets — et ne remplace pas la CLI sur les repos locaux.
• Même intelligence : Codex for Chrome exécute la même intelligence GPT-5.x-Codex que les autres surfaces, donc une configuration AGENTS.md ou skills qui fonctionne dans la CLI transmet les mêmes conventions au travail piloté depuis le navigateur.

Installez-la depuis la documentation de l’extension Codex Chrome.⁹⁰

Exploration approfondie du système de configuration

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

Précédence (de la plus élevée à la plus faible)

1. Remplacements de session (priorité maximale) : flags CLI (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) et remplacements -c key=value
2. Configuration de projet (.codex/config.toml, découverte depuis le CWD en remontant jusqu’à la racine du projet ; le dossier 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 sur Unix)
5. Valeurs par défaut intégrées (priorité minimale)

requirements.toml agit comme une couche de contraintes de stratégie qui limite les valeurs que les utilisateurs peuvent sélectionner après la fusion normale de la configuration. Consultez Déploiement en entreprise.

Emplacements des fichiers de configuration

Astuce d’expert : la variable d’environnement CODEX_HOME remplace le dossier par défaut ~/.codex. Utile pour les configurations CI/CD ou multi-comptes.

Référence complète de configuration

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.5"                      # Recommended model when available
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_context_window = 400000           # Token count available to active model (override)
model_auto_compact_token_limit = 200000 # Threshold triggering automatic history compaction
model_reasoning_effort = "medium"       # minimal|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.5"               # Optional model for /review command
service_tier = "fast"                  # Preferred service tier for new turns
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-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 ─────────────────────────────────
allow_login_shell = false               # Allow login shell semantics (loads .profile/.zprofile)

[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
mcp_oauth_callback_port = 0            # Fixed port for MCP OAuth callback (0 = random)
mcp_oauth_credentials_store = "auto"   # auto|file|keyring

# ─── 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
sqlite_home = ""                        # Override SQLite-backed resumable state location

# ─── 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)
unified_exec = true                     # PTY-backed exec (stable)
shell_snapshot = true                   # Shell env snapshots (stable)
enable_request_compression = true       # zstd request compression where supported (stable)
fast_mode = true                        # Service-tier selection and Fast-tier commands (stable)
goals = true                            # Goal mode; stable and on by default in v0.133.0+
hooks = true                            # Lifecycle hooks (stable)
multi_agent = true                      # Enable multi-agent collaboration tools (stable)
personality = true                      # Personality selection (stable)
plugins = true                          # Plugin system (stable)
plugin_hooks = true                     # Plugin-bundled hooks (stable)
plugin_sharing = true                   # Workspace plugin sharing (stable)
browser_use = true                      # In-app browser automation (stable)
browser_use_external = true             # Chrome extension browser use (stable)
computer_use = true                     # macOS Computer Use (stable, plan/region gated)
in_app_browser = true                   # Shared rendered-page preview (stable)
image_generation = true                 # Image-generation tool (stable)
guardian_approval = true                # Auto-review approval path (stable)
skill_mcp_dependency_install = true     # Prompt/install missing skill MCP deps (stable)
tool_suggest = true                     # Tool/plugin suggestion surface (stable)
workspace_dependencies = true           # Workspace dependency discovery (stable)
memories = true                         # Memories (experimental)
network_proxy = false                   # Sandboxed networking proxy (experimental)
prevent_idle_sleep = true               # Keep machine awake during active turns (experimental)
terminal_resize_reflow = true           # Terminal reflow improvements (experimental)

# Removed or deprecated feature names still appear in `codex features list`
# for migration diagnostics. Do not set removed flags such as
# `collaboration_modes`, `request_rule`, `codex_git_commit`,
# `apply_patch_freeform`, `search_tool`, or `js_repl` in new configs.

# ─── Multi-Agent Roles (v0.102.0+) ───────────────────
[agents]
max_threads = 4                         # Maximum concurrent agent threads

[agents.explorer]
description = "Read-only codebase navigator"
config_file = "~/.codex/profiles/explorer.toml"

# ─── Notifications ────────────────────────────────────
notify = ["terminal-notifier", "-title", "Codex"]  # Command for notifications

# ─── Per-Project Overrides ────────────────────────────
[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.4"
model_reasoning_effort = "xhigh"
approval_policy = "untrusted"
sandbox_mode = "read-only"

[profiles.auto]
model = "gpt-5.4"
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 d’expert : définissez un profil par défaut avec profile = "fast" au niveau supérieur de votre configuration. Remplacez-le pour une session avec --profile.

Fournisseurs de modèles personnalisés

Connectez-vous à Azure, AWS Bedrock, des modèles locaux ou des 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"

# Built-in amazon-bedrock provider (v0.123.0+, first-class in v0.124.0+)
# AWS SigV4 signing + credential-based auth; AWS profile selectable via the
# nested `aws.profile` field (NOT a top-level `aws_profile` key).
# v0.130.0+ also accepts credentials from `aws login` (the AWS console-login
# flow) — Codex resolves the cached console-login session for the chosen
# profile if static keys are absent.
# v0.140.0+ adds managed Amazon Bedrock API-key authentication, and stores
# CLI and MCP OAuth credentials in encrypted local storage.[^184]
[model_providers.amazon-bedrock]
name = "Amazon Bedrock"

[model_providers.amazon-bedrock.aws]
profile = "default"                   # any profile from ~/.aws/credentials
# Region/credential resolution otherwise follows the standard AWS chain;
# v0.130.0 added support for `aws login` console-login profiles in addition
# to static access keys and IAM role assumption.[^168]

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

Avertissement : le API filaire chat/completions (wire_api = "chat") a été déprécié pour les modèles hébergés par OpenAI, OpenAI ayant annoncé sa suppression en février 2026.³⁴ Les fournisseurs locaux (Ollama, LM Studio) peuvent encore accepter ce format. Pour les endpoints OpenAI, utilisez plutôt wire_api = "responses".

Utilisez des 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"

Remplacements de configuration en ligne

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

codex -c model="gpt-5.5" "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 (avril 2026)

GPT-5.5 (23 avril 2026) est le choix recommandé par OpenAI pour la plupart des tâches Codex : codage complexe, utilisation de l’ordinateur, travail intellectuel et workflows de recherche. Disponible dans Codex CLI / web / desktop le 23 avril pour ChatGPT Plus / Pro / Business / Enterprise / Edu / Go ; dans l’API OpenAI le 24 avril. Fenêtre de contexte : 400K dans Codex, 1M dans l’API — Codex plafonne la fenêtre à 400K pour équilibrer débit et coût entre les niveaux d’abonnement ; l’API expose la totalité des 1M. Tarification (API) : 5 $ en entrée / 30 $ en sortie par MTok (2× le tarif de GPT-5.4 ; OpenAI indique une augmentation effective d’environ 20 % après les améliorations d’efficacité des tokens). Benchmarks : 82,7 % sur Terminal-Bench 2.0 (SOTA actuel parmi les modèles publiquement disponibles), 84,9 % sur GDPval (44 professions), 78,7 % sur OSWorld-Verified, 98,0 % sur Tau2-bench Telecom (sans optimisation des prompts). OpenAI a utilisé GPT-5.5 + Codex en interne pour réécrire son infrastructure de service avant le lancement — ce qui a permis un gain de 20 % sur la vitesse de génération de tokens.⁸³

GPT-5.4 reste disponible sur toutes les surfaces Codex (CLI, app, extension IDE, cloud).⁶⁴ La liste exacte des modèles varie selon le compte et le déploiement. Vérifiez votre cache local : ~/.codex/models_cache.json.

Note de dépréciation (11 mars 2026) : les modèles GPT-5.1 ne sont plus disponibles dans ChatGPT. Les conversations existantes se poursuivent automatiquement sur GPT-5.3 Instant, GPT-5.4 Thinking ou GPT-5.4 Pro. GPT-5.1-Codex-Mini reste disponible via API et CLI pour les charges de travail sensibles aux coûts.⁷¹

Note sur le niveau gratuit (5 mai 2026) : GPT-5.5 Instant a été déployé sur le niveau gratuit de ChatGPT le 5 mai 2026. Cela élargit l’audience de la famille GPT-5.5 au-delà des plans payants, bien que l’accès à Codex CLI continue d’exiger un abonnement Plus / Pro / Business / Enterprise / Edu / Go éligible ou une clé API.⁹²

GPT-5.4 mini (17 mars 2026) : variante plus petite et plus rapide de GPT-5.4 avec un contexte de 400K à 0,75 $/4,50 $ par MTok — n’utilise que 30 % du quota GPT-5.4. Idéal pour la délégation à des sous-agents : laissez GPT-5.4 gérer la planification et la coordination pendant que des sous-agents GPT-5.4 mini traitent en parallèle des sous-tâches plus restreintes (recherche dans la base de code, revue de fichiers, traitement de documents).⁷⁶

Logigramme de sélection de 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 (near-instant, Pro only)
   │  └─ No
   │     ├─ Subagent or parallel subtask (search, review, processing)?
   │     │  ├─ Yes → gpt-5.4-mini (30% of GPT-5.4 quota, 2x faster)
   │     │  └─ No
   │     │     ├─ Pure coding task (refactor, migration, feature build)?
   │     │     │  ├─ Yes → gpt-5.3-codex (coding specialist, 272K context)
   │     │     │  └─ No → gpt-5.5 (new flagship: 400K context in Codex / 1M in API, 82.7% Terminal-Bench 2.0 SOTA)
   └─ Still unsure? → gpt-5.5

Effort de raisonnement

Contrôlez à quel point le modèle « réfléchit » avant de répondre :

Les niveaux pris en charge dépendent du modèle. minimal n’est disponible que pour les modèles GPT-5. Tous les modèles ne prennent pas en charge tous les niveaux.

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

Astuce d’expert : 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 est rentable.

Contrôles rapides du raisonnement dans la TUI (v0.124.0+).⁸⁵ Dans une session TUI interactive, Alt+, abaisse le raisonnement d’un cran et Alt+. le relève d’un cran — utile lorsqu’un problème difficile en cours de session justifie une montée temporaire medium → high → xhigh sans /effort ni -c. Lorsque vous acceptez une mise à niveau de modèle en cours de session, le raisonnement est réinitialisé à la valeur par défaut du nouveau modèle plutôt que de conserver le niveau précédent.

Changement de modèle

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

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

Combien coûte Codex ?

Voir aussi Sélection du modèle pour les capacités et Cadres de décision pour choisir le bon modèle selon la tâche.

Accès via les forfaits ChatGPT

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

Mise à jour tarifaire d’avril 2026 : Le tarif annuel Business est passé de 25 $ à 20 $/siège/mois. Les sièges Codex uniquement avec tarification à l’usage sont désormais disponibles pour les espaces de travail Business et Enterprise — pas de frais de siège fixes, facturés sur la consommation de tokens.⁷⁹ Les limites de débit promotionnelles 2x pour les forfaits payants (depuis le lancement de l’application Desktop en février 2026) restent actives.¹⁶

Boost des limites d’usage de mai 2026 (jusqu’au 31 mai 2026) : Codex sur le forfait Plus fonctionne avec une limite de 25× sur 5 heures (contre le boost standard de 20×), et le palier à 100 $/mois est doublé sur la même fenêtre. Profitez de cette période pour pousser des lots de tâches cloud plus longs ou des exécutions d’agents à plus haut débit sans atteindre votre mur habituel des 5 heures.⁸⁹

Coûts en crédits

Les opérations Codex consomment des crédits de l’allocation de votre forfait :

Les forfaits Enterprise et Edu adaptent les crédits à l’allocation contractuelle. Vérifiez /status dans le TUI pour l’usage actuel.

Facturation API

Lorsque vous utilisez Codex via l’API, OpenAI facture l’usage par token selon la tarification standard OpenAI API pour le modèle sélectionné (plus toutes les remises applicables de mise en cache des prompts). Consultez la page officielle de tarification API pour les tarifs actuels.²⁰

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 de routine
2. Réservez le raisonnement élevé : N’utilisez xhigh que pour les problèmes véritablement difficiles, car il coûte 3 à 5x plus de tokens
3. Utilisez --ephemeral : Sautez 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. Regroupez avec le mode exec : codex exec évite la surcharge du TUI pour les workflows d’automatisation
6. Surveillez l’usage : Vérifiez /status dans le TUI et les tableaux de bord de facturation de votre organisation

Exemples de coûts réels

Coûts API représentatifs pour des tâches courantes (gpt-5.3-codex à la tarification standard, raisonnement moyen) :

Les coûts varient selon l’effort de raisonnement, la mise en cache et la longueur de la conversation. Utilisez gpt-5.1-codex-mini pour les tâches de routine afin de réduire les coûts d’environ 40 à 60 %. Les tokens d’entrée mis en cache sont facturés avec une remise.

Surcharge cachée en tokens

Chaque appel d’outil ajoute des tokens au-delà de votre prompt visible :

Conseil d’expert : Surveillez votre usage réel via /status dans le TUI. Le compteur de tokens inclut toute la surcharge, pas seulement vos messages visibles. Si les coûts vous surprennent, vérifiez combien de serveurs MCP sont connectés — chacun ajoute des définitions d’outils à chaque appel API.

Gestion des coûts d’équipe

Stratégies de contrôle des coûts d’équipe : - Définissez requirements.toml pour imposer des limites de modèle et d’effort de raisonnement à l’échelle de l’organisation - Utilisez gpt-5.1-codex-mini pour CI/CD — les pipelines automatisés ont rarement besoin du raisonnement maximal - Budgétisation par profil — définissez des profils ci, review et dev avec des plafonds de coût appropriés - Surveillance via OpenTelemetry — les déploiements Enterprise peuvent exporter la télémétrie d’usage vers les piles d’observabilité existantes

Cadres de décision

Quand utiliser chaque surface

Quand utiliser chaque mode de sandbox

Quand utiliser chaque niveau de raisonnement

Mode Plan vs exécution directe

Will Codex need to change more than 3 files?
│
├── YES → Use Plan Mode (/plan)
│         Codex designs the approach BEFORE making changes.
│         You review and approve the plan.
│         Best for: refactors, new features, migrations
│
└── NO → Is the change well-defined?
         │
         ├── YES → Direct execution
         │         Just describe the task. Codex executes immediately.
         │         Best for: bug fixes, small features, test additions
         │
         └── NO → Use Plan Mode (/plan)
                  Let Codex explore and propose an approach first.
                  Best for: unfamiliar codebases, ambiguous requirements

Mode Steer : Entrée vs Tab

Règle empirique : Entrée = « arrête, écoute ceci maintenant ». Tab = « quand tu as terminé, fais aussi ceci ».

Desktop App vs CLI

How do you prefer to work?
│
├── Terminal-first → Use CLI
│   │
│   ├── Single focused task → codex (interactive TUI)
│   ├── Scripted automation → codex exec (non-interactive)
│   └── Quick one-shot → codex exec "prompt" -o result.txt
│
└── Visual/multi-project → Use Desktop App
    │
    ├── Multiple parallel tasks → Multi-thread with worktree isolation
    ├── Visual diff review → Built-in Git diff viewer
    ├── Scheduled automation → Automations tab
    └── Voice-driven → Ctrl+M for voice dictation

Quel profil ?

Associez votre tâche à un profil préconfiguré :

Configuration de config.toml :

# Default profile
profile = "default"

[profiles.fast]
model = "gpt-5.1-codex-mini"
model_reasoning_effort = "low"

[profiles.careful]
model = "gpt-5.3-codex"
model_reasoning_effort = "xhigh"

[profiles.pair]
model = "gpt-5.3-codex-spark"
model_reasoning_effort = "high"

[profiles.ci]
model = "gpt-5.1-codex-mini"
model_reasoning_effort = "low"
sandbox_mode = "workspace-write"

Changez de profil par session : codex --profile careful

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 Codex demande une approbation humaine. Cette approche diffère fondamentalement du système d’autorisations de Claude Code : Codex applique les restrictions au niveau du noyau de l’OS.⁵ Consultez aussi Déploiement en entreprise pour les contraintes requirements.toml que les administrateurs appliquent à l’échelle de l’organisation.

Couche 1 : Sandbox (ce qui est possible)

Le sandbox contrôle l’accès au système de fichiers et au réseau avec des mécanismes natifs de l’OS :

Application selon la plateforme :

• macOS : framework Seatbelt d’Apple via sandbox-exec, avec des profils propres à chaque mode compilés à l’exécution et appliqués par le noyau⁶. Depuis la v0.121.0, les profils de sandbox macOS peuvent allowlist des sockets Unix spécifiques (par exemple docker.sock, sockets IPC d’éditeur) et la résolution DNS privée n’est plus bloquée par défaut.⁸²
• 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 défense en profondeur.⁵ Bubblewrap (bwrap) est intégré et compilé dans le cadre du build Linux (promu depuis le statut optionnel en v0.100.0)⁷. La v0.117.0 a amélioré la fiabilité du sandbox sur les anciennes distributions avec des configurations de noyau héritées.⁷⁵ La v0.129.0 a renforcé le démarrage du sandbox sous Linux et fait passer Bubblewrap intégré à la version 0.11.2 avec des correctifs de sécurité upstream ; la v0.130.0 a ajouté un durcissement supplémentaire du démarrage.⁸⁹⁹¹
• Windows : sandbox natif avec tokens restreints (promu depuis le statut expérimental en v0.100.0). WSL est aussi pris en charge (hérite de Linux Landlock + seccomp). La v0.117.0 inclut des améliorations du sandbox à tokens restreints pour une meilleure isolation des processus.⁷⁵ La v0.130.0 accorde aux utilisateurs du sandbox l’accès au cache binaire du runtime desktop afin que le sandbox Windows puisse résoudre les binaires de runtime de façon fiable pour les utilisateurs de workspace-sandbox.⁹¹

Pourquoi c’est important : contrairement au sandboxing fondé sur des conteneurs (Docker), le sandboxing au niveau de l’OS 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.

Correctifs de sécurité : - Contournement du sandbox par zsh-fork (v0.106.0) : correction d’une vulnérabilité dans laquelle l’exécution shell via fork zsh pouvait contourner les restrictions du sandbox.⁶⁰ Si vous utilisez une version antérieure, mettez à niveau immédiatement. - Limite de taille d’entrée (v0.106.0) : Codex applique désormais une limite d’entrée d’environ 1 million de caractères afin d’éviter les blocages dus à des payloads excessivement volumineux.⁶⁰ - Profil devcontainer sécurisé (v0.121.0) : un nouveau profil client renforcé pour les devcontainers Docker utilise Bubblewrap pour le sandboxing dans le conteneur. WSL2 est pris en charge ; WSL1 est explicitement rejeté (Bubblewrap est incompatible avec le shim de noyau de WSL1).⁸² - Review Guardian + hooks (v0.121.0) : les hooks sont désactivés pendant les sessions de review Guardian, afin que les hooks pré/post-outil ne puissent pas interférer avec les décisions du subagent Guardian.⁸² Si vous vous appuyez sur des hooks pour la journalisation ou la validation, gardez à l’esprit qu’une review Guardian les ignore : appuyez-vous sur l’observabilité du serveur d’application si vous avez besoin d’une piste d’audit complète. - Système de fichiers /dev sous Linux (v0.105.0) : les commandes sandboxées sous Linux reçoivent désormais un système de fichiers /dev minimal, ce qui améliore la compatibilité avec les outils qui s’attendent à trouver des nœuds de périphérique.⁶¹

Politique ReadOnlyAccess (v0.100.0+) : une forme de politique configurable pour un contrôle granulaire de l’accès en lecture. Utilisez-la pour restreindre les dossiers que Codex peut lire, même en mode workspace-write :

[sandbox_workspace_write]
read_only_access = ["/etc", "/usr/local/share"]  # Only these paths readable outside workspace

Couche 2 : politique d’approbation (quand demander)

La politique d’approbation détermine quand Codex se met en pause pour demander une confirmation humaine :

on-failure apparaît encore dans certains anciens exemples et chemins de compatibilité, mais la documentation de configuration OpenAI actuelle le marque comme obsolète. Préférez on-request pour les exécutions interactives et never pour les exécutions non interactives qui disposent déjà d’une limite de sécurité externe.⁸⁷

ID d’approbation distincts (v0.104.0+)

Codex attribue désormais des ID d’approbation distincts à chaque commande dans une exécution shell en plusieurs étapes. Les approbations sont donc granulaires : approuver une commande dans une séquence n’approuve pas automatiquement les suivantes dans la même invocation shell.⁴⁹

Contrôles d’approbation flexibles (v0.105.0+)

Le flux d’approbation prend désormais en charge des permissions de sandbox supplémentaires et un rejet granulaire :⁶¹

• Permissions de sandbox supplémentaires : lorsqu’une commande nécessite un accès au-delà du mode de sandbox actuel, Codex peut demander des permissions supplémentaires spécifiques au lieu d’exiger un changement complet de mode
• Rejet granulaire : rejetez des appels d’outil individuels avec un retour afin que Codex puisse ajuster son approche au lieu de simplement relancer la même commande

Demandes de permissions à l’exécution (v0.113.0+)

Codex inclut désormais un outil intégré request_permissions qui permet au modèle de demander des permissions supplémentaires à l’exécution.⁶⁹ Lorsque le modèle rencontre une tâche nécessitant un accès élevé, il peut demander formellement des permissions spécifiques (chemins de système de fichiers, accès réseau, etc.) via le flux d’approbation du TUI, plutôt que d’échouer silencieusement ou d’obliger l’utilisateur à redémarrer avec d’autres flags.

Profils de permissions (v0.113.0+, étendus en v0.128.0 et v0.133.0)

Les profils de permissions divisent les politiques de sandbox du système de fichiers et du réseau en sections nommées et réutilisables. Définissez default_permissions sur un profil intégré comme :read-only, :workspace, ou faites-le pointer vers une table personnalisée [permissions.<name>].⁸⁷ La v0.133.0 promeut les profils comme surface gérée : les list APIs exposent les métadonnées des profils disponibles, les profils peuvent hériter les uns des autres, le fichier requirements.toml géré peut déclarer des exigences de permissions, les profils actifs s’actualisent à l’exécution, et la configuration du sandbox Windows consomme désormais le profil résolu plutôt qu’une politique ad hoc séparée.⁹⁸

default_permissions = "project-safe"

[permissions.project-safe.filesystem]
"/usr/local" = "read"
glob_scan_max_depth = 3

[permissions.project-safe.filesystem.":project_roots"]
"." = "write"
"**/*.env" = "none"

[permissions.project-safe.network]
enabled = true
mode = "limited"

[permissions.project-safe.network.domains]
"api.github.com" = "allow"
"registry.npmjs.org" = "allow"

Utilisez none pour les fichiers sensibles et les globs qui doivent rester illisibles même lorsque la racine du projet est accessible en écriture. Pour les exceptions ponctuelles de commande, préférez les règles à l’élargissement massif d’un profil.⁸⁷

Recommandations héritées pour --full-auto

D’anciens guides décrivaient --full-auto comme un alias pratique pour :

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

Dans la v0.128.0, les notes de version marquent --full-auto comme obsolète, et l’aide CLI actuelle ne l’affiche plus pour les exécutions interactives. Utilisez plutôt les flags explicites ci-dessus ou un profil de permissions nommé.⁸⁶

Fiabilité du sandbox (v0.129.0) : le durcissement du démarrage du sandbox Linux réduit les courses sur les systèmes de fichiers lents ou les checkouts avec liens symboliques ; les améliorations de fiabilité du sandbox Windows corrigent plusieurs plantages de cas limites pendant les exécutions longues ; et Bubblewrap intégré passe à la version 0.11.2 avec des correctifs de sécurité upstream. Aucun changement de configuration requis. Exécutez codex update pour en bénéficier.⁸⁹

Configurations recommandées

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

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

Power user (accès complet, humain dans la boucle) :

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

Cette combinaison est le « sweet spot » recommandé par la communauté : capacité maximale, mais approbation requise pour chaque commande.⁸

Automatisation CI/CD :

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

Approbations intelligentes avec le subagent Guardian (v0.115.0+)

Les Approbations intelligentes peuvent acheminer les demandes de review via un subagent guardian au lieu d’exiger une approbation humaine pour chaque action. La session guardian persiste entre les approbations afin de réutiliser le cache de prompt et d’éviter le coût de démarrage. Chaque review reçoit un historique propre (les décisions précédentes ne fuient pas dans les reviews ultérieures).⁷³

Configurez le reviewer dans config.toml :

approvals_reviewer = "guardian_subagent"   # "user" (default) or "guardian_subagent"

C’est particulièrement utile pour les workflows CI/CD où vous souhaitez une review automatisée avec raisonnement plutôt qu’un approval_policy = "never" généralisé.

Activer l’accès réseau

Codex bloque l’accès réseau par défaut en mode workspace-write. Activez-le lorsque c’est nécessaire :

# 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

Prise en charge du proxy WebSocket (v0.104.0+)

Pour les environnements d’entreprise qui acheminent le trafic WebSocket via un proxy, Codex prend désormais en charge les variables d’environnement WS_PROXY et WSS_PROXY :⁴⁹

export WSS_PROXY="https://proxy.corp.example.com:8443"
codex "update the README"

Elles complètent la prise en charge existante de HTTPS_PROXY et du proxy SOCKS5 (v0.93.0+), couvrant toutes les couches de transport.

Tester le sandbox

Vérifiez le comportement du sandbox avant de lui faire confiance :

codex sandbox macos --permissions-profile :workspace -- ls /etc/passwd   # macOS test
codex sandbox linux --permissions-profile :workspace -- cat /etc/shadow  # Linux test

Si le sandbox fonctionne correctement, les deux commandes doivent échouer avec une erreur de type permission denied sous un profil limité au workspace. Si l’une des deux commandes réussit, votre configuration de sandbox doit être examinée.

Comment fonctionne AGENTS.md ?

AGENTS.md est le système d’instructions de projet de Codex : un standard ouvert⁹ désormais régi par l’Agentic AI Foundation de la Linux Foundation. Pris en charge par Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode et plus de 60 000 projets open source. Il définit le comportement de Codex dans un dépôt ou un dossier précis. Consultez Skills pour découvrir les packages d’expertise réutilisables qui complètent AGENTS.md.

Hiérarchie de découverte

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

1. Global (~/.codex/) : AGENTS.override.md > AGENTS.md
2. Projet (de la racine git au dossier actuel) : chaque niveau est vérifié pour AGENTS.override.md > AGENTS.md > noms de fichiers de secours
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 consignes 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 excellent AGENTS.md

D’après les recommandations directes de Codex lui-même et les pratiques de la communauté¹⁰ :

À FAIRE : - Soyez précis : "Use rg --files for discovery" vaut mieux que "search efficiently" - Définissez la clôture : que signifie « terminé » ? (tests réussis, lint sans erreur, etc.) - Incluez les commandes : build, test, lint, format (invocations exactes) - Organisez par tâche : sections codage, review, release, incident/debug - Définissez l’escalade : quoi faire en cas de blocage ou d’état inattendu

À NE PAS FAIRE : - Déverser 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 (vitesse + vérification exhaustive + aucun budget d’exécution) - Rédiger de la documentation 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.

Gestion des secrets dans les sessions Agent

Considérez l’historique visible par Codex comme une surface de sécurité, pas seulement comme du code source. Les notes de version de Codex documentent les travaux sur les instantanés shell et la rédaction des variables d’environnement, et le système de mémoire recherche les secrets dans les écritures en mémoire, mais ces protections ne transforment pas les sorties de commande, transcriptions de session, instantanés shell, journaux locaux ou scripts d’aide en emplacements sûrs pour afficher des identifiants.³⁷⁵⁵⁹⁵

La règle opérationnelle est simple : n’affichez pas de secrets que le modèle pourrait inspecter ; conservez les identifiants d’aide dans une configuration qui exige l’environnement ; séparez le code source exécutable, la documentation, les caches générés, les transcriptions de session, les instantanés shell, les journaux et les magasins de secrets intentionnels pendant les audits ; expurgez l’historique local lorsqu’une forme de secret à forte confiance apparaît ; et ne promouvez les hooks de prévention qu’après validation de la boucle d’hygiène manuelle. La leçon publique est la cartographie des surfaces et les critères d’acceptation, pas les valeurs privées des tokens, les chemins exacts ni les détails internes des détecteurs.⁹⁵

Le mécanisme d’override

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

• Gel de release : « Pas de nouvelles fonctionnalités, correctifs uniquement »
• Mode incident : « Toutes les modifications doivent être examinées par l’astreinte »
• Durcissement temporaire : « Aucune mise à jour de dépendance 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 scaffold

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"

Hooks

Codex a introduit les hooks dans v0.99.0 (AfterAgent) et v0.100.0 (AfterToolUse), puis ajouté un moteur de hooks expérimental dans v0.114.0 avec les événements SessionStart et Stop.⁷⁰ Depuis v0.124.0 (23 avril 2026), les hooks sont stables.⁸⁵ Ils sont désormais configurables inline dans config.toml et requirements.toml : plus besoin de fichier de scripts de hooks séparé ; ils observent les outils MCP aux côtés de apply_patch et des longues sessions Bash. Le système couvre maintenant le cycle de vie de session et l’automatisation au niveau des outils, comblant l’écart avec le modèle de hooks de Claude Code.

Événements de hook disponibles

Configuration des hooks

Les hooks sont configurés dans .codex/config.toml :

[[hooks]]
event = "AfterToolUse"
command = "echo 'Tool completed' >> /tmp/codex-log.txt"

[[hooks]]
event = "SessionStart"
command = "echo 'Current date: $(date +%Y-%m-%d)'"

La sortie stdout du hook SessionStart alimente le contexte du modèle, ce qui le rend idéal pour injecter des informations dynamiques (dates, noms de branche, variables d’environnement) au démarrage de la session.

Répliquer les patterns de hooks de Claude Code

Si vous migrez depuis Claude Code, voici comment obtenir une automatisation similaire :

Conseil d’expert : depuis v0.124.0 (23 avril 2026), le moteur de hooks est stable. De nouveaux événements de hook sont encore livrés dans les releases : consultez le changelog Codex.

Navigateur de hooks dans la TUI (v0.129.0) : exécutez /hooks dans la TUI pour découvrir les hooks disponibles, voir ceux qui sont actuellement actifs et activer ou désactiver des hooks individuels sans modifier config.toml. Utile pour diagnostiquer un hook intégré à un plugin qui se comporte mal, ou pour désactiver temporairement un linter AfterToolUse pendant une session d’édition concentrée.⁸⁹

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, et les commandes comme le format de configuration peuvent changer d’une version à l’autre. Codex prend en charge deux types de transport : STDIO (processus locaux) et Streamable HTTP (serveurs distants).¹¹

Changements MCP de v0.121.0 : les outils sont désormais enregistrés avec un namespace, si bien que les noms d’outils dans les listes apparaissent sous la forme <server>:<tool> plutôt que comme des noms seuls — mettez à jour les scripts ou prompts qui utilisent grep sur des noms d’outils non qualifiés. Un nouveau flag supports_parallel_tool_calls est transmis aux MCP inclus, ce qui permet l’exécution parallèle pour les serveurs qui déclarent la prendre en charge. Les métadonnées d’état du sandbox transitent désormais par les métadonnées des outils MCP, afin que les serveurs puissent adapter leur comportement (par exemple, avertir lorsqu’ils s’exécutent dans un sandbox en lecture seule). La requête personnalisée codex/sandbox-state a été supprimée — utilisez plutôt le chemin des métadonnées. La phase 3 du déploiement des Apps MCP arrive ici avec la prise en charge des appels d’outils ; les appels d’outils différés aplatis sont désormais pris en charge pour les serveurs qui utilisent le modèle d’appel différé.⁸²

Configurer des 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 de 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. /mcp verbose (v0.123.0+)⁸⁴ renvoie les diagnostics complets du serveur, les ressources et les modèles de ressources — utile lorsqu’un serveur ne se charge pas ou que les outils n’apparaissent pas à l’endroit attendu. Le simple /mcp reste rapide.

Le chargement des plugins MCP (v0.123.0+) accepte à la fois le schéma standard mcpServers et les maps de serveurs de premier niveau dans .mcp.json, ce qui permet aux plugins écrits pour l’une ou l’autre convention de se charger correctement.⁸⁴

Exécuter Codex EN TANT QUE serveur MCP

Codex peut s’exposer lui-même comme serveur MCP pour l’orchestration multi-agent :¹²

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

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

Utilisation avec le SDK Agents (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

Modèles pratiques

Modèle 1 : développement sensible au contexte — Associez Context7 à la documentation de votre framework afin que Codex dispose toujours de références API à jour :

[mcp_servers.context7]
enabled = true
required = true
command = "npx"
args = ["-y", "@upstash/context7-mcp"]

Modèle 2 : limites de sortie — Les réponses des outils MCP sont tronquées à environ 25 000 caractères par défaut. Pour les outils qui renvoient de gros volumes de données (requêtes de base de données, captures de logs), utilisez enabled_tools afin de limiter l’accès à des outils précis et de garder des réponses ciblées.

Modèle 2a : sortie d’outil multimodale (v0.107.0) — Les outils personnalisés peuvent désormais renvoyer une sortie multimodale (images, contenu enrichi) en plus du texte. Cela permet aux outils qui produisent des artefacts visuels — captures d’écran, diagrammes, rendus de graphiques — de les transmettre directement au modèle pour analyse.⁶²

Modèle 3 : gouvernance MCP en entreprise — Verrouillez les serveurs MCP que les développeurs peuvent utiliser via requirements.toml :

# In /etc/codex/requirements.toml — only approved servers allowed
[mcp_servers.approved-internal]
identity = { command = "npx @company/internal-mcp" }

Tout serveur ne correspondant pas à une identité dans requirements.toml sera bloqué au démarrage. Consultez Déploiement en entreprise pour la configuration complète des politiques.

Code Mode [EXPERIMENTAL]

Code mode (v0.114.0) fournit des workflows de codage plus isolés en restreignant le périmètre de l’agent aux opérations centrées sur le code.⁷⁰ Lorsqu’il est activé, l’agent se concentre sur la lecture, l’écriture et les tests de code, sans interactions système plus larges.

Depuis v0.139.0, code mode peut appeler directement une recherche web autonome — y compris depuis des appels d’outils JavaScript imbriqués — et reçoit des résultats en texte brut, si bien qu’un flux code-mode peut récupérer des informations en direct sans quitter le contexte de codage sandboxé.¹⁰⁵

Cette fonctionnalité est expérimentale. Consultez les notes de version pour les mises à jour.

Runtime REPL JavaScript [REMOVED]

Codex v0.100.0 a ajouté un runtime REPL JavaScript expérimental (js_repl), puis v0.106.0 l’a promu via la surface /experimental.⁶⁰ Ces consignes relèvent désormais de l’historique. Dans v0.128.0, le changelog de version inclut « Remove js_repl feature », et la liste actuelle des fonctionnalités marque js_repl et js_repl_tools_only comme supprimés.⁸⁶

N’ajoutez pas features.js_repl = true aux nouvelles configurations. Utilisez des commandes shell, des scripts versionnés, des outils MCP ou une skill Codex avec un dossier scripts/ lorsque vous avez besoin d’une logique exécutable répétable.

Que sont les skills ?

Les skills sont des packages de capacités réutilisables et propres à 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

Codex stocke les skills installés par l’utilisateur 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 symlink.

Créer un skill

Format SKILL.md :

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

## Security Audit Procedure

1. Scan for hardcoded secrets using `rg -i "(api_key|password|secret|token)\s*=" --type py`
2. Check for SQL injection: look for string interpolation in queries
3. Verify input validation on all API endpoints
4. Check dependency vulnerabilities: `pip audit` or `npm audit`
5. Review authentication and authorization patterns
6. Report findings with severity levels (Critical/High/Medium/Low)

Métadonnées (agents/openai.yaml) :

interface:
  display_name: "Security Audit"
  short_description: "Full 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 créer un nouveau skill de manière interactive
• Installeur : utilisez $skill-installer install <name> pour installer des skills communautaires

Activer/désactiver

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

Skills vs Slash Commands

Déboguer les skills

Si un skill ne s’active pas :

1. Vérifiez la découverte : /skills doit lister le skill dans le TUI
2. Vérifiez le chemin : assurez-vous que le dossier du skill se trouve dans un emplacement reconnu (~/.codex/skills/, racine du projet ou /etc/codex/skills/)
3. Vérifiez enabled : les skills avec enabled = false dans config.toml ne seront pas chargés
4. Vérifiez l’activation implicite : si vous vous appuyez sur la détection automatique, assurez-vous que allow_implicit_invocation: true figure dans agents/openai.yaml
5. Utilisez des mots-clés : incluez les termes de description du skill dans votre prompt pour améliorer la correspondance implicite

Exemple en production : skill de déploiement

Un skill complet à plusieurs fichiers montrant comment références et scripts fonctionnent ensemble :

deploy-skill/
  SKILL.md
  references/
    runbook.md
    rollback-checklist.md
  scripts/
    pre-deploy-check.sh
    smoke-test.sh
  agents/openai.yaml

SKILL.md :

---
name: deploy
description: Deploy the application to staging or production. Runs pre-flight checks, executes deployment, and verifies with smoke tests.
---

## Deployment Procedure

### Pre-flight
1. Run `scripts/pre-deploy-check.sh` to verify:
   - All tests pass
   - No uncommitted changes
   - Branch is up to date with remote
2. Review the runbook at `references/runbook.md` for environment-specific steps.

### Deploy
3. Execute the deployment command for the target environment.
4. Monitor logs for errors during rollout.

### Verify
5. Run `scripts/smoke-test.sh <environment-url>` to confirm critical paths.
6. If smoke tests fail, follow `references/rollback-checklist.md`.

Invoquez-le avec : $deploy to staging ou $deploy production with canary rollout

Plugins

Les plugins unifient les skills, les entrées MCP, les hooks et les connecteurs d’apps dans un seul package installable (v0.110.0+).⁶⁵ Depuis la v0.117.0, les plugins sont des éléments de premier plan : les plugins à périmètre produit se synchronisent automatiquement au démarrage et /plugins fournit un navigateur intégré au TUI pour la découverte et la gestion.⁷⁵ La v0.128.0 a étendu les workflows de plugins avec l’installation depuis la marketplace, la mise en cache de bundles distants, les APIs de désinstallation distante, les hooks groupés dans les plugins, l’état d’activation des hooks et l’import de configuration d’agent externe.⁸⁶ v0.129.0 (7 mai 2026) ajoute le partage de plugins au niveau du workspace (pousser un ensemble de plugins à des coéquipiers sans republier), les contrôles d’accès au partage (activation/désactivation par destinataire, révocation), le filtrage des sources (limiter les marketplaces depuis lesquelles un workspace récupère des éléments) et les opérations de marketplace qui peuvent être invoquées directement depuis le navigateur /plugins au lieu du CLI.⁸⁹ v0.133.0 (21 mai 2026) rend la découverte de plugins plus facile à auditer : la sortie de liste tient compte des marketplaces, les versions installées sont visibles, les racines de marketplace sont listées et les collections de plugins distantes peuvent être affichées sans deviner de quel registre provient un résultat.⁹⁸ v0.130.0 (8 mai 2026) rend le packaging des plugins plus transparent et le workflow de partage plus contrôlable :⁹¹

• Hooks groupés visibles dans les détails du plugin. La vue détaillée de /plugins liste désormais chaque hook de cycle de vie inclus dans un plugin (SessionStart, UserPromptSubmit, Stop, etc.). Avant d’installer un plugin, vous pouvez voir exactement quels hooks il enregistrera dans votre session — plus d’effets de bord inattendus provenant des hooks d’un plugin auquel vous faites confiance uniquement pour ses outils.
• Métadonnées de partage de plugin dans shareContext. Lorsqu’un plugin est partagé depuis un workspace, le payload du lien de partage expose désormais les métadonnées du lien (créateur, périmètre, fraîcheur) afin que les sessions réceptrices puissent afficher la provenance et décider de l’accepter ou non.
• Contrôles de découvrabilité dans les paramètres de partage. Les paramètres de partage exposent un bouton de découvrabilité, ce qui permet aux équipes de publier des plugins vers des workspaces ou des listes de destinataires spécifiques sans les rendre globalement listables dans toute une organisation.

Sources de plugins

Découverte des plugins

Codex indique au modèle quels plugins sont activés au démarrage de la session (v0.111.0), ce qui améliore la découverte des MCPs, apps et skills installés.⁶⁵ Le modèle peut suggérer des plugins pertinents pendant une session selon le contexte de la tâche. Dans la v0.117.0, les plugins à périmètre produit sont synchronisés au démarrage, ce qui garantit que le dernier catalogue de plugins est disponible sans intervention manuelle.⁷⁵ Depuis la v0.142.0, le menu /plugins organise les plugins distants en sections OpenAI Curated, Workspace et Shared with me, et les tours éligibles peuvent recommander et installer des plugins pertinents directement en ligne.¹⁰⁴

Mentions @plugin (v0.112.0+)

Référencez directement dans le chat n’importe quel plugin installé avec @plugin-name.⁶⁸ Lorsque vous mentionnez un plugin, son contexte (capacités, outils, configuration) est automatiquement inclus dans la fenêtre de contexte du modèle : inutile de décrire ce que fait le plugin.

@deploy push this branch to staging with canary rollout
@linter check for unused imports in src/

Cela fonctionne avec n’importe quel plugin installé, y compris les skills personnalisés, les serveurs MCP et les connecteurs d’apps.

Plugin Marketplace (v0.113.0+)

La plugin marketplace inclut désormais une découverte plus riche avec des métadonnées, des catégories et des notes.⁶⁹ Les vérifications d’authentification à l’installation confirment que les plugins nécessitant des clés API ou OAuth disposent d’identifiants valides avant l’installation. Un endpoint de désinstallation supprime proprement les plugins et leur configuration associée.

Ajouter des marketplaces tierces (v0.121.0+)

La documentation OpenAI Codex actuelle conserve la gestion des sources de marketplace sous codex plugin marketplace. Cela formalise la distribution de plugins tiers au-delà de la marketplace propriétaire d’OpenAI et prend en charge les raccourcis de repo GitHub, les URL Git HTTP(S), les URL SSH et les dossiers racines de marketplace locaux ; utilisez --ref pour épingler une ref Git et répétez --sparse PATH uniquement pour les repos de marketplace basés sur Git.⁹³

# GitHub repository (shorthand)
codex plugin marketplace add owner/repo

# Arbitrary git URL
codex plugin marketplace add https://git.example.com/team/plugins.git

# SSH Git URL
codex plugin marketplace add [email protected]:team/plugins.git

# Local directory
codex plugin marketplace add /path/to/local/marketplace

# Upgrade or remove a configured marketplace
codex plugin marketplace upgrade <marketplace-name>
codex plugin marketplace remove <marketplace-name>

Une fois ajoutés, les plugins d’une marketplace apparaissent dans le navigateur /plugins aux côtés des plugins par défaut. Les appelants du serveur d’app (intégrations IDE/desktop) disposent d’un endpoint parallèle pour enregistrer des marketplaces par programmation.⁸²

Considération de sécurité : les marketplaces tierces exécutent du code de plugin arbitraire avec vos permissions Codex. Évaluez les sources avant de les ajouter et privilégiez l’exécution en sandbox lors des premiers lancements.

Gérer les plugins

codex plugin marketplace add <src>       # Add a marketplace source
codex plugin marketplace upgrade [name]  # Upgrade one marketplace or all
codex plugin marketplace remove <name>   # Remove a configured marketplace

Dans le TUI, utilisez /plugins (v0.117.0+) pour parcourir, installer et supprimer des plugins individuels de manière interactive sans quitter votre session.⁷⁵

Conseil d’expert : les plugins consolident ce qui nécessitait auparavant une configuration MCP séparée, l’installation de skills et la configuration de connecteurs d’apps. Un seul plugin peut regrouper les trois, ce qui accélère l’onboarding d’équipe et rend la configuration plus portable.

Plan Mode et collaboration

Plan mode permet à Codex de concevoir une approche avant d’exécuter des changements. Il est activé par défaut (depuis la v0.94.0).¹⁴ Consultez Cadres de décision pour l’arbre de décision « Plan Mode vs Direct Execution ».

Entrer dans 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 la base de code - Propose un plan d’implémentation - N’apporte aucun changement tant que vous n’approuvez pas - Diffuse le plan 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 activement, sans interrompre sa tâche en cours.¹⁴

Il existe deux méthodes d’injection :

Exemples pratiques :

# Codex is refactoring the auth module...

[Enter] "Use bcrypt instead of argon2 — we already have it as a dependency"
→ Codex adjusts immediately, mid-turn

[Tab] "Once auth is done, update the migration script too"
→ Codex finishes auth refactor, then starts the migration

Steer mode est toujours actif dans le TUI. Si vous préférez attendre que Codex termine avant de donner des instructions, tapez simplement normalement une fois le tour terminé : aucun mode spécial n’est nécessaire.

Améliorations du TUI (v0.105.0–v0.106.0)

Coloration syntaxique (v0.105.0) : le TUI applique désormais une coloration syntaxique aux blocs de code clôturés et aux diffs en ligne. Utilisez /theme pour choisir un jeu de couleurs.⁶¹

Nouvelles commandes TUI (v0.105.0+) :⁶¹

Transcription vocale (v0.105.0, expérimentale) : appuyez sur la barre d’espace pour dicter des prompts via la transcription vocale. Cette fonctionnalité est expérimentale et peut nécessiter des permissions de microphone.⁶¹ Depuis la v0.107.0, les sessions vocales en temps réel prennent en charge la sélection du microphone et du haut-parleur, ce qui vous permet de choisir un matériel d’entrée/sortie audio spécifique.⁶² Supprimé dans la v0.140.0 : les contrôles vocaux expérimentaux /realtime et leurs dépendances audio ont été retirés du TUI ; la transcription vocale avec la barre d’espace n’est pas affectée.¹⁰²

Autres améliorations : - Les liens longs restent désormais cliquables même lorsqu’ils sont renvoyés à la ligne dans le TUI (v0.105.0)⁶¹ - Les liens vers des fichiers locaux s’affichent avec une mise en forme améliorée (v0.106.0)⁶⁰ - Le Markdown du TUI conserve les liens web cliquables via les métadonnées OSC 8, et les tableaux trop serrés se replient en enregistrements clé/valeur lisibles sans perdre les cibles des liens (v0.136.0)¹⁰⁸ - La gestion de Ctrl+C pour les sous-agents a été corrigée afin de terminer correctement les processus enfants (v0.106.0)⁶⁰

Système de mémoire

Codex dispose d’un système de mémoire persistant (v0.100.0+) qui stocke les faits, les préférences et le contexte du projet entre les sessions.²⁴

Commandes de mémoire

Les mémoires sont stockées dans des fichiers markdown sous ~/.codex/memory/. Codex les charge au démarrage de la session et les utilise pour orienter son comportement dans toutes les sessions futures.

Ce qu’il faut stocker

Les mémoires fonctionnent mieux pour les préférences persistantes et les faits liés au projet :

• Conventions du projet : « Ce projet utilise des tabulations, pas des espaces » ou « Les réponses API incluent toujours un champ meta »
• Préférences d’outils : « Utiliser pnpm au lieu de npm » ou « Exécuter les tests avec pytest -x --tb=short »
• Décisions d’architecture : « Le module auth se trouve dans src/core/auth/, pas dans src/middleware/ »
• Préférences de workflow : « Toujours exécuter le linter avant de me montrer un diff »

Mémoire dans les pipelines

Lors de l’exécution de codex exec, les mémoires sont chargées automatiquement. Cela signifie que les pipelines CI/CD et les scripts bénéficient du même contexte que les sessions interactives — inutile de répéter les instructions à chaque invocation.

Améliorations de la mémoire (v0.101.0–v0.107.0)

• Nettoyage des secrets : les mémoires sont automatiquement analysées à la recherche de secrets avant d’être écrites sur le disque
• Prise en compte du CWD : les fichiers de mémoire incluent désormais le contexte du répertoire de travail pour un rappel propre au projet
• Exclusion des messages développeur : les messages développeur/système sont exclus de l’entrée mémoire de phase 1, ce qui améliore la qualité de la mémoire en la concentrant sur les interactions utilisateur
• Oubli basé sur les diff (v0.106.0) : la mémoire utilise désormais un oubli basé sur les diff pour supprimer les faits obsolètes, ce qui maintient le magasin de mémoire léger et pertinent dans le temps⁶⁰
• Sélection sensible à l’usage (v0.106.0) : la récupération des mémoires tient désormais compte de l’usage, en donnant la priorité aux mémoires fréquemment consultées et récemment pertinentes⁶⁰
• Mémoires configurables (v0.107.0) : les mémoires sont désormais entièrement configurables. Utilisez codex debug clear-memories pour réinitialiser toutes les mémoires stockées et repartir de zéro — utile lorsque vous changez de contexte entre des projets sans rapport ou lorsque l’état de la mémoire a dérivé⁶²
• Mise à niveau du modèle de phase 2 (v0.121.0) : le modèle de consolidation de mémoire de phase 2 est désormais gpt-5.4 (au lieu de l’ancien modèle par défaut). Le pipeline de phase 2 s’exécute entre les sessions pour condenser les transcriptions de phase 1 en faits durables ; ce changement de modèle améliore la qualité du rappel au même coût en tokens.⁸²
• Menu des mémoires dans la TUI (v0.121.0) : une nouvelle UI en session expose le mode mémoire, la suppression de mémoires individuelles et un bouton de réinitialisation. La réinitialisation de la mémoire préserve désormais les rollouts passés au lieu de les invalider, de sorte qu’elle efface la surface de rappel future sans casser la relecture de session.⁸²

Mémoire vs AGENTS.md

Astuce : utilisez /m_update pour les faits qui doivent persister indéfiniment. Pour le contexte propre à une session, indiquez-le simplement à Codex directement dans la conversation. Pour le contexte partagé avec l’équipe, utilisez AGENTS.md.

Gestion des sessions

Codex conserve les sessions sous ~/.codex/sessions/, ce qui permet la reprise, le fork et les workflows multi-threads entre les surfaces CLI et desktop.

Reprendre

Reprenez là où vous vous étiez arrêté :

codex resume                          # Interactive picker (sorted by recency)
codex resume <SESSION_ID>             # Resume a specific session
codex exec resume --last "continue"   # Non-interactive: resume most recent

La slash command /resume dans la TUI ouvre le même sélecteur interactif avec recherche.

Fork

Branchez une conversation pour explorer des alternatives sans perdre votre progression actuelle :

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

Les forks créent des threads indépendants partageant le même historique jusqu’au point de fork. Les changements dans un fork n’affectent pas l’autre. C’est utile pour comparer des approches (par exemple, « fork et essayer Redis au lieu de Memcached ») ou explorer des changements risqués en toute sécurité.

Fork de threads vers des sub-agents (v0.107.0) : les threads peuvent désormais être forkés vers des sub-agents indépendants, ce qui permet à une conversation de lancer des flux de travail parallèles qui s’exécutent de manière autonome. Cela étend le modèle de fork existant — au lieu de simplement brancher la conversation, le thread forké devient un sub-agent avec son propre contexte d’exécution.⁶² Depuis la v0.117.0, les sub-agents utilisent des adresses basées sur les chemins (par exemple, /root/agent_a) avec une messagerie inter-agents structurée, ce qui rend la coordination multi-agent plus explicite et plus facile à déboguer.⁷⁵

Liste des threads

Affichez et gérez les sessions actives :

/status                            # Current session info and token usage
/ps                                # Show background terminals in session

Dans l’app desktop, les threads sont visibles dans la barre latérale avec l’historique complet et des aperçus de diff.

Cycle de vie d’une session

Les sessions se synchronisent entre CLI et l’app desktop — commencez dans l’une, continuez dans l’autre.

Mode non interactif (codex exec)

codex exec exécute Codex de manière non interactive pour les scripts, la CI/CD et l’automatisation.¹⁵

Utilisation de base

codex exec "summarize the repository structure"
codex exec --sandbox workspace-write --ask-for-approval on-request "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 dans stderr, et le message final de l’agent dans stdout. Cette conception le rend composable avec les pipelines Unix standard.

Archivage des sessions (v0.136.0)

Les sessions peuvent être archivées afin de garder la liste de reprise/fork ciblée sans supprimer l’historique. Archivez depuis la TUI avec /archive, ou depuis le shell :¹⁰⁸

codex archive <session-id>     # archive a session
codex unarchive <session-id>   # restore it

Une session archivée est protégée contre les opérations de reprise ou de fork jusqu’à ce que vous la désarchiviez : un garde-fou contre la reprise accidentelle d’une session que vous comptiez retirer. Même version : codex app-server --stdio lance l’app-server en mode stdio pour les intégrations éditeur/hôte, et /diff ne peut désormais plus exécuter les assistants Git fournis par le dépôt (un correctif de sécurité des commandes). Sous Windows, un chemin de provisionnement alpha ajoute codex sandbox setup --elevated pour les administrateurs.¹⁰⁸

Sortie en lignes JSON

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 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 clés

Authentification CI

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

Bannière de démarrage codex exec (v0.130.0). La bannière de démarrage de codex exec n’affiche plus l’ancien libellé « research preview ». Si votre CI extrait la sortie de démarrage, le texte de la bannière est désormais plus léger ; les événements structurés --json restent inchangés.⁹¹

codex remote-control (v0.130.0+)

codex remote-control est une commande de premier niveau qui démarre un app-server headless destiné à être piloté par un autre processus : extensions IDE, orchestrateurs personnalisés ou plans de contrôle distants. Elle remplace l’invocation codex app-server à flags multiples que de nombreux intégrateurs assemblaient à la main, et fournit aux outils tiers un point d’entrée unique et stable vers le même runtime app-server que celui livré avec les surfaces desktop et IDE.⁹¹ La v0.133.0 améliore la forme d’exécution de la commande : elle peut fonctionner comme une commande au premier plan, attendre la disponibilité, rapporter l’état de la machine, tout en exposant des commandes explicites de type démon start / stop pour les configurations de contrôleur longue durée.⁹⁸

# Start a headless, remotely controllable app-server
codex remote-control

# Same lifecycle as a TUI session: thread store, hooks, plugins, MCP, sandbox
# all initialize from your normal config.toml.

Associez codex remote-control aux APIs de pagination app-server ci-dessous lorsque vous créez des UI qui doivent énumérer de longs historiques de threads sans charger chaque turn en mémoire d’un seul coup.

Pagination des threads App-Server (v0.130.0+)

Les clients app-server peuvent désormais paginer de grands threads via trois vues distinctes des éléments de turn :⁹¹

Associez la pagination à l’interface ThreadStore introduite en v0.121.0 afin de parcourir efficacement les threads longue durée, en particulier dans les déploiements remote-control où l’orchestrateur peut se trouver sur une machine différente de celle des fichiers de rollout.⁸²

Actualisation à chaud de la configuration App-Server (v0.130.0+)

Les threads app-server actifs prennent désormais en compte les changements de config.toml sans nécessiter de redémarrage : modifiez la configuration, enregistrez, et le thread en cours reflète les nouvelles valeurs à son prochain turn. C’est le pendant correctif de codex remote-control : un serveur headless longue durée peut être reconfiguré sur place au lieu d’être arrêté puis relancé.⁹¹

Exécuteurs distants chiffrés (v0.141.0)

Depuis la v0.141.0 (stable, 18 juin 2026), les exécuteurs distants se connectent via des canaux Noise-relay authentifiés et chiffrés de bout en bout : le plan de contrôle et l’exécuteur n’ont plus à faire confiance au relais placé entre eux, ce qui compte dès que votre orchestrateur pilote un app-server au-delà d’une frontière réseau. La même version a fait en sorte que l’exécution distante multiplateforme préserve le dossier de travail et le shell natifs de l’exécuteur ; ainsi, lorsqu’un contrôleur sur un OS pilote un exécuteur sur un autre, les chemins ou la sémantique du shell ne sont plus réécrits sous ses pieds. TLS accepte également désormais les signatures de certificat P-521 pour la compatibilité avec les proxys d’entreprise.¹⁰³

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

Statut : Codex Cloud est une fonctionnalité expérimentale. Les interfaces, les tarifs et la disponibilité peuvent changer. OpenAI gère les environnements cloud, et vous ne contrôlez pas l’infrastructure.

Codex Cloud exécute les tâches de façon asynchrone dans des environnements gérés par OpenAI.⁴ Consultez aussi Action GitHub et CI/CD pour intégrer Codex à votre pipeline CI.

Fonctionnement

1. Soumettez une tâche (via chatgpt.com/codex, l’intégration Slack ou CLI)
2. Codex clone votre dépôt dans une sandbox cloud isolée
3. L’agent travaille de manière autonome : il lit le code, exécute les tests et apporte 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 :

• Off : aucun accès Internet pour l’agent (par défaut)
• On : liste d’autorisation de domaines facultative + restrictions de méthodes HTTP

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

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

Intégration Slack

Mentionnez @Codex dans un canal ou un thread Slack pour démarrer 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. App Slack installée pour votre workspace

Codex répond avec un lien de tâche et publie les résultats une fois celle-ci terminée.

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’app Codex Desktop

L’app de bureau Codex (macOS et Windows) fournit une interface graphique optimisée pour la gestion de plusieurs projets.¹⁶ La version Windows a été lancée le 4 mars 2026 avec la prise en charge native de PowerShell et un sandbox Windows natif.⁶⁶

Installation

codex app                      # Auto-downloads and installs on first run

Ou téléchargez directement : Codex.dmg (macOS) | Disponible dans le Microsoft Store (Windows)

Fonctionnalités clés

Appshots, commentaires de navigateur et Computer Use

Les mises à jour de l’app du 21 mai font de l’app de bureau une surface de contexte plus puissante, plutôt qu’un simple gestionnaire de threads. Utilisez Appshots lorsque Codex a besoin de l’état d’une autre app Mac avant d’agir : Codex capture la fenêtre au premier plan, le texte visible/hors écran disponible exposé par l’app, puis stocke la pièce jointe localement dans l’historique de session.⁹⁹

Pour le travail web et frontend, utilisez d’abord le navigateur intégré lorsque la page ne nécessite pas d’authentification : il vous donne, à vous et à Codex, un aperçu rendu partagé, prend en charge des actions de type browser-use comme les clics, les captures d’écran, les téléchargements d’assets et l’inspection JavaScript en lecture seule, et vous permet de marquer des zones de page avec des commentaires que Codex peut traiter au tour suivant.⁹⁹ Pour les sites avec connexion, continuez à utiliser l’extension Chrome.

Utilisez Computer Use uniquement lorsqu’une intégration structurée ou un aperçu navigateur ne peut pas vérifier la tâche. Il peut inspecter et utiliser des apps Mac autorisées, mais il hérite des approbations Codex et des règles de sandbox pour les modifications de fichiers et les commandes shell ; l’utilisation verrouillée reste étroite : Codex peut accéder temporairement aux apps autorisées pendant les tours Computer Use actifs et de confiance après le verrouillage du Mac, avec des protections de reverrouillage et une détection des entrées locales.⁹⁹

Modes de thread

Chaque thread s’exécute dans l’un des trois modes, sélectionné lors de sa création :

Mécanismes d’isolation Worktree :

Lorsque vous démarrez un thread Worktree, l’app de bureau : 1. Crée un nouveau git worktree (git worktree add) dans un dossier temporaire 2. Checkout une nouvelle branche depuis votre HEAD actuel 3. Exécute l’agent dans le worktree — toutes les modifications de fichiers sont isolées 4. Présente une revue de diff une fois terminé — vous choisissez les modifications à fusionner en retour

Cela signifie que plusieurs threads Worktree peuvent s’exécuter simultanément sur le même repo sans conflit. Chacun reçoit sa propre branche et son propre dossier de travail.

Automations

Les automations s’exécutent localement dans l’app ; l’app doit donc être lancée et le projet disponible sur le disque :

• Dans les repos Git, les automations utilisent des worktrees d’arrière-plan dédiés (isolés de votre dossier de travail)
• Dans les projets non Git, les exécutions se font directement dans le dossier du projet
• Les automations utilisent vos paramètres de sandbox par défaut

Configurer une automation : 1. Ouvrez un projet dans l’app de bureau 2. Cliquez sur l’onglet Automations dans la barre latérale 3. Définissez un déclencheur (planification, webhook ou manuel) 4. Rédigez le prompt et sélectionnez le mode d’exécution (local ou worktree) 5. Définissez le niveau de raisonnement pour l’exécution de l’automation (App v26.312)⁷² 6. Les automations s’exécutent selon la planification et mettent les résultats en file d’attente pour revue

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

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

Prise en charge de Windows

Codex Desktop App a été lancée sur Windows le 4 mars 2026 (App v26.304) avec la prise en charge native de PowerShell, un sandbox Windows natif et une parité fonctionnelle complète, y compris les skills, automations et worktrees, sans nécessiter WSL.⁶⁶

Action GitHub et CI/CD

L’Action GitHub officielle intègre Codex à 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, le texte de réponse final 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 TypeScript SDK 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 de SDK

• runStreamed(...) : flux d’événements asynchrone pour les mises à jour intermédiaires
• Auth Python SDK (v0.132.0+) : la connexion par clé API, les flux ChatGPT dans le navigateur ou par code d’appareil, l’inspection du compte et la déconnexion sont des chemins SDK de premier ordre.⁹⁷
• Tour en texte seul simplifié (v0.132.0+) : les APIs de tour Python acceptent les chaînes simples et renvoient des métadonnées TurnResult plus riches, avec éléments collectés, minutage et utilisation.⁹⁷
• outputSchema : impose une sortie finale structurée selon JSON
• Entrée multimodale : transmettez du texte + des images locales ({ type: "local_image", path: "..." })
• Workflows d’image (v0.117.0) : view_image renvoie des URL, les images générées peuvent être rouvertes et l’historique des images survit à la reprise de session⁷⁵
• view_image multi-environnement (v0.130.0) : pour les sessions qui couvrent plusieurs environnements (introduites dans la v0.124.0 avec sélection de l’environnement et du dossier de travail à chaque tour, puis affinées dans la v0.125.0 avec des environnements persistants), view_image résout désormais les chemins de fichiers via l’environnement sélectionné plutôt que via le système de fichiers local de l’orchestrateur. Une image jointe depuis un environnement distant est récupérée relativement au dossier de travail de cet environnement, et non à l’hôte qui exécute le SDK.⁹¹

Configuration des threads 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.5" },
});

Les sessions persistent dans ~/.codex/sessions.

Runtime : Node.js 18+.

Optimisation des performances

Gestion du contexte

Les fenêtres de contexte varient selon le modèle. En avril 2026 : GPT-5.5 dans Codex offre 400K (1M dans le API). GPT-5.4 / GPT-5.4-mini offrent respectivement 1M / 400K (équivalent API dans Codex). La famille GPT-5.3-Codex / GPT-5.2-Codex fonctionne avec un budget de 272K en entrée + 128K en sortie (400K au total). Toutes se remplissent plus vite que vous ne l’imaginez — 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 une documentation locale : un AGENTS.md de qualité et une documentation locale réduisent le coût d’exploration (qui consomme du contexte)
3. Utilisez @ pour joindre des fichiers précis : référencez directement les fichiers au lieu de demander à Codex de les trouver
4. Gardez les prompts ciblés : les prompts cadrés avec des fichiers exacts consomment moins de contexte qu’une exploration ouverte

Efficacité des tokens

Optimisation de la vitesse

1. gpt-5.3-codex-spark : variante à latence réduite pour le binômage interactif
2. --profile fast : modèle mini préconfiguré avec faible raisonnement
3. Exécution parallèle des outils : Codex exécute simultanément les lectures et vérifications indépendantes ; structurez donc vos prompts pour le permettre
4. Boucles orientées résultat : demandez « implémenter, tester, corriger, arrêter quand c’est vert » plutôt que de donner des instructions étape par étape

Comment déboguer les problèmes ?

Problèmes courants et solutions

Référence des messages d’erreur

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 TUI en 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 TUI ci-dessus.

Réinstallation propre

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

Mode debug

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

Signaler des problèmes

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

Ou ouvrez une issue sur github.com/openai/codex/issues.¹

Codex Security [PREVIEW]

Codex Security est entré en research preview le 6 mars 2026, apportant une revue de sécurité applicative sensible au contexte à la stack Codex.⁷⁷ Disponible pour les clients ChatGPT Pro, Enterprise, Business et Edu via Codex web.

Fonctionnement : Codex Security analyse les dépôts pour construire un modèle de menace propre au projet, identifie les vulnérabilités classées selon leur impact réel et met les résultats à l’épreuve dans un environnement sandboxé afin de les valider. L’agent fait remonter des constats à plus haute confiance avec des correctifs, ce qui réduit le bruit des bugs insignifiants.

Performance : pendant la research preview, Codex Security a analysé 1,2 million de commits et identifié 10 561 vulnérabilités de gravité élevée. La précision s’est améliorée au fil du temps — avec une réduction du bruit de 84 %, une baisse de plus de 90 % des gravités surévaluées et une division par deux des taux de faux positifs. Le système a trouvé de vraies vulnérabilités dans OpenSSH, GnuTLS et Chromium, avec 14 CVE assignées.⁷⁷

Remarque : Codex Security est distinct du modèle de sécurité sandbox intégré au CLI. Le sandbox protège votre machine contre Codex ; Codex Security protège votre codebase contre les vulnérabilités.

Déploiement en entreprise

Contrôles administrateur (requirements.toml)

Les administrateurs appliquent la politique d’entreprise via requirements.toml, un fichier de configuration imposé par l’administration qui encadre les paramètres sensibles pour la sécurité que les utilisateurs ne peuvent pas remplacer :²¹

# /etc/codex/requirements.toml

# Restrict which approval policies users can select
allowed_approval_policies = ["untrusted", "on-request", "never"]

# Limit available sandbox modes
allowed_sandbox_modes = ["read-only", "workspace-write"]

# Control web search capabilities
allowed_web_search_modes = ["cached"]

# Allowlist MCP servers by identity (both name and identity must match)
[mcp_servers.approved-server]
identity = { command = "npx approved-mcp-server" }

# Admin-enforced command restrictions
[[rules.prefix_rules]]
pattern = [{ token = "rm" }, { any_of = ["-rf", "-fr"] }]
decision = "forbidden"
justification = "Recursive force-delete is prohibited by IT policy"

[[rules.prefix_rules]]
pattern = [{ token = "sudo" }]
decision = "prompt"
justification = "Elevated commands require explicit approval"

Contrairement au config.toml de niveau utilisateur, qui définit des préférences, requirements.toml est une couche de contraintes stricte qui limite les valeurs que les utilisateurs peuvent sélectionner, et ceux-ci ne peuvent pas la remplacer. Les règles d’exigences administrateur peuvent uniquement demander confirmation ou interdire (jamais autoriser silencieusement).

Configuration MDM macOS

Distribuez via MDM en utilisant le domaine de préférences com.openai.codex.²¹ Codex respecte les payloads MDM macOS standard (Jamf Pro, Fleet, Kandji, etc.). Encodez TOML en base64 sans retour à la ligne :

Priorité (de la plus élevée à la plus basse) :

1. Préférences gérées macOS (MDM)
2. Exigences récupérées depuis le cloud (ChatGPT Business / Enterprise)
3. /etc/codex/requirements.toml (système de fichiers local)

Les exigences cloud ne renseignent que les champs d’exigences non définis ; les couches gérées de priorité supérieure l’emportent donc toujours. Les exigences cloud fonctionnent en best-effort : si la récupération échoue ou expire, Codex continue sans la couche cloud.

Intégration OpenTelemetry

Codex prend en charge la propagation du contexte de trace OpenTelemetry depuis les variables d’environnement OTel standard jusqu’aux appels OpenAI API. Définissez les variables d’environnement standard avant de lancer Codex :

# Point Codex at your OTel collector
export OTEL_EXPORTER_OTLP_ENDPOINT="https://otel-collector.internal:4318"
export OTEL_SERVICE_NAME="codex-cli"
export OTEL_RESOURCE_ATTRIBUTES="team=platform,env=production"

# Launch Codex — trace context propagates to all OpenAI API calls
codex

• Les variables d’environnement standard OTEL_* sont respectées (endpoint, nom du service, attributs de ressource)
• Le contexte de trace se propage via Codex jusqu’aux appels API, ce qui permet une observabilité de bout en bout
• Utilisez les attributs de ressource pour baliser les traces par équipe, environnement ou projet
• Gardez les exigences de confidentialité à l’esprit lorsque vous activez la journalisation des prompts/outils : les traces peuvent contenir des extraits de code
• Métadonnées de trace OpenTelemetry configurables (v0.130.0+). Au-delà de l’enveloppe standard OTEL_RESOURCE_ATTRIBUTES, la crate codex-otel expose désormais des métadonnées de trace configurables afin que les administrateurs puissent baliser les traces avec des dimensions propres à l’organisation (centre de coûts, ID de projet, référence de ticket) sans reconstruire OTEL_RESOURCE_ATTRIBUTES à partir de zéro à chaque invocation. Associez cela aux analyses enrichies de review/feedback livrées dans la même version pour un débogage et un triage unifiés sur les sessions CLI, app-server et remote-control.⁹¹

Accès en entreprise

• ChatGPT Business / Enterprise / Edu : accès contrôlé par l’administrateur de l’organisation, avec application automatique des exigences récupérées depuis le cloud. Prend en charge le SSO via SAML/OIDC par l’intermédiaire de votre fournisseur d’identité (Okta, Entra ID, etc.)
• API : authentification, facturation et contrôles d’organisation/projet API standard. OpenAI publie des rapports SOC 2 Type II et SOC 3 ; un BAA HIPAA est disponible pour l’offre Enterprise
• Codex SDK : intégration dans les outils et workflows internes
• Application des politiques à grande échelle : utilisez requirements_toml_base64 distribué par MDM ou /etc/codex/requirements.toml au niveau du système de fichiers

Gestion des données et conformité : - Les entrées/sorties API ne sont pas utilisées pour l’entraînement dans le cadre des conditions Business/Enterprise/API d’OpenAI - Pour la résidence des données, le trafic OpenAI API passe par défaut par une infrastructure basée aux États-Unis ; pour les exigences de résidence des données dans l’UE, consultez l’équipe commerciale Enterprise d’OpenAI - Les transcriptions de session sont stockées localement ; seuls les appels API quittent la machine - ChatGPT Enterprise prend en charge des cadres de conformité, notamment SOC 2, GDPR et CCPA

Stratégie de déploiement

Déploiement progressif recommandé pour les organisations :

1. Pilote (semaines 1-2) : déployez auprès de 3 à 5 ingénieurs senior avec requirements.toml imposant le mode sandbox untrusted et la recherche web cached. Recueillez les retours sur les modèles AGENTS.md et les besoins en serveurs MCP.
2. Extension à l’équipe (semaines 3-4) : déployez à toute l’équipe. Distribuez le config.toml standard de l’équipe via MDM ou le repo. Activez le sandbox workspace-write pour les dépôts de confiance.
3. Intégration CI (semaines 5-6) : ajoutez codex-action aux pipelines CI/CD pour automatiser la review de PR et la génération de tests. Utilisez --ephemeral pour garder les coûts prévisibles.
4. À l’échelle de l’organisation (mois 2+) : déployez via MDM avec requirements.toml imposant les serveurs MCP approuvés, les politiques de sandbox et les allowlists de modèles.

Modèles d’audit

Suivez l’utilisation de Codex et appliquez la conformité :

• Traces OpenTelemetry : surveillez le volume d’appels API, l’utilisation des tokens et la latence par équipe
• Persistance des sessions : auditez ~/.codex/sessions/ pour les reviews de conformité (désactivez avec --ephemeral dans les contextes sensibles)
• Application de l’identité MCP : requirements.toml journalise les tentatives de serveurs bloquées — examinez-les pour détecter les usages d’outils non autorisés
• Piste d’audit Git : toutes les modifications de fichiers par Codex passent par le git standard — examinez-les via l’historique des branches et les diffs de PR

Bonnes pratiques et anti-patterns

Modèles de prompting

1. Prompts guidés par les contraintes : commencez par les limites. « Ne modifiez PAS les contrats API. Refactorisez uniquement 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écutez le lint + la plus petite suite de tests pertinente. Indiquez les commandes et les résultats. »
4. Références de fichiers : utilisez @filename pour joindre des fichiers spécifiques au contexte
5. Boucles guidées par le résultat : « Implémentez, lancez les tests, corrigez les échecs, arrêtez-vous uniquement quand tous les tests passent. » Codex itère jusqu’à la fin

Philosophie de test

La communauté converge vers une collaboration avec l’AI pilotée par les tests :²²

• Définir les tests en amont comme signaux d’achèvement
• Laisser Codex itérer jusqu’à ce que les tests passent (rouge → vert → refactorisation)
• Adopter les modèles de programmation Tiger Style
• Fournir le texte exact du fichier lorsque vous demandez des patches. Codex utilise une correspondance stricte, pas un patching approximatif basé sur l’AST

Bonnes pratiques de gestion du contexte

• Fournir une documentation locale de qualité plutôt que de dépendre de la recherche web
• Maintenir un markdown structuré avec des tables des matières et des fichiers de progression (« progressive disclosure »)
• Normaliser les fins de ligne (LF vs CRLF) dans les fichiers suivis pour éviter les échecs de patch
• Garder AGENTS.md concis, car les longues instructions sont repoussées hors du contexte

Workflow Git

• Créer toujours une nouvelle branche avant d’exécuter Codex sur des repos inconnus
• Utiliser des workflows basés sur des patches (git diff / git apply) plutôt que des modifications directes
• Examiner les suggestions de Codex comme des PRs en revue de code
• Utiliser /diff pour vérifier les modifications avant de commit

Skills et prompts communautaires

Le repository feiskyer/codex-settings fournit des configurations maintenues par la communauté :²³

Prompts réutilisables (dans ~/.codex/prompts/) : - deep-reflector : extraire les enseignements 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] : workflows de revue de code - ui-engineer [requirements] : développement frontend de qualité production

Skills communautaires : - claude-skill : transférer 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

Anti-patterns

Erreurs courantes qui gaspillent des tokens, produisent de mauvais résultats ou créent des workflows frustrants.

Anti-patterns de coût

Anti-patterns de contexte

Anti-patterns de workflow

Anti-patterns de prompt

Recettes de workflow

Modèles de bout en bout pour les scénarios de développement courants.

Recette 1 : configuration d’un nouveau projet

mkdir my-app && cd my-app && git init
codex

> Create a FastAPI project with: main.py, requirements.txt, Dockerfile,
  basic health endpoint, and a README. Use async throughout.

> /init

Passez en revue le AGENTS.md généré, modifiez-le pour l’adapter à vos conventions, puis :

> Run the health endpoint test and confirm it passes

Recette 2 : flux de développement quotidien

cd ~/project && git checkout -b feature/user-auth
codex

> @src/models/user.py @src/api/auth.py
  Add password reset functionality. Requirements:
  1. POST /api/auth/reset-request (email → sends token)
  2. POST /api/auth/reset-confirm (token + new password)
  3. Tests for both endpoints
  Run tests when done.

Passez en revue avec /diff, puis commit.

Recette 3 : refactorisation complexe avec Plan Mode

codex

> /plan Migrate the database layer from raw SQL to SQLAlchemy ORM.
  Constraints: don't change any API contracts, keep all existing tests passing.

Passez le plan en revue. Approuvez ou orientez :

[Tab] Also add a migration script using Alembic

Après l’exécution par Codex, vérifiez :

> Run the full test suite and report results
> /diff

Recette 4 : revue de PR avec codex exec

codex exec --model gpt-5.1-codex-mini \
  "Review the changes in this branch against main. \
   Flag security issues, missed edge cases, and style violations. \
   Format as a markdown checklist." \
  -o review.md

Recette 5 : debugging avec Cloud Tasks [EXPERIMENTAL]

codex cloud exec --env my-env "Diagnose why the /api/orders endpoint returns 500 \
  for orders with > 100 line items. Check the serializer, database query, \
  and pagination logic. Propose a fix with tests."

Vérifiez la progression plus tard :

codex cloud status <TASK_ID>
codex cloud diff <TASK_ID>

Appliquez la correction localement une fois terminée :

codex apply <TASK_ID>

Guide de migration

Depuis Claude Code

Différences clés à comprendre :

• La sandbox est au niveau de l’OS : Codex utilise Seatbelt/Landlock, pas des conteneurs. Les restrictions s’appliquent au niveau du noyau, sous la couche applicative.
• Les hooks se développent : Codex prend désormais en charge 5 événements de hooks : SessionStart, Stop et UserPromptSubmit (v0.114.0–v0.116.0, expérimental), ainsi que AfterAgent (v0.99.0) et AfterToolUse (v0.100.0). Le système couvre le cycle de vie des sessions, l’interception des prompts et l’automatisation au niveau des outils, même si les 12+ événements de cycle de vie de Claude Code offrent encore une couverture plus large. Pour les schémas d’automatisation pas encore couverts, utilisez les instructions AGENTS.md ou les skills.
• Sub-agents v2 (v0.117.0) : les sub-agents utilisent maintenant des adresses basées sur des chemins (par exemple, /root/agent_a), avec une messagerie inter-agents structurée et une liste des agents.⁷⁵ Cela étend le mécanisme existant (6 concurrents max., contre 12 dans la v0.91.0). Les rôles multi-agents restent personnalisables via la configuration (v0.104.0+).⁴⁷ La v0.105.0 a ajouté spawn_agents_on_csv pour répartir le travail sur des lignes, avec suivi de progression et ETA.⁶¹ Codex ne dispose toujours pas de l’UX explicite de l’outil Task de Claude Code pour la délégation pilotée par l’utilisateur : utilisez les tâches cloud ou l’orchestration SDK pour les schémas de délégation.
• AGENTS.md est multi-outils : votre AGENTS.md fonctionne dans Cursor, Copilot, Amp, Jules, Gemini CLI et plus de 60 000 projets open source. CLAUDE.md est propre à Claude.
• Les profils remplacent le basculement manuel : au lieu de modifier les flags à chaque exécution, définissez des profils dans config.toml.

Depuis GitHub Copilot

Ce que vous gagnez : - Sandbox au niveau de l’OS (Seatbelt/Landlock — appliquée par le noyau plutôt que basée sur des conteneurs) - Délégation de tâches cloud avec codex apply - Profils de configuration pour changer de workflow - Application desktop avec isolation par worktree

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                   ║
║  --ask-for-approval <p>     Approval policy                   ║
║  --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   /goal        Persisted goal      ║
║  /vim          Modal Vim     /hooks       Browse/toggle hooks ║
║  /init         AGENTS.md scaffold                             ║
║  /mcp          MCP tools     /skills      Invoke skills       ║
║  /ps           Background    /personality Style               ║
║  /permissions  Approval mode /statusline  Footer config       ║
║  /fast         Toggle fast mode (default: on)                ║
║  /copy         Copy last response to clipboard                ║
║  /clear        Clear screen  /theme       Syntax highlighting ║
║                                                               ║
║  TUI SHORTCUTS                                                ║
║  @              Fuzzy file search                             ║
║  !command       Run shell command                             ║
║  Ctrl+G         External editor                               ║
║  Ctrl+L         Clear screen                                  ║
║  Enter          Inject instructions (while running)           ║
║  Esc Esc        Edit previous messages                        ║
║                                                               ║
║  EXEC MODE (CI/CD)                                            ║
║  codex exec --sandbox workspace-write "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               ║
║                                                               ║
║  PLUGINS                                                      ║
║  codex plugin marketplace add <src>     Add marketplace       ║
║  codex plugin marketplace upgrade       Upgrade marketplaces  ║
║                                                               ║
║  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             ║
║  requirements.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-request    Prompt for boundary violations                 ║
║  never         No prompts                                     ║
║                                                               ║
║  MODELS (April 2026)                                          ║
║  gpt-5.5               Recommended default (400K in Codex)   ║
║  gpt-5.5-pro           Highest-effort GPT-5.5 tier            ║
║  gpt-5.4               Prior flagship / fallback              ║
║  gpt-5.4-mini          Subagent work, 2x faster (400K)        ║
║  gpt-5.3-codex         Legacy coding specialist               ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Journal des modifications

Références

Note sur les URL du blog OpenAI : les références ¹⁶, ²⁵–³⁰, ³³, ⁶⁴, ⁶⁶, ⁶⁷, ⁷⁶ et ⁷⁷ pointent vers des articles de blog openai.com/index/ qui renvoient HTTP 403 aux accès automatisés en raison de la protection anti-bot Cloudflare. Ces URL sont valides lorsqu’elles sont consultées depuis un navigateur web standard.