Guide complet OpenAI Codex CLI 2026 : De l'installation à la configuration production-ready, votre assistant IA de programmation dans le terminal

OpenAI Codex CLI est l’assistant IA de programmation en ligne de commande lancé par OpenAI mi-2025. Il intègre directement la puissance de génération de code dans l’environnement terminal. En tant que produit phare rivalisant avec Anthropic Claude Code, Codex CLI s’est rapidement imposé comme un outil incontournable de la boîte à outils des développeurs en 2026, grâce à son approche open source et gratuite, son modèle de sécurité sandbox, son intégration du protocole MCP et son système de configuration Profile flexible.

Qu’est-ce que Codex CLI ?

Bien plus qu’un “ChatGPT dans le terminal”

Beaucoup de développeurs découvrant Codex CLI le réduisent à tort à un simple “ChatGPT qui tourne dans le terminal”. Cette vision sous-estime considérablement la profondeur de sa conception. Codex CLI est un véritable agent de code interactif (Code Agent) capable non seulement de comprendre les instructions en langage naturel, mais aussi de :

• Lire le contexte du projet : Analyser automatiquement la structure des fichiers, les dépendances et le style de code du répertoire courant
• Exécuter des tâches multi-étapes : Former un flux de travail complet, de l’analyse des besoins à l’implémentation du code en passant par la validation par tests
• Isolation sandbox sécurisée : Garantir que les opérations de l’IA ne détruisent pas le système grâce à trois niveaux de sandbox et quatre stratégies d’approbation
• Persistance des sessions : Prendre en charge la récupération de session, le fork expérimental et le traçage historique pour éviter toute perte de progression

Architecture centrale

Codex CLI est développé en Rust avec une architecture modulaire :

codex-cli/
├── core/          # Moteur central : appels modèle, gestion du contexte
├── sandbox/       # Couche sandbox : isolation système de fichiers, restrictions d'exécution de commandes
├── mcp/           # Intégration protocole MCP : connexion aux outils externes
├── config/        # Système de configuration : gestion Profile, résolution d'alias
└── ui/            # Interface interactive : TUI, analyseur de commandes slash

Cette conception permet à Codex CLI de rester léger tout en offrant une sécurité et une extensibilité de niveau entreprise. Par rapport aux plugins IDE traditionnels, ses avantages sont :

• Aucune dépendance à l’éditeur : Que vous utilisiez Vim, Emacs ou VS Code, l’intégration dans le terminal est transparente
• Compatible avec les environnements distants : Fonctionne parfaitement sur des serveurs connectés via SSH ou dans des conteneurs Docker
• Faible empreinte mémoire : Le binaire écrit en Rust démarre rapidement et consomme beaucoup moins de mémoire que les applications Electron

Installation et configuration de base

Quatre méthodes d’installation

1. Installation via npm (recommandée pour la plupart des utilisateurs)

npm install -g @openai/codex

C’est la méthode la plus universelle, compatible avec macOS, Linux et Windows (WSL2). Après l’installation, exécutez codex --version pour vérifier que tout fonctionne.

2. Installation via Homebrew (idéale pour les utilisateurs macOS)

brew install --cask codex

L’avantage de Homebrew réside dans la gestion automatique des dépendances et de la configuration PATH. Pour mettre à jour, il suffit d’exécuter brew upgrade codex.

3. Téléchargement du binaire

Rendez-vous sur GitHub Releases pour télécharger le binaire précompilé correspondant à votre plateforme :

• macOS Apple Silicon : codex-macos-arm64
• macOS Intel : codex-macos-x86_64
• Linux x86_64 : codex-linux-x86_64
• Linux ARM64 : codex-linux-arm64
• Windows : codex-windows-x86_64.exe

Après téléchargement, attribuez les permissions d’exécution et déplacez le fichier dans un répertoire du PATH :

chmod +x codex-linux-x86_64
sudo mv codex-linux-x86_64 /usr/local/bin/codex

4. Installation WSL2 (pour les utilisateurs Windows)

Le support natif Windows étant encore en cours d’amélioration, il est recommandé d’installer via WSL2 (Windows Subsystem for Linux) :

# Dans Ubuntu WSL2
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
npm install -g @openai/codex

Méthodes d’authentification : Abonnement ChatGPT vs Clé API

Codex CLI prend en charge deux méthodes d’authentification, chacune adaptée à des scénarios différents :

Connexion par abonnement ChatGPT (idéal pour les particuliers)

Si vous disposez d’un abonnement ChatGPT Plus, Pro, Team, Edu ou Enterprise, vous pouvez vous connecter directement via le navigateur :

codex login

Cela ouvre votre navigateur par défaut. Après avoir terminé l’autorisation OAuth, le jeton est automatiquement sauvegardé. Avantages pour les abonnés :

• Utilisateurs Plus : 5 $ de crédit API gratuit par mois (glissant sur 30 jours)
• Utilisateurs Pro : 50 $ de crédit API gratuit par mois (glissant sur 30 jours)

Au-delà de ces limites, la facturation suit les tarifs standard de l’API OpenAI.

Variable d’environnement Clé API (idéal pour les équipes et l’automatisation)

Pour le travail collaboratif ou l’intégration CI/CD, il est recommandé d’utiliser une clé API :

export OPENAI_API_KEY="sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx"

Ajoutez cette ligne à ~/.bashrc ou ~/.zshrc pour une persistance permanente. Vous pouvez créer et gérer vos clés API sur OpenAI Platform.

Conseil de sécurité : Ne codez jamais en dur votre clé API dans les dépôts de code. Privilégiez les fichiers .env ou les services de gestion de secrets.

Prérequis système et vérifications

Avant l’installation, assurez-vous que votre système répond aux exigences suivantes :

Composant	Version minimale	Version recommandée
Node.js	18.x	20.x LTS
npm	9.x	10.x
Git	2.x	2.40+
Système d’exploitation	macOS 12+/Ubuntu 20.04+/WSL2	Dernière version stable

Exécutez les commandes suivantes pour vérifier les prérequis :

node --version   # Doit afficher v18.x ou supérieur
npm --version    # Doit afficher 9.x ou supérieur
git --version    # Doit afficher git version 2.x

Si votre version de Node.js est trop ancienne, rendez-vous sur le site officiel Node.js pour télécharger la dernière version LTS.

Les trois modes d’opération détaillés

Codex CLI propose trois modes d’opération, correspondant à différents niveaux d’automatisation et de sécurité :

Mode suggest (le plus sûr)

codex --mode suggest

En mode suggest, Codex se contente de fournir des suggestions de code et des explications, sans modifier automatiquement aucun fichier. Vous devez copier manuellement le code suggéré et l’appliquer à votre projet.

Scénarios d’utilisation :

• Apprentissage d’un nouveau framework, lorsque vous souhaitez comprendre chaque étape
• Revue de modifications de code sensibles nécessitant une confirmation humaine
• Première utilisation de Codex pour se familiariser avec son style de sortie

Exemple :

$ codex --mode suggest
> Crée un composant React Todo

[CODEx] Je suggère la structure de fichiers suivante :
- src/components/TodoList.jsx
- src/components/TodoItem.jsx
- src/hooks/useTodos.js

Voici le contenu de TodoList.jsx :
[bloc de code...]

Vous pouvez créer ces fichiers manuellement, ou passer en mode auto-edit pour me laisser les écrire automatiquement.

Mode auto-edit (équilibre)

codex --mode auto-edit

auto-edit est le mode par défaut. Codex modifie automatiquement les fichiers, mais demande confirmation avant d’exécuter des commandes pouvant avoir des effets secondaires (comme rm ou git push).

Scénarios d’utilisation :

• Flux de travail de développement quotidien
• Itération rapide du code par l’IA tout en conservant le contrôle des opérations critiques
• Refactoring de projets de complexité moyenne

Exemple :

[CODEx] Je vais créer src/components/TodoList.jsx... ✓
[CODEx] Je vais créer src/components/TodoItem.jsx... ✓
[CODEx] Je dois exécuter npm install react-icons, continuer ? [Y/n]

Mode full-auto (le plus rapide)

codex --mode full-auto

En mode full-auto, Codex exécute toutes les opérations automatiquement, y compris les modifications de fichiers et l’exécution de commandes, sans aucune confirmation. C’est le mode le plus efficace, mais aussi le plus risqué.

Scénarios d’utilisation :

• Environnements de développement isolés (comme les conteneurs Docker)
• Lorsque vous faites entièrement confiance au jugement de Codex et recherchez une efficacité maximale
• Tâches de génération de code en lot

Avertissement : Avant d’utiliser full-auto en environnement de production, configurez impérativement le mode sandbox pour limiter ses permissions.

Analyse approfondie du modèle de sécurité sandbox ⭐ Point différenciant majeur

La sandbox est le mécanisme de sécurité central de Codex CLI. Elle isole le système de fichiers et restreint les permissions d’exécution de commandes pour empêcher l’IA de causer des dommages au système par erreur ou malveillance. Comprendre le modèle sandbox est essentiel pour une utilisation production-ready de Codex.

Comparaison des trois modes sandbox

Codex propose trois niveaux de sandbox, spécifiés via le paramètre --sandbox :

Mode	Permissions système de fichiers	Exécution de commandes	Scénarios d’utilisation
read-only	Lecture seule, aucune écriture autorisée	Commandes en lecture seule uniquement (ls, cat, grep)	Revue de code, analyse de documentation
workspace-write	Écriture autorisée uniquement dans le répertoire du projet courant	Commandes normales autorisées, opérations système interdites	Développement quotidien (recommandé)
danger-full-access	Permissions complètes en lecture/écriture	Toutes les commandes autorisées	Environnements isolés, tâches expérimentales

Mode par défaut : workspace-write, offrant un équilibre entre sécurité et praticité.

Mode read-only en pratique

codex --sandbox read-only
> Analyse l'architecture de ce projet

[CODEx] Je lis la structure du répertoire src/...
[CODEx] Modules détectés :
- auth/ (authentification)
- api/ (API REST)
- components/ (composants UI)

Étant en mode read-only, je ne peux pas modifier les fichiers. Pour refactorer, passez en mode workspace-write.

Mode workspace-write (recommandé)

codex --sandbox workspace-write
> Refactorise le module auth, ajoute les refresh tokens JWT

[CODEx] Je modifie src/auth/token.js... ✓
[CODEx] Je crée src/auth/refresh.js... ✓
[CODEx] J'exécute les tests pour valider les changements... ✓

Dans ce mode, Codex ne peut modifier que les fichiers du répertoire de travail courant et de ses sous-répertoires. Il ne peut pas accéder aux répertoires système comme /etc ou /usr.

Mode danger-full-access (à utiliser avec prudence)

codex --sandbox danger-full-access
> Nettoie tous les répertoires node_modules

[CODEx] Attention : cette opération supprimera plusieurs répertoires, confirmer ? [Y/n]

À utiliser uniquement dans les scénarios suivants :

• Environnements temporaires dans des conteneurs Docker
• Machines virtuelles sandbox dédiées
• Lorsque vous faites entièrement confiance à Codex et avez sauvegardé vos données importantes

Granularité à quatre niveaux des stratégies d’approbation

Outre les modes sandbox, Codex offre des stratégies d’approbation de commandes fines, contrôlées via le paramètre --ask-for-approval :

Stratégie	Comportement	Scénarios d’utilisation
untrusted	Approbation requise uniquement pour les commandes non fiables (par défaut)	Développement quotidien
on-failure	Approbation demandée uniquement en cas d’échec de commande	Scénarios de débogage
on-request	Approbation uniquement lorsque Codex la demande explicitement	Confiance élevée en l’IA
never	Aucune demande d’approbation	Utilisé conjointement avec la sandbox

Définition des commandes non fiables :

• Opérations réseau (curl, wget)
• Gestion de paquets (npm install, pip install)
• Contrôle de version (git push, git reset --hard)
• Configuration système (sudo, chmod)

Exemples de combinaisons

# Combinaison la plus sûre : sandbox lecture seule + approbation stricte
codex --sandbox read-only --ask-for-approval untrusted

# Combinaison efficace : écriture workspace + approbation en cas d'échec
codex --sandbox workspace-write --ask-for-approval on-failure

# Combinaison fully automatic : sandbox dangereuse + jamais d'approbation (environnements isolés uniquement)
codex --sandbox danger-full-access --ask-for-approval never

Différence fondamentale entre —full-auto et —yolo

De nombreux utilisateurs confondent --mode full-auto et --yolo. Ces paramètres agissent à des niveaux différents :

• --mode full-auto : Contrôle si Codex nécessite une confirmation utilisateur pour les modifications de code
• --yolo : Ignore toutes les invites d’approbation pour l’exécution de commandes (équivalent à --ask-for-approval never)

# Les deux commandes suivantes ont le même effet
codex --mode full-auto --yolo
codex --mode full-auto --ask-for-approval never

Origine du nom : “Yolo” vient de l’expression populaire “You Only Live Once”, souvent utilisée dans la communauté technique pour signifier “exécuter sans se soucier des conséquences”. OpenAI utilise ce nom humoristique pour rappeler aux utilisateurs : ce mode comporte des risques, utilisez-le avec prudence.

Meilleures pratiques de sécurité en environnement de production

Pour utiliser Codex CLI en environnement de production, suivez ces recommandations de sécurité :

1. Utilisez par défaut la sandbox workspace-write : Limitez l’IA aux modifications des fichiers du projet courant
2. Activez l’intégration Git : Chaque modification de l’IA est automatiquement commitée pour faciliter le rollback
3. Revoyez régulièrement les Transcripts : Codex enregistre tous les logs d’interaction et d’opération
4. Exécutez manuellement les opérations sensibles : Ne confiez pas à l’IA les migrations de base de données ou les déploiements en production
5. Utilisez les Profiles pour isoler les environnements : Configurez des stratégies de sécurité différentes pour chaque projet

# Exemple de configuration pour projet de production
codex --profile production --sandbox workspace-write --ask-for-approval untrusted

# Exemple de configuration pour projet expérimental
codex --profile experimental --sandbox danger-full-access --yolo

Les 24 commandes slash décryptées ⭐ Point différenciant majeur

Codex CLI propose 24 commandes slash (Slash Commands) couvrant le contrôle de session, le changement de modèle, la gestion des permissions, les opérations sur les fichiers et bien plus. Maîtriser ces commandes améliore considérablement votre productivité.

Contrôle de session (/new, /resume, /fork, /compact)

/new - Démarrer une nouvelle session

/new

Efface le contexte courant et démarre une conversation entièrement nouvelle. Idéal pour changer de tâche ou éliminer les interférences de l’historique.

/resume - Reprendre une session historique

/resume

Ouvre un sélecteur de session interactif listant toutes les sessions historiques, avec filtrage par date et répertoire. Voir le chapitre “Récupération de session” ci-dessous pour plus de détails.

/fork - Fork expérimental

/fork

Crée une copie de la session courante pour essayer différentes solutions dans une nouvelle branche, sans affecter la session principale. Utile pour :

• Comparer plusieurs approches d’implémentation
• Refactoring expérimental, facilement abandonnable en cas d’échec
• Exploration parallèle de différentes architectures

> /fork
[CODEx] Branche de session créée : fork-2026-06-07-14-30
> Essaie de remplacer Context API par Redux

[CODEx] Dans la branche, je vais refactorer la gestion d'état...

/compact - Compresser le contexte

/compact

Lorsque l’historique de session devient trop long et entraîne une explosion de la consommation de tokens, utilisez /compact pour compresser le contexte. Les informations clés sont conservées tandis que les conversations redondantes sont supprimées. Cela réduit efficacement le coût des appels ultérieurs.

Modèle et style (/model, /personality, /plan)

/model - Changer de modèle

/model gpt-5

Permet de changer de modèle à la volée. Les modèles disponibles incluent :

• gpt-5.3-codex (par défaut, optimisé pour le code)
• gpt-5 (modèle flagship généraliste)
• o4-mini (modèle de raisonnement léger, faible coût)

> /model o4-mini
[CODEx] Passage au modèle o4-mini. Ce modèle convient aux tâches simples, avec des capacités de raisonnement plus faibles mais un coût réduit.

/personality - Ajuster la personnalité de l’IA

/personality concise

Ajuste le style de réponse de Codex :

• concise : Concis et direct, peu d’explications
• verbose : Explications détaillées, idéal pour l’apprentissage
• professional : Ton formel, adapté à la génération de documentation
• friendly : Ton amical et détendu, pour les échanges quotidiens

/plan - Générer un plan d’exécution

/plan

Demande à Codex de produire d’abord un plan d’exécution détaillé avant de procéder étape par étape. Idéal pour les tâches complexes, permettant d’identifier les problèmes potentiels en amont.

> /plan
> Refactorise entièrement le module d'authentification, ajoute le support OAuth2

[CODEx] Plan d'exécution :
1. Analyser la structure actuelle du répertoire auth/
2. Concevoir le flux OAuth2 (Authorization Code Grant)
3. Créer le sous-module oauth2/
4. Modifier l'endpoint de login pour compatibilité mot de passe traditionnel et OAuth2
5. Mettre à jour les cas de test
6. Générer la documentation de migration

Commencer l'exécution ? [Y/n]

Permissions et état (/permissions, /status, /debug-config)

/permissions - Voir les permissions courantes

/permissions

Affiche la configuration actuelle du mode sandbox et de la stratégie d’approbation.

> /permissions
[CODEx] Configuration des permissions actuelles :
- Sandbox : workspace-write
- Politique d'approbation : untrusted
- Mode Yolo : désactivé

/status - Voir l’état de la session

/status

Affiche les détails de la session courante, incluant :

• Le modèle utilisé et le niveau de raisonnement
• Les statistiques d’utilisation des tokens
• La durée de la session
• Le nombre d’opérations exécutées

> /status
[CODEx] État de la session :
- Modèle : gpt-5.3-codex (raisonnement : high)
- Tokens : 12 450 en entrée / 3 200 en sortie
- Durée : 45 minutes
- Opérations : 23 modifications de fichiers, 8 commandes exécutées

/debug-config - Diagnostiquer la chaîne de chargement de configuration

/debug-config

C’est l’outil ultime pour résoudre les problèmes de configuration. Il affiche comment Codex charge les fichiers de configuration, incluant :

• Le chemin de configuration globale (~/.codex/config.toml)
• Le chemin de configuration projet (.codex/config.toml)
• Les surcharges par variables d’environnement
• L’état d’activation du Profile
• Les valeurs de configuration finales effectives

> /debug-config
[CODEx] Chaîne de chargement de configuration :
1. Configuration globale : /home/user/.codex/config.toml ✓
2. Configuration projet : /path/to/project/.codex/config.toml ✓
3. Variables d'environnement : OPENAI_API_KEY définie ✓
4. Profile actif : production
5. Configuration finale :
   - model : gpt-5.3-codex
   - sandbox_mode : workspace-write
   - approval_policy : untrusted

Fichiers et outils (/mention, /diff, /review, /mcp)

/mention - Citer un fichier spécifique

/mention src/auth/token.js

Force Codex à se concentrer sur un fichier spécifique, même s’il n’est pas dans le contexte courant. Utile pour localiser des fichiers clés dans les grands projets.

/diff - Voir les différences de modifications

/diff

Affiche la comparaison des différences de tous les fichiers modifiés depuis le début de la session. Permet de vérifier que les modifications de l’IA correspondent à vos attentes.

/review - Revue de code

/review

Demande à Codex de revoir les modifications de code récentes, en identifiant les problèmes potentiels, les goulets d’étranglement de performance et les risques de sécurité.

> /review
[CODEx] Rapport de revue de code :
✓ Points forts :
  - Utilisation correcte de async/await pour gérer les opérations asynchrones
  - Gestion d'erreurs complète ajoutée

⚠ Suggestions d'amélioration :
  - token.js ligne 45 : Validation d'entrée manquante, risque d'injection
  - refresh.js ligne 12 : Flag HttpOnly non défini, risque XSS

🔴 Problèmes critiques :
  - Clé JWT codée en dur, devrait utiliser une variable d'environnement

/mcp - Gérer les serveurs MCP

/mcp list

Liste les serveurs Model Context Protocol (MCP) configurés. MCP permet à Codex de se connecter à des outils externes comme GitHub, les bases de données, les plateformes de monitoring, etc. Voir le chapitre “Intégration du protocole MCP” ci-dessous pour plus de détails.

Autres commandes utiles

Commande	Fonction
/init	Initialise la configuration du projet, crée .codex/config.toml
/feedback	Envoyer un feedback à OpenAI
/logout	Se déconnecter, effacer les jetons d’authentification
/quit	Quitter Codex CLI
/statusline	Personnaliser l’affichage de la barre d’état du terminal
/ps	Voir les tâches en arrière-plan
/apps	Gérer les applications intégrées

Récupération de session : Ne perdez plus jamais votre progression ⭐ Point différenciant majeur

La récupération de session est l’une des fonctionnalités les plus sous-estimées de Codex CLI. Avec les outils terminal traditionnels, fermer le terminal signifie perdre tout le contexte. Codex résout ce problème grâce au mécanisme Transcripts, permettant la persistance et la récupération flexible des sessions.

Quatre méthodes de récupération

1. Sélecteur interactif (recommandé)

codex resume

Ouvre une interface interactive listant toutes les sessions historiques, avec :

• Tri par date
• Filtrage par répertoire
• Recherche par mots-clés
• Aperçu du résumé de session

$ codex resume
Sélectionnez la session à reprendre :
  1. [2026-06-07 14:30] refactor auth module (12 ops)
  2. [2026-06-07 10:15] create React todo app (8 ops)
  3. [2026-06-06 16:45] debug API endpoint (5 ops)
> 1
[CODEx] Session restaurée : refactor auth module

2. Reprendre la dernière session

codex resume --last

Restaure rapidement la dernière session utilisée sans sélection interactive. Idéal pour reprendre le travail après une interruption.

3. Reprendre une session spécifique

codex resume <SESSION_ID>

Restaure précisément une session via son ID. L’ID de session se trouve dans la sortie de la commande /status ou dans le répertoire Transcripts.

codex resume sess_abc123def456

4. Reprendre toutes les sessions跨目录

codex resume --all

Liste les sessions historiques de tous les répertoires, utile pour basculer entre plusieurs projets.

Que conserve-t-on lors de la récupération ?

Lors de la récupération de session, Codex reconstruit l’état suivant :

• Historique des conversations : Tous les échanges Q/R précédents
• Contexte des fichiers : Liste des fichiers lus et modifiés
• Configuration du modèle : Modèle utilisé et niveau de raisonnement
• Permissions sandbox : Configuration de sécurité courante
• Tâches inachevées : Si une tâche multi-étapes était en cours, elle reprend au point d’interruption

Ce qui n’est pas conservé :

• Variables temporaires ou résultats intermédiaires non sauvegardés
• État d’exécution des commandes externes (comme les serveurs en cours d’exécution)

Cas d’usage pratiques

Scénario 1 : Reprendre après une interruption

# Matin : démarrage du refactoring du module d'authentification
$ codex
> Refactorise le module auth, ajoute les refresh tokens JWT
[CODEx] Analyse du code existant en cours...
# Réunion imprévue, Ctrl+C pour quitter

# Après-midi : reprise directe
$ codex resume --last
[CODEx] Bienvenue. Nous avions analysé auth/token.js. Je vais maintenant créer refresh.js...

Scénario 2 : Comparer plusieurs approches

# Session principale : utilisation de Context API
$ codex
> Implémente la gestion d'état
[CODEx] Je vais utiliser Context API...

# Fork expérimental : tentative avec Redux
> /fork
[CODEx] Branche créée. Tentative de l'approche Redux...

# Après comparaison, conservation de la session principale, abandon de la branche

Scénario 3 : Développement progressif de projets long terme

# Jour 1 : Mise en place de la structure du projet
$ codex
> Crée la structure du projet Next.js
[CODEx] Terminé...

# Jour 2 : Reprise de session, poursuite du développement
$ codex resume --last
[CODEx] Bon retour. Hier, nous avons créé la structure du projet. Aujourd'hui, implémentons les composants de page...

Configurations production-ready ⭐ Point différenciant majeur

Le système de configuration de Codex CLI est extrêmement flexible, supportant la configuration globale, la configuration projet et les Profiles multi-scénarios. Une configuration appropriée améliore considérablement la productivité et la sécurité.

Configuration d’alias : Une commande pour tous les paramètres de lancement

Pour les combinaisons de paramètres de lancement fréquemment utilisées, simplifiez les commandes via des alias shell :

# ~/.bashrc ou ~/.zshrc
alias codex-safe='codex --sandbox read-only --ask-for-approval untrusted'
alias codex-dev='codex --sandbox workspace-write --mode auto-edit'
alias codex-yolo='codex --sandbox danger-full-access --yolo'

Utilisation :

codex-safe   # Mode revue de sécurité
codex-dev    # Mode développement quotidien
codex-yolo   # Mode expérimental (prudence !)

Profiles multi-scénarios (solution plus élégante)

Les alias sont simples mais manquent de flexibilité. Le système Profile de Codex permet de définir plusieurs scénarios dans un fichier de configuration, activables en un clic via le paramètre --profile.

Structure des fichiers de configuration

Le fichier de configuration globale se trouve à ~/.codex/config.toml, et le fichier de configuration projet à .codex/config.toml.

# ~/.codex/config.toml

# Configuration par défaut
model = "gpt-5.3-codex"
model_reasoning_effort = "high"
web_search = "live"
sandbox_mode = "workspace-write"
approval_policy = "untrusted"

# Profile : Revue de code (lecture seule, approbation stricte)
[profiles.review]
sandbox_mode = "read-only"
approval_policy = "untrusted"
model_reasoning_effort = "medium"

# Profile : Prototypage rapide (modèle léger, faible coût)
[profiles.quick]
model = "o4-mini"
model_reasoning_effort = "low"
web_search = "disabled"
sandbox_mode = "workspace-write"

# Profile : Environnement de production (sécurité prioritaire)
[profiles.production]
sandbox_mode = "workspace-write"
approval_policy = "on-failure"
model = "gpt-5.3-codex"
model_reasoning_effort = "high"

# Profile : Environnement expérimental (fully automatic, haut risque)
[profiles.experimental]
sandbox_mode = "danger-full-access"
approval_policy = "never"
model = "gpt-5.3-codex"
model_reasoning_effort = "high"

Utilisation des Profiles

# Scénario revue de code
codex --profile review

# Scénario prototypage rapide
codex --profile quick

# Projet de production
codex --profile production

# Projet expérimental
codex --profile experimental

Surcharge de configuration au niveau projet

Créez .codex/config.toml à la racine du projet pour surcharger la configuration globale :

# my-project/.codex/config.toml

# Ce projet force l'utilisation de la sandbox lecture seule
sandbox_mode = "read-only"

# Ce projet désactive la recherche web
web_search = "disabled"

Priorité de chargement de configuration Codex : Configuration projet > Configuration Profile > Configuration globale > Valeurs par défaut.

debug-config pour diagnostiquer la chaîne de chargement de configuration

Lorsqu’une configuration ne s’applique pas comme prévu, utilisez la commande /debug-config pour diagnostiquer :

> /debug-config
[CODEx] Chaîne de chargement de configuration :
1. Configuration globale : /home/user/.codex/config.toml ✓
   - model : gpt-5.3-codex
   - sandbox_mode : workspace-write
2. Configuration projet : /path/to/project/.codex/config.toml ✓
   - sandbox_mode : read-only (surcharge la configuration globale)
3. Profile actif : review
   - approval_policy : untrusted
4. Variables d'environnement :
   - OPENAI_API_KEY : définie ✓
   - CODEX_MODEL : non définie
5. Configuration finale :
   - model : gpt-5.3-codex (de la configuration globale)
   - sandbox_mode : read-only (de la configuration projet, priorité supérieure)
   - approval_policy : untrusted (du Profile)

Cette sortie vous permet de voir clairement la source de chaque valeur de configuration, facilitant l’identification rapide des problèmes.

Changement de modèle et niveau de raisonnement

Modèle par défaut gpt-5.3-codex

Codex CLI utilise par défaut le modèle gpt-5.3-codex, une variante spécialement optimisée par OpenAI pour la génération de code, avec les caractéristiques suivantes :

• Compréhension du code puissante : Compréhension approfondie de multiples langages de programmation et frameworks
• Grande fenêtre de contexte : Supporte l’analyse de longs fichiers et de structures de projet complexes
• Efficacité de raisonnement élevée : Chemins de raisonnement optimisés pour les tâches de code

Changement de modèle à la volée

Changez de modèle via la commande /model ou la configuration :

# Passage au modèle flagship généraliste
/model gpt-5

# Passage au modèle léger
/model o4-mini

Scénarios d’utilisation de chaque modèle :

Modèle	Scénarios d’utilisation	Coût
gpt-5.3-codex	Génération de code complexe, refactoring, débogage	Élevé
gpt-5	Tâches générales, génération de documentation, conception d’architecture	Élevé
o4-mini	Tâches simples, prototypage rapide, scénarios à faible coût	Faible

Stratégie de sélection du niveau de raisonnement (high/medium/low)

Le niveau de raisonnement (Reasoning Effort) contrôle la profondeur de réflexion du modèle avant de générer une réponse :

Niveau	Comportement	Scénarios d’utilisation	Consommation de tokens
high	Analyse approfondie, raisonnement multi-étapes	Algorithmes complexes, conception d’architecture, bugs difficiles	Élevée
medium	Équilibre vitesse/qualité	Développement quotidien, refactoring standard	Moyenne
low	Réponse rapide, raisonnement superficiel	Tâches simples, correction syntaxique, génération de templates	Faible

Configuration dans le fichier :

model_reasoning_effort = "high"  # ou "medium", "low"

Changement à la volée :

> /reasoning high
[CODEx] Passage au niveau de raisonnement high. Les réponses suivantes seront plus approfondies.

Optimisation des coûts : Comment économiser la moitié de vos tokens en un mois

Une utilisation judicieuse des modèles et des niveaux de raisonnement réduit considérablement les coûts :

1. Tâches simples avec o4-mini + raisonnement low :

   codex --profile quick  # Utilise o4-mini + low

2. Tâches complexes uniquement avec gpt-5.3-codex + raisonnement high :

   codex --profile production  # Utilise gpt-5.3-codex + high

3. Utilisez régulièrement /compact pour compresser le contexte : Supprimez l’historique de conversation redondant

4. Exploitez les crédits d’abonnement ChatGPT : Utilisez en priorité les crédits gratuits des utilisateurs Plus/Pro

5. Évitez les recherches web inutiles : Définissez web_search = "disabled" pour réduire les appels supplémentaires

Estimation des économies :

• Basculer 50 % des tâches simples de gpt-5.3-codex + high vers o4-mini + low permet d’économiser environ 60-70 % du coût des tokens
• Combiné aux crédits d’abonnement, le coût mensuel moyen d’un utilisateur particulier peut être maintenu entre 10 et 20 $

Intégration du protocole MCP : Connexion aux outils externes

Model Context Protocol (MCP) est un protocole ouvert proposé par Anthropic, permettant aux assistants IA de se connecter à des outils et sources de données externes. Grâce à l’intégration MCP, Codex CLI peut accéder à GitHub, aux bases de données, aux plateformes de monitoring, etc., étendant considérablement ses capacités.

Qu’est-ce que MCP ?

L’idée centrale de MCP est la suivante : les assistants IA ne doivent pas se limiter à leurs connaissances internes, mais doivent pouvoir accéder en temps réel aux dernières données des systèmes externes. Via les serveurs MCP, Codex peut :

• Lire les Issues et Pull Requests des dépôts GitHub
• Interroger les enregistrements d’une base de données PostgreSQL
• Obtenir les logs d’erreurs Sentry
• Accéder aux messages des canaux Slack

Configuration des serveurs MCP GitHub/Sentry/Base de données

Configurez les serveurs MCP dans ~/.codex/config.toml :

[mcp_servers]

# Serveur MCP GitHub
github = { command = "npx", args = ["-y", "@modelcontextprotocol/server-github"] }

# Serveur MCP PostgreSQL
postgres = { command = "npx", args = ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"] }

# Serveur MCP Sentry
sentry = { command = "npx", args = ["-y", "@modelcontextprotocol/server-sentry"] }

# Serveur MCP système de fichiers (extension des capacités sandbox)
filesystem = { command = "npx", args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"] }

En pratique : Étendre les capacités de Codex avec MCP

Scénario 1 : Analyser une Issue GitHub

codex --mcp github
> Analyse les bug reports récents du repo:openai/codex

[CODEx] Requête via GitHub MCP...
[CODEx] 5 bug reports récents trouvés :
1. #123 : Échec de restauration de session sur Windows
2. #124 : Fuite de permissions sandbox en mode workspace-write
3. ...

J'analyserai en détail le problème #123...

Scénario 2 : Interroger une base de données

codex --mcp postgres
> Interroge les utilisateurs récemment inscrits dans la table users

[CODEx] Exécution de la requête via PostgreSQL MCP...
[CODEx] Résultats :
- user_id : 1001, email : alice@example.com, created_at : 2026-06-07
- user_id : 1002, email : bob@example.com, created_at : 2026-06-06

Scénario 3 : Déboguer les erreurs Sentry

codex --mcp sentry
> Analyse les critical errors des dernières 24 heures

[CODEx] Requête via Sentry MCP...
[CODEx] 3 critical errors détectés :
1. TypeError : Cannot read property 'token' of undefined (auth/token.js:45)
2. ...

Solution suggérée : Ajouter une vérification de nullité avant d'accéder à la propriété token...

Voir et gérer les serveurs MCP

# Lister les serveurs MCP configurés
/mcp list

# Activer/désactiver un serveur spécifique
/mcp enable github
/mcp disable postgres

# Voir l'état des serveurs
/mcp status

Codex CLI vs Claude Code : Comparaison complète

Codex CLI et Claude Code sont tous deux des représentants des assistants IA de programmation en terminal, chacun ayant ses forces et faiblesses. Voici une comparaison complète :

Tableau comparatif des fonctionnalités

Dimension	Claude Code	Codex CLI
Configuration personnalisée	Supporte barre d’état, prompts, styles de sortie	Profiles multi-scénarios, contrôle fin du niveau de raisonnement
Contexte visuel	Supporte l’entrée d’images	Supporte Ctrl+V pour coller des images
Gestion de session	Récupération de session, tâches en arrière-plan	/resume, /fork, enregistrement Transcripts
Sécurité	Revue de sécurité intégrée	Sandbox trois niveaux + approbation quatre niveaux
Modes spéciaux	Mode Vim	—yolo fully automatic (mode dangereux)
Intégration MCP	Support natif	Intégration via fichier de configuration
Statut open source	Closed source	Open source (Apache 2.0)
Choix de modèle	Uniquement modèle Claude	gpt-5.3-codex, gpt-5, o4-mini
Écosystème communautaire	Support officiel Anthropic	GitHub 39K+ Stars, communauté active

Comparaison des tarifs

Élément	Claude Code	Codex CLI
Outil lui-même	Gratuit	Gratuit (open source)
Frais d’abonnement	Claude Pro 20 $/mois	Pas de frais mensuels fixes
Frais API	Inclus dans l’abonnement Pro	Facturé selon l’utilisation API
Crédits gratuits	Utilisation illimitée avec Pro	Plus : 5 $/mois, Pro : 50 $/mois
Facturation au-delà	Aucune (Pro illimité)	Selon tarification API OpenAI

Estimation des coûts :

• Utilisateur léger (1-2 heures/jour) : Codex CLI 5-15 $/mois (utilisation des crédits d’abonnement), Claude Pro 20 $
• Utilisateur modéré (3-5 heures/jour) : Codex CLI 20-50 $/mois, Claude Pro 20 $
• Utilisateur intensif (6+ heures/jour) : Codex CLI 50-150+ $/mois, Claude Pro 20 $

Comment choisir ?

Choisissez Codex CLI si :

• Vous privilégiez les outils open source et les systèmes de configuration transparents
• Vous avez besoin d’un contrôle précis du choix de modèle et du niveau de raisonnement
• Vos projets impliquent des changements fréquents de modèle (tâches simples avec modèle léger)
• La sécurité sandbox et la récupération de session sont importantes pour vous
• Votre budget est limité et vous souhaitez réduire les coûts via les crédits d’abonnement

Choisissez Claude Code si :

• Vous êtes déjà abonné à Claude Pro
• Vous privilégiez une expérience produit mature et stable
• Vous n’avez pas besoin de changer fréquemment de modèle
• Le support officiel et l’intégration écosystémique d’Anthropic sont importants pour vous

Stratégie d’utilisation mixte : De nombreux développeurs installent les deux outils et choisissent selon le scénario :

• Développement quotidien avec Claude Code (stable, sans souci)
• Refactoring complexe avec Codex CLI (multi-modèles, contrôle fin)
• Sensibilité aux coûts avec Codex CLI (utilisation des crédits d’abonnement)

FAQ - Questions fréquentes

Erreur “command not found” après l’installation

Cause : Le répertoire d’installation global npm n’est pas dans le PATH.

Solution :

# Trouver l'emplacement d'installation de codex
which codex

# Si introuvable, vérifier le répertoire global npm
npm config get prefix

# Ajouter le sous-répertoire bin de ce répertoire au PATH
echo 'export PATH=$(npm config get prefix)/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

Version Node.js trop ancienne

Cause : Codex CLI requiert Node.js 18.x ou supérieur.

Solution :

# Vérifier la version actuelle
node --version

# Si inférieure à 18.x, mettre à niveau vers la version LTS
# macOS
brew install node@20

# Ubuntu
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# Utiliser nvm (recommandé)
nvm install 20
nvm use 20

Clé API invalide

Cause : Format de clé API incorrect, clé expirée ou permissions insuffisantes.

Solution :

1. Vérifiez que le format de la clé API commence par sk-proj- ou sk-
2. Vérifiez l’état de la clé sur OpenAI Platform
3. Confirmez que votre compte dispose d’un solde suffisant ou de crédits d’abonnement
4. Réexportez la variable d’environnement :

   export OPENAI_API_KEY="sk-proj-votre-clé-correcte"

Comment utiliser Codex CLI en Chine ?

Problèmes réseau : Codex CLI doit accéder à l’API OpenAI, la connexion directe depuis la Chine peut être instable.

Solutions :

1. Utiliser un proxy : Configurer la variable d’environnement HTTP_PROXY

   export HTTP_PROXY=http://votre-proxy:port
   export HTTPS_PROXY=http://votre-proxy:port

2. Utiliser un service de relais : Certains fournisseurs de cloud proposent un relais API
3. Déployer un modèle local : Combiner avec des outils de modèles locaux comme Ollama (nécessite la modification de la configuration Codex)

Problèmes de compte : L’inscription d’un compte OpenAI peut nécessiter un numéro de téléphone ou un e-mail étranger.

Problèmes de paiement : L’abonnement ChatGPT nécessite une carte bancaire internationale ou des cartes cadeaux.

Comment gérer les avertissements Git ?

Symptôme : Avertissements liés à Git lors de l’exécution de Codex.

Cause : Git n’est pas installé ou les informations utilisateur ne sont pas configurées.

Solution :

# Installer Git
# macOS
brew install git

# Ubuntu
sudo apt install git

# Configurer les informations utilisateur
git config --global user.name "Votre Nom"
git config --global user.email "votre@email.com"

# Initialiser le dépôt (si dans un répertoire de projet)
git init

Conclusion et démarrage rapide en trois étapes

OpenAI Codex CLI représente la dernière évolution des assistants IA de programmation en terminal. Ce n’est pas seulement un outil de génération de code, mais une plateforme de développement complète intégrant sandbox de sécurité, gestion de session, intégration MCP et configurations production-ready.

Rappel des valeurs clés

1. Sécurité prioritaire : Sandbox trois niveaux + approbation quatre niveaux, garantissant un contrôle des opérations de l’IA
2. Configuration flexible : Système Profile permettant un basculement multi-scénarios en un clic
3. Persistance des sessions : /resume et /fork pour ne plus jamais perdre votre progression
4. Extension écosystémique : Protocole MCP connectant GitHub, bases de données et autres outils externes
5. Optimisation des coûts : Choix de modèles multiples + contrôle du niveau de raisonnement, utilisation à la demande

Démarrage rapide en trois étapes

Étape 1 : Installation et authentification

npm install -g @openai/codex
codex login  # ou utiliser une clé API

Étape 2 : Choisir le mode de sécurité

# Recommandé pour les débutants : mode revue de sécurité
codex --sandbox read-only

# Développement quotidien : mode écriture workspace
codex --sandbox workspace-write

Étape 3 : Commencer votre première tâche

codex
> Crée une API Express.js simple avec un endpoint GET /health

[CODEx] Je vais créer les fichiers suivants :
- package.json
- server.js
- routes/health.js

Démarrage de l'exécution... ✓

Ressources pour la suite

• Documentation officielle : developers.openai.com/codex
• Dépôt GitHub : github.com/openai/codex
• Guide d’intégration IDE : developers.openai.com/codex/ide
• Détails tarifaires API : openai.com/api/pricing
• Discussions communautaires : GitHub Issues et Reddit r/OpenAI

Que vous soyez un développeur senior ou un novice en programmation IA, Codex CLI améliorera significativement votre flux de travail. Commencez dès aujourd’hui et faites de l’IA votre partenaire de pair programming dans le terminal !

---

Lectures connexes :

• Guide complet Aider 2026 : L’outil open source de pair programming IA dans le terminal
• Guide complet Claude Code CLI 2026
• Évaluation approfondie OpenCode CLI 2026