OpenAI Codex CLI Komplette Anleitung 2026: Vom...

OpenAI Codex CLI ist ein KI-Programmierungsassistent für das Terminal, den OpenAI Mitte 2025 eingeführt hat. Er bringt leistungsstarke Code-Generierungsfähigkeiten direkt in die Befehlszeilenumgebung. Als Kernprodukt zur Konkurrenz von Anthropic Claude Code hat sich Codex CLI dank seines offenen und kostenlosen Ansatzes, des Sandbox-Sicherheitsmodells, der MCP-Protokollintegration und des flexiblen Profile-Konfigurationssystems schnell zu einem unverzichtbaren Werkzeug im Entwickler-Toolkit des Jahres 2026 entwickelt.

Was ist Codex CLI?

Mehr als nur “ChatGPT im Terminal”

Viele Entwickler, die zum ersten Mal mit Codex CLI in Berührung kommen, verstehen es einfach als “ChatGPT, das im Terminal läuft”. Diese Sichtweise unterschätzt jedoch die Tiefe seines Designs erheblich. Codex CLI ist ein vollständiger interaktiver Code-Agent, der nicht nur natürliche Sprachbefehle versteht, sondern auch:

• Projektkontext lesen: Automatische Analyse der Dateistruktur, Abhängigkeiten und des Code-Stils im aktuellen Verzeichnis
• Mehrstufige Aufgaben ausführen: Von der Anforderungsanalyse über die Code-Implementierung bis zur Testvalidierung – ein kompletter Workflow
• Sichere Sandbox-Isolierung: Durch dreistufige Sandbox-Modi und vierstufige Genehmigungsstrategien wird sichergestellt, dass KI-Operationen das System nicht beschädigen
• Sitzungspersistenz: Unterstützung für Sitzungswiederherstellung, Fork-Experimente und Historien-Tracking, damit Arbeitsfortschritte nicht verloren gehen

Kern-Architekturdesign

Codex CLI wurde in Rust entwickelt und verwendet eine modulare Architektur:

codex-cli/
├── core/          # Core-Engine: Modellaufrufe, Kontextverwaltung
├── sandbox/       # Sandbox-Schicht: Dateisystem-Isolierung, Befehlsausführungslimits
├── mcp/           # MCP-Protokollintegration: Verbindung zu externen Tools
├── config/        # Konfigurationssystem: Profile-Verwaltung, Alias-Auflösung
└── ui/            # Interaktive Oberfläche: TUI, Slash-Befehls-Parsing

Dieses Design ermöglicht es Codex CLI, trotz seiner Leichtigkeit unternehmensweite Sicherheit und Erweiterbarkeit zu bieten. Im Vergleich zu traditionellen IDE-Plugins liegen die Vorteile auf der Hand:

• Keine Editor-Bindung: Egal ob du Vim, Emacs oder VS Code bevorzugst – du kannst es nahtlos im Terminal verwenden
• Remote-freundlich: Läuft ebenso flüssig auf SSH-verbindeten Servern oder in Docker-Containern
• Niedrige Ressourcennutzung: Die in Rust geschriebene Binärdatei startet schnell und verbraucht deutlich weniger Speicher als Electron-Anwendungen

Installation und Grundkonfiguration

Vier Installationsmethoden

1. npm-Installation (empfohlen für die meisten Benutzer)

npm install -g @openai/codex

Dies ist die universellste Installationsmethode und funktioniert unter macOS, Linux und Windows (WSL2). Nach der Installation führe codex --version aus, um den Erfolg zu bestätigen.

2. Homebrew-Installation (erste Wahl für macOS-Benutzer)

brew install --cask codex

Der Vorteil der Homebrew-Installation liegt in der automatischen Behandlung von Abhängigkeiten und PATH-Konfiguration. Zum Aktualisieren genügt ein brew upgrade codex.

3. Binärdatei-Download

Besuche GitHub Releases, um vorkompilierte Binärdateien für deine Plattform herunterzuladen:

• 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

Nach dem Download vergib Ausführungsrechte und verschiebe die Datei in ein PATH-Verzeichnis:

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

4. WSL2-Installation (für Windows-Benutzer)

Die native Windows-Unterstützung befindet sich noch in der Entwicklung. Es wird empfohlen, sie über WSL2 (Windows Subsystem for Linux) zu installieren:

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

Authentifizierungsmethoden: ChatGPT-Abonnement vs. API-Key

Codex CLI unterstützt zwei Authentifizierungsmethoden, jede mit ihren eigenen Anwendungsszenarien:

ChatGPT-Abonnement-Login (geeignet für Privatnutzer)

Wenn du ein ChatGPT Plus-, Pro-, Team-, Edu- oder Enterprise-Abonnement besitzt, kannst du dich direkt über den Browser anmelden:

codex login

Dadurch wird dein Standardbrowser geöffnet. Nach Abschluss der OAuth-Autorisierung wird das Token automatisch gespeichert. Vorteile für Abonnenten:

• Plus-Benutzer: 5 USD monatliches kostenloses API-Guthaben (30-Tage-Rolling)
• Pro-Benutzer: 50 USD monatliches kostenloses API-Guthaben (30-Tage-Rolling)

Nach Überschreiten des Guthabens wird nach den standardmäßigen API-Preisen abgerechnet.

API-Key-Umgebungsvariable (geeignet für Teams/Automatisierung)

Für Teamzusammenarbeit oder CI/CD-Integration wird die Verwendung eines API-Keys empfohlen:

export OPENAI_API_KEY="sk-proj-xxxxxxxxxxxxxxxxxxxxxxxx"

Füge diese Zeile zu ~/.bashrc oder ~/.zshrc hinzu, damit sie dauerhaft wirksam wird. API-Keys können auf der OpenAI Platform erstellt und verwaltet werden.

Sicherheitshinweis: Hardcodiere API-Keys niemals in Code-Repositories. Verwende stattdessen .env-Dateien oder Schlüsselverwaltungsdienste.

Systemanforderungen und Vorab-Checks

Stelle vor der Installation sicher, dass dein System die folgenden Anforderungen erfüllt:

Komponente	Mindestversion	Empfohlene Version
Node.js	18.x	20.x LTS
npm	9.x	10.x
Git	2.x	2.40+
Betriebssystem	macOS 12+/Ubuntu 20.04+/WSL2	Neueste stabile Version

Führe die folgenden Befehle aus, um die Voraussetzungen zu prüfen:

node --version   # Sollte v18.x oder höher ausgeben
npm --version    # Sollte 9.x oder höher ausgeben
git --version    # Sollte git version 2.x ausgeben

Wenn deine Node.js-Version zu niedrig ist, besuche die Node.js-Website, um die neueste LTS-Version herunterzuladen und zu installieren.

Drei Betriebsmodi im Detail

Codex CLI bietet drei Betriebsmodi, die unterschiedliche Automatisierungsgrade und Sicherheitsstufen entsprechen:

suggest-Modus (am sichersten)

codex --mode suggest

Im suggest-Modus liefert Codex nur Code-Vorschläge und Erklärungen. Er ändert keine Dateien automatisch. Du musst den vorgeschlagenen Code manuell kopieren und in dein Projekt übernehmen.

Anwendungsszenarien:

• Beim Lernen neuer Frameworks, wenn du die Prinzipien jedes Schritts verstehen möchtest
• Vor der Überprüfung sensibler Code-Änderungen, wenn eine manuelle Bestätigung erforderlich ist
• Bei der ersten Verwendung von Codex, um sich mit seinem Ausgabestil vertraut zu machen

Beispiel:

$ codex --mode suggest
> Erstelle eine React Todo-Komponente

[CODEx] Ich schlage folgende Dateistruktur vor:
- src/components/TodoList.jsx
- src/components/TodoItem.jsx
- src/hooks/useTodos.js

Hier ist der Inhalt von TodoList.jsx:
[Code-Block...]

Du kannst diese Dateien manuell erstellen oder in den auto-edit-Modus wechseln, damit ich sie automatisch schreibe.

auto-edit-Modus (ausgewogen)

codex --mode auto-edit

auto-edit ist der Standardmodus. Codex bearbeitet Dateien automatisch, fordert aber bei Befehlen mit möglichen Nebenwirkungen (wie rm, git push) eine Bestätigung an.

Anwendungsszenarien:

• Täglicher Entwicklungs-Workflow
• Wenn KI schnell Code iterieren soll, aber die Genehmigungsbefugnis für kritische Operationen erhalten bleibt
• Refactoring von Projekten mittlerer Komplexität

Beispiel:

[CODEx] Ich erstelle src/components/TodoList.jsx... ✓
[CODEx] Ich erstelle src/components/TodoItem.jsx... ✓
[CODEx] Ich muss npm install react-icons ausführen. Fortfahren? [Y/n]

full-auto-Modus (am schnellsten)

codex --mode full-auto

Im full-auto-Modus führt Codex alle Operationen vollautomatisch aus, einschließlich Dateibearbeitungen und Befehlsausführungen, ohne jegliche Bestätigung. Dies ist der effizienteste, aber auch gefährlichste Modus.

Anwendungsszenarien:

• Isolierte Entwicklungsumgebungen (wie Docker-Container)
• Wenn du Codex’ Urteilsvermögen vollständig vertraust und maximale Effizienz anstrebst
• Batch-Code-Generierungsaufgaben

Warnung: Bevor du full-auto in einer Produktionsumgebung verwendest, konfiguriere unbedingt den Sandbox-Modus, um seinen Berechtigungsbereich einzuschränken.

Tiefgehende Analyse des Sandbox-Sicherheitsmodells ⭐ Differenzierungsschwerpunkt

Die Sandbox ist der Kern-Sicherheitsmechanismus von Codex CLI. Sie isoliert Dateisystem- und Befehlsausführungsberechtigungen, um zu verhindern, dass fehlerhafte oder böswillige KI-Aktionen das System beschädigen. Das Verständnis des Sandbox-Modells ist der Schlüssel zur produktionsreifen Nutzung von Codex.

Vergleich der drei Sandbox-Modi

Codex bietet dreistufige Sandbox-Modi, die über den --sandbox-Parameter angegeben werden:

Modus	Dateisystem-Berechtigungen	Befehlsausführung	Anwendungsszenario
read-only	Nur lesend, jegliches Schreiben verboten	Erlaubt nur Lesebefehle (ls, cat, grep)	Code-Review, Dokumentationsanalyse
workspace-write	Schreiben nur im aktuellen Projektverzeichnis erlaubt	Erlaubt normale Befehle, verbietet systemweite Operationen	Tägliche Entwicklung (empfohlen)
danger-full-access	Vollständige Lese-/Schreibberechtigungen	Erlaubt alle Befehle	Isolierte Umgebungen, experimentelle Aufgaben

Standardmodus: workspace-write, ein Gleichgewicht zwischen Sicherheit und Benutzerfreundlichkeit.

read-only-Modus in der Praxis

codex --sandbox read-only
> Analysiere die Architektur dieses Projekts

[CODEx] Ich lese die Struktur des src/-Verzeichnisses...
[CODEx] Folgende Module gefunden:
- auth/ (Authentifizierung)
- api/ (REST-API)
- components/ (UI-Komponenten)

Da ich mich im read-only-Modus befinde, kann ich keine Dateien ändern. Für Refactoring wechsle bitte zum workspace-write-Modus.

workspace-write-Modus (empfohlen)

codex --sandbox workspace-write
> Refaktorisiere das auth-Modul und füge JWT-Refresh-Token hinzu

[CODEx] Ich ändere src/auth/token.js... ✓
[CODEx] Ich erstelle src/auth/refresh.js... ✓
[CODEx] Tests ausführen, um Änderungen zu validieren... ✓

In diesem Modus kann Codex nur Dateien im aktuellen Arbeitsverzeichnis und seinen Unterverzeichnissen ändern. Der Zugriff auf Systemverzeichnisse wie /etc oder /usr ist nicht möglich.

danger-full-access-Modus (mit Vorsicht verwenden)

codex --sandbox danger-full-access
> Alle node_modules-Verzeichnisse bereinigen

[CODEx] Warnung: Diese Operation löscht mehrere Verzeichnisse. Fortfahren? [Y/n]

Nur in folgenden Szenarien verwenden:

• Temporäre Umgebungen in Docker-Containern
• Dedizierte Sandbox-VMs
• Wenn du Codex’ Urteilsvermögen vollständig vertraust und wichtige Daten gesichert hast

Vierstufige Granularität der Genehmigungsstrategie

Zusätzlich zum Sandbox-Modus bietet Codex feinkörnige Befehlsgenehmigungsstrategien, die über den --ask-for-approval-Parameter gesteuert werden:

Strategie	Verhalten	Anwendungsszenario
untrusted	Nur nicht vertrauenswürdige Befehle erfordern Genehmigung (Standard)	Tägliche Entwicklung
on-failure	Genehmigung nur bei Befehlsfehler	Debugging-Szenarien
on-request	Genehmigung nur bei aktiver Anfrage durch Codex	Hohes Vertrauen in die KI
never	Niemals Genehmigung anfordern	In Kombination mit Sandbox verwenden

Definition nicht vertrauenswürdiger Befehle:

• Netzwerkoperationen (curl, wget)
• Paketverwaltung (npm install, pip install)
• Versionskontrolle (git push, git reset --hard)
• Systemkonfiguration (sudo, chmod)

Kombinierte Anwendungsbeispiele

# Sicherste Kombination: Nur-Lesen-Sandbox + strikte Genehmigung
codex --sandbox read-only --ask-for-approval untrusted

# Effiziente Kombination: Workspace-Schreiben + Genehmigung bei Fehler
codex --sandbox workspace-write --ask-for-approval on-failure

# Vollautomatische Kombination: Gefährliche Sandbox + keine Genehmigung (nur für isolierte Umgebungen)
codex --sandbox danger-full-access --ask-for-approval never

Der wesentliche Unterschied zwischen —full-auto und —yolo

Viele Benutzer verwechseln die Parameter --mode full-auto und --yolo. Sie wirken auf unterschiedlichen Ebenen:

• --mode full-auto: Steuert, ob Codex eine Benutzerbestätigung für Code-Bearbeitungen benötigt
• --yolo: Überspringt alle Genehmigungs-Prompts für Befehlsausführungen (entspricht --ask-for-approval never)

# Die folgenden beiden Befehle haben denselben Effekt
codex --mode full-auto --yolo
codex --mode full-auto --ask-for-approval never

Namensherkunft: “Yolo” stammt vom populären Ausdruck “You Only Live Once” und wird in der Tech-Community oft verwendet, um “rücksichtslose Ausführung” zu bedeuten. OpenAI nutzt diesen humorvollen Namen, um Benutzer daran zu erinnern: Dieser Modus birgt Risiken, bitte mit Vorsicht verwenden.

Beste Sicherheitspraktiken für Produktionsumgebungen

Bei der Verwendung von Codex CLI in Produktionsumgebungen sollten folgende Sicherheitsrichtlinien beachtet werden:

1. Standardmäßig workspace-write-Sandbox verwenden: Beschränke die KI darauf, nur aktuelle Projektdateien zu ändern
2. Git-Integration aktivieren: Jede KI-Änderung wird automatisch committet, was das Rollback erleichtert
3. Transcripts regelmäßig überprüfen: Codex protokolliert alle Interaktionen und Operationslogs
4. Sensitive Operationen manuell ausführen: Kritische Schritte wie Datenbank-Migrationen oder Produktions-Deployments nicht der KI überlassen
5. Profile zur Umgebungsisolierung verwenden: Unterschiedliche Sicherheitsstrategien für verschiedene Projekte konfigurieren

# Beispielkonfiguration für Produktionsprojekte
codex --profile production --sandbox workspace-write --ask-for-approval untrusted

# Beispielkonfiguration für experimentelle Projekte
codex --profile experimental --sandbox danger-full-access --yolo

Vollständige Analyse der 24 Slash-Befehle ⭐ Differenzierungsschwerpunkt

Codex CLI bietet 24 Slash-Befehle (Slash Commands), die Sitzungssteuerung, Modellwechsel, Berechtigungsverwaltung, Dateioperationen und mehr abdecken. Die Beherrschung dieser Befehle steigert die Arbeitseffizienz erheblich.

Sitzungssteuerung (/new, /resume, /fork, /compact)

/new - Neue Sitzung starten

/new

Löscht den aktuellen Kontext und beginnt ein völlig neues Gespräch. Geeignet für Aufgabenwechsel oder zum Löschen störender Historie.

/resume - Historische Sitzung wiederherstellen

/resume

Öffnet einen interaktiven Sitzungsauswähler, der alle historischen Sitzungen auflistet und Filterung nach Datum und Verzeichnis unterstützt. Siehe Kapitel “Sitzungswiederherstellung” weiter unten.

/fork - Fork-Experiment

/fork

Erstellt eine Kopie der aktuellen Sitzung. Versuche unterschiedliche Lösungen in einem neuen Branch, ohne die Hauptsitzung zu beeinflussen. Geeignet für:

• Vergleich mehrerer Implementierungsansätze
• Experimentelles Refactoring, das bei Misserfolg leicht verworfen werden kann
• Paralleles Erkunden verschiedener Architekturentwürfe

> /fork
[CODEx] Sitzungsbranch fork-2026-06-07-14-30 erstellt
> Versuche, Redux statt Context API zu verwenden

[CODEx] Im Branch werde ich das State-Management refaktorisieren...

/compact - Kontext komprimieren

/compact

Wenn die Sitzungshistorie zu lang wird und den Token-Verbrauch stark ansteigen lässt, verwende /compact, um den Kontext zu komprimieren. Wichtige Informationen bleiben erhalten, redundante Gespräche werden gelöscht. Dies senkt effektiv die Kosten nachfolgender Aufrufe.

Modell und Stil (/model, /personality, /plan)

/model - Modell wechseln

/model gpt-5

Wechselt das zur Laufzeit verwendete Modell. Verfügbare Modelle sind:

• gpt-5.3-codex (Standard, speziell für Code optimiert)
• gpt-5 (Allgemeines Flaggschiff-Modell)
• o4-mini (Leichtes Inferenzmodell, niedrige Kosten)

> /model o4-mini
[CODEx] Zum o4-mini-Modell gewechselt. Dieses Modell eignet sich für einfache Aufgaben. Die Inferenzfähigkeiten sind schwächer, aber die Kosten sind niedriger.

/personality - KI-Persönlichkeit anpassen

/personality concise

Passt den Antwortstil von Codex an:

• concise: Prägnant und direkt, wenig Erklärung
• verbose: Detaillierte Erklärungen, geeignet zum Lernen
• professional: Formeller Ton, geeignet zur Dokumentenerstellung
• friendly: Freundlich und locker, geeignet für alltägliche Kommunikation

/plan - Ausführungsplan generieren

/plan

Lässt Codex zuerst einen detaillierten Ausführungsplan ausgeben, bevor er schrittweise implementiert. Geeignet für komplexe Aufgaben, damit du potenzielle Probleme frühzeitig erkennst.

> /plan
> Das gesamte Auth-Modul refaktorisieren und OAuth2-Unterstützung hinzufügen

[CODEx] Ausführungsplan:
1. Bestehende auth/-Verzeichnisstruktur analysieren
2. OAuth2-Flow entwerfen (Authorization Code Grant)
3. oauth2/-Submodul erstellen
4. Login-Endpunkt ändern, kompatibel mit traditionellem Passwort und OAuth2
5. Testfälle aktualisieren
6. Migrationsdokumentation generieren

Mit der Ausführung beginnen? [Y/n]

Berechtigungen und Status (/permissions, /status, /debug-config)

/permissions - Aktuelle Berechtigungen anzeigen

/permissions

Zeigt die aktuelle Sandbox-Modus- und Genehmigungsstrategie-Konfiguration an.

> /permissions
[CODEx] Aktuelle Berechtigungskonfiguration:
- Sandbox: workspace-write
- Genehmigungsrichtlinie: untrusted
- Yolo-Modus: deaktiviert

/status - Sitzungsstatus anzeigen

/status

Zeigt detaillierte Informationen zur aktuellen Sitzung an, einschließlich:

• Verwendetes Modell und Inferenzstufe
• Token-Nutzungsstatistik
• Sitzungsdauer
• Anzahl der ausgeführten Operationen

> /status
[CODEx] Sitzungsstatus:
- Modell: gpt-5.3-codex (reasoning: high)
- Tokens: 12.450 Input / 3.200 Output
- Dauer: 45 Minuten
- Operationen: 23 Dateibearbeitungen, 8 ausgeführte Befehle

/debug-config - Konfigurationsladekette diagnostizieren

/debug-config

Dies ist das ultimative Tool zur Behebung von Konfigurationsproblemen. Es zeigt, wie Codex Konfigurationsdateien lädt, einschließlich:

• Pfad zur globalen Konfiguration (~/.codex/config.toml)
• Pfad zur Projektkonfiguration (.codex/config.toml)
• Umgebungsvariablen-Overrides
• Profil-Aktivierungsstatus
• Endgültig wirksame Konfigurationswerte

> /debug-config
[CODEx] Konfigurationsladekette:
1. Globale Konfiguration: /home/user/.codex/config.toml ✓
2. Projektkonfiguration: /path/to/project/.codex/config.toml ✓
3. Umgebungsvariablen: OPENAI_API_KEY gesetzt ✓
4. Aktives Profil: production
5. Finale Konfiguration:
   - model: gpt-5.3-codex
   - sandbox_mode: workspace-write
   - approval_policy: untrusted

Dateien und Tools (/mention, /diff, /review, /mcp)

/mention - Bestimmte Datei zitieren

/mention src/auth/token.js

Zwingt Codex, sich auf eine bestimmte Datei zu konzentrieren, auch wenn sie nicht im aktuellen Kontext steht. Geeignet zur Lokalisierung Schlüsseldateien in großen Projekten.

/diff - Änderungsunterschiede anzeigen

/diff

Zeigt die Diff-Vergleiche aller Dateiänderungen seit Beginn der Sitzung an. Praktisch zur Überprüfung, ob die KI-Änderungen den Erwartungen entsprechen.

/review - Code-Review

/review

Lässt Codex die neuesten Code-Änderungen überprüfen, potenzielle Probleme, Leistungsengpässe und Sicherheitsrisiken aufzeigen.

> /review
[CODEx] Code-Review-Bericht:
✓ Vorteile:
  - Korrekte Verwendung von async/await zur Behandlung asynchroner Operationen
  - Umfassende Fehlerbehandlung hinzugefügt

⚠ Verbesserungsvorschläge:
  - token.js Zeile 45: Fehlende Eingabevalidierung, könnte zu Injection-Angriffen führen
  - refresh.js Zeile 12: HttpOnly-Flag nicht gesetzt, XSS-Risiko besteht

🔴 Kritische Probleme:
  - Hartcodierter JWT-Schlüssel, sollte Umgebungsvariable verwenden

/mcp - MCP-Server verwalten

/mcp list

Listet die konfigurierten Model Context Protocol (MCP)-Server auf. MCP ermöglicht Codex die Verbindung zu externen Tools wie GitHub, Datenbanken und Monitoring-Plattformen. Siehe Kapitel “MCP-Protokollintegration” weiter unten.

Weitere nützliche Befehle

Befehl	Funktion
/init	Projektkonfiguration initialisieren, .codex/config.toml erstellen
/feedback	Feedback an OpenAI senden
/logout	Abmelden, Authentifizierungstoken löschen
/quit	Codex CLI beenden
/statusline	Anzeige der Terminal-Statusleiste anpassen
/ps	Im Hintergrund laufende Tasks anzeigen
/apps	Integrierte Anwendungen verwalten

Sitzungswiederherstellung: Arbeitsfortschritt nie wieder verlieren ⭐ Differenzierungsschwerpunkt

Die Sitzungswiederherstellung ist eine stark unterschätzte Funktion von Codex CLI. In traditionellen Terminal-Tools bedeutet das Schließen des Terminals den Verlust des gesamten Kontexts. Codex implementiert durch den Transcripts-Mechanismus die Persistenz und flexible Wiederherstellung von Sitzungen.

Vier Wiederherstellungsmethoden

1. Interaktiver Auswähler (empfohlen)

codex resume

Öffnet eine interaktive Oberfläche, die alle historischen Sitzungen auflistet und unterstützt:

• Sortierung nach Datum
• Filterung nach Verzeichnis
• Stichwortsuche
• Vorschau der Sitzungszusammenfassung

$ codex resume
Wähle die wiederherzustellende Sitzung:
  1. [2026-06-07 14:30] auth-Modul refaktorisieren (12 Ops)
  2. [2026-06-07 10:15] React Todo-App erstellen (8 Ops)
  3. [2026-06-06 16:45] API-Endpunkt debuggen (5 Ops)
> 1
[CODEx] Sitzung wiederhergestellt: auth-Modul refaktorisieren

2. Letzte Sitzung wiederherstellen

codex resume --last

Stellt die zuletzt verwendete Sitzung schnell wieder her, ohne interaktive Auswahl. Geeignet für Szenarien, in denen die Arbeit nach einer Unterbrechung fortgesetzt wird.

3. Bestimmte Sitzung wiederherstellen

codex resume <SESSION_ID>

Präzise Wiederherstellung über die Sitzungs-ID. Die Sitzungs-ID findest du in der Ausgabe des /status-Befehls oder im Transcripts-Verzeichnis.

codex resume sess_abc123def456

4. Alle Sitzungen verzeichnisübergreifend wiederherstellen

codex resume --all

Listet historische Sitzungen aus allen Verzeichnissen auf. Geeignet für Szenarien, in denen zwischen mehreren Projekten gewechselt wird.

Was bleibt bei der Wiederherstellung erhalten?

Bei der Sitzungswiederherstellung重建t Codex die folgenden Zustände:

• Gesprächshistorie: Alle vorherigen Frage-Antwort-Datensätze
• Dateikontext: Liste der gelesenen und geänderten Dateien
• Modellkonfiguration: Verwendetes Modell und Inferenzstufe
• Sandbox-Berechtigungen: Aktuelle Sicherheitskonfiguration
• Unvollendete Aufgaben: Wenn zuvor eine mehrstufige Aufgabe ausgeführt wurde, wird am Unterbrechungspunkt fortgefahren

Nicht gespeicherte Inhalte:

• Temporäre Variablen oder nicht gespeicherte Zwischenergebnisse
• Ausführungsstatus externer Befehle (wie laufende Server)

Praktische Anwendungsfälle

Szenario 1: Arbeit nach Unterbrechung fortsetzen

# Morgens mit dem Refactoring des Auth-Moduls begonnen
$ codex
> Auth-Modul refaktorisieren, JWT-Refresh-Token hinzufügen
[CODEx] Bestehender Code wird analysiert...
# Plötzlich muss ich zu einem Meeting, Strg+C zum Beenden

# Nachmittags zurückkommen und direkt wiederherstellen
$ codex resume --last
[CODEx] Sitzung wiederhergestellt. Zuletzt haben wir auth/token.js analysiert. Als Nächstes werde ich refresh.js erstellen...

Szenario 2: Mehrere Ansätze vergleichen

# Hauptsitzung: Context API verwenden
$ codex
> State-Management implementieren
[CODEx] Ich werde Context API verwenden...

# Fork-Experiment: Redux versuchen
> /fork
[CODEx] Branch erstellt. Jetzt Redux-Ansatz versuchen...

# Nach dem Vergleich entscheiden, die Hauptsitzung beizubehalten und den Branch zu verwerfen

Szenario 3: Inkrementelle Entwicklung langfristiger Projekte

# Tag 1: Projektgerüst aufbauen
$ codex
> Next.js-Projektstruktur erstellen
[CODEx] Abgeschlossen...

# Tag 2: Sitzung wiederherstellen, Entwicklung fortsetzen
$ codex resume --last
[CODEx] Willkommen zurück. Gestern haben wir die Projektstruktur erstellt. Heute setzen wir die Implementierung der Seitenkomponenten fort...

Produktionsreife Konfigurationslösungen ⭐ Differenzierungsschwerpunkt

Das Konfigurationssystem von Codex CLI ist sehr flexibel und unterstützt globale Konfiguration, Projektkonfiguration und Profile für mehrere Szenarien. Eine vernünftige Konfiguration steigert Arbeitseffizienz und Sicherheit erheblich.

Alias-Konfiguration: Startparameter mit einem Befehl erledigen

Für häufig verwendete Startparameter-Kombinationen können Shell-Aliase verwendet werden, um Befehle zu vereinfachen:

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

Nach der Verwendung:

codex-safe   # Sicherer Review-Modus
codex-dev    # Täglicher Entwicklungsmodus
codex-yolo   # Experimenteller Modus (Vorsicht!)

Profile für mehrere Szenarien (die elegantere Lösung)

Obwohl Aliase einfach sind, fehlt ihnen Flexibilität. Das Profile-System von Codex ermöglicht es dir, mehrere Szenarien in Konfigurationsdateien zu definieren und mit dem --profile-Parameter mit einem Klick zu wechseln.

Konfigurationsdateistruktur

Die globale Konfigurationsdatei befindet sich unter ~/.codex/config.toml, die Projektkonfigurationsdatei unter .codex/config.toml.

# ~/.codex/config.toml

# Standardkonfiguration
model = "gpt-5.3-codex"
model_reasoning_effort = "high"
web_search = "live"
sandbox_mode = "workspace-write"
approval_policy = "untrusted"

# Profil: Code-Review (nur lesen, strikte Genehmigung)
[profiles.review]
sandbox_mode = "read-only"
approval_policy = "untrusted"
model_reasoning_effort = "medium"

# Profil: Schneller Prototyp (leichtes Modell, niedrige Kosten)
[profiles.quick]
model = "o4-mini"
model_reasoning_effort = "low"
web_search = "disabled"
sandbox_mode = "workspace-write"

# Profil: Produktionsumgebung (Sicherheit an erster Stelle)
[profiles.production]
sandbox_mode = "workspace-write"
approval_policy = "on-failure"
model = "gpt-5.3-codex"
model_reasoning_effort = "high"

# Profil: Experimentelle Umgebung (vollautomatisch, hohes Risiko)
[profiles.experimental]
sandbox_mode = "danger-full-access"
approval_policy = "never"
model = "gpt-5.3-codex"
model_reasoning_effort = "high"

Profile verwenden

# Code-Review-Szenario
codex --profile review

# Schneller Prototyp-Szenario
codex --profile quick

# Produktionsprojekt
codex --profile production

# Experimentelles Projekt
codex --profile experimental

Projektkonfigurations-Override

Erstelle .codex/config.toml im Projektstammverzeichnis, um die globale Konfiguration zu überschreiben:

# my-project/.codex/config.toml

# Dieses Projekt erzwingt nur-lesen-Sandbox
sandbox_mode = "read-only"

# Dieses Projekt deaktiviert Websuche
web_search = "disabled"

Die Priorität der Codex-Konfigurationsladung lautet: Projektkonfiguration > Profil-Konfiguration > Globale Konfiguration > Standardwerte.

debug-config zur Diagnose der Konfigurationsladekette

Wenn die Konfiguration nicht wie erwartet wirkt, verwende den /debug-config-Befehl zur Diagnose:

> /debug-config
[CODEx] Konfigurationsladekette:
1. Globale Konfiguration: /home/user/.codex/config.toml ✓
   - model: gpt-5.3-codex
   - sandbox_mode: workspace-write
2. Projektkonfiguration: /path/to/project/.codex/config.toml ✓
   - sandbox_mode: read-only (überschreibt globale Konfiguration)
3. Aktives Profil: review
   - approval_policy: untrusted
4. Umgebungsvariablen:
   - OPENAI_API_KEY: gesetzt ✓
   - CODEX_MODEL: nicht gesetzt
5. Finale Konfiguration:
   - model: gpt-5.3-codex (aus globaler Konfiguration)
   - sandbox_mode: read-only (aus Projektkonfiguration, höhere Priorität)
   - approval_policy: untrusted (aus Profil)

Durch diese Ausgabe siehst du klar die Quelle jedes Konfigurationswerts und kannst Probleme schnell lokalisieren.

Modellwechsel und Inferenzstufe

Standardmodell gpt-5.3-codex

Codex CLI verwendet standardmäßig das gpt-5.3-codex-Modell. Dies ist eine von OpenAI speziell für die Code-Generierung optimierte Variante mit folgenden Eigenschaften:

• Starke Code-Verständnisfähigkeit: Tiefes Verständnis für多种 Programmiersprachen und Frameworks
• Großes Kontextfenster: Unterstützt die Analyse langer Dateien und komplexer Projektstrukturen
• Hohe Inferenzeffizienz: Für Code-Aufgaben optimierte Inferenzpfade

Modell zur Laufzeit wechseln

Wechsle Modelle über den /model-Befehl oder die Konfigurationsdatei:

# Zum allgemeinen Flaggschiff-Modell wechseln
/model gpt-5

# Zum leichten Modell wechseln
/model o4-mini

Anwendungsszenarien der einzelnen Modelle:

Modell	Anwendungsszenario	Kosten
gpt-5.3-codex	Komplexe Code-Generierung, Refactoring, Debugging	Hoch
gpt-5	Allgemeine Aufgaben, Dokumentenerstellung, Architekturentwurf	Hoch
o4-mini	Einfache Aufgaben, schnelle Prototypen, kostengünstige Szenarien	Niedrig

Strategie zur Auswahl der Inferenzstufe (high/medium/low)

Die Inferenzstufe (Reasoning Effort) steuert die Denktiefe des Modells vor der Generierung der Antwort:

Stufe	Verhalten	Anwendungsszenario	Token-Verbrauch
high	Tiefgreifende Analyse, mehrstufige Inferenz	Komplexe Algorithmen, Architekturentwurf, knifflige Bugs	Hoch
medium	Balance zwischen Geschwindigkeit und Qualität	Tägliche Entwicklung, reguläres Refactoring	Mittel
low	Schnelle Antwort, oberflächliche Inferenz	Einfache Aufgaben, Syntaxkorrektur, Template-Generierung	Niedrig

In der Konfigurationsdatei einstellen:

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

Zur Laufzeit wechseln:

> /reasoning high
[CODEx] Zur hohen Inferenzstufe gewechselt. Nachfolgende Antworten werden tiefergehend analysiert.

Kostenoptimierung: Wie man monatlich die Hälfte der Token einspart

Die vernünftige Verwendung von Modellen und Inferenzstufen kann die Kosten erheblich senken:

1. Einfache Aufgaben mit o4-mini + niedriger Inferenz:

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

2. Komplexe Aufgaben nur mit gpt-5.3-codex + hoher Inferenz:

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

3. Regelmäßig /compact verwenden, um den Kontext zu komprimieren: Redundante Gesprächshistorie löschen

4. ChatGPT-Abonnementguthaben nutzen: Das kostenlose Guthaben von Plus/Pro-Benutzern priorisiert verwenden

5. Unnötige Websuche vermeiden: web_search = "disabled" einstellen, um zusätzliche Aufrufe zu reduzieren

Geschätzte Einspareffekte:

• Wenn 50 % der einfachen Aufgaben von gpt-5.3-codex + high auf o4-mini + low umgestellt werden, können etwa 60–70 % der Token-Kosten eingespart werden
• In Kombination mit dem Abonnementguthaben können persönliche Benutzer die monatlichen durchschnittlichen Kosten innerhalb von 10–20 USD halten

MCP-Protokollintegration: Externe Tools verbinden

Model Context Protocol (MCP) ist ein offenes Protokoll, das von Anthropic vorgeschlagen wurde. Es ermöglicht KI-Assistenten, externe Tools und Datenquellen zu verbinden. Durch MCP-Integration kann Codex CLI auf externe Ressourcen wie GitHub, Datenbanken und Monitoring-Plattformen zugreifen und seine Fähigkeitsgrenzen erheblich erweitern.

Was ist MCP?

Die Kernidee von MCP lautet: KI-Assistenten sollten nicht auf ihr eigenes Wissen beschränkt sein, sondern Echtzeit-Zugriff auf die neuesten Daten externer Systeme haben. Über MCP-Server kann Codex:

• Issues und Pull Requests von GitHub-Repositories lesen
• Datensätze aus PostgreSQL-Datenbanken abfragen
• Fehlerlogs von Sentry abrufen
• Nachrichten aus Slack-Kanälen accessen

GitHub/Sentry/Datenbank-MCP-Server konfigurieren

Konfiguriere MCP-Server in ~/.codex/config.toml:

[mcp_servers]

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

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

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

# Dateisystem-MCP-Server (erweitert Sandbox-Fähigkeiten)
filesystem = { command = "npx", args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"] }

Praxis: Codex-Fähigkeiten mit MCP erweitern

Szenario 1: GitHub-Issue analysieren

codex --mcp github
> Analysiere die neuesten Bug-Reports im Repo:openai/codex

[CODEx] Über GitHub MCP abfragen...
[CODEx] 5 neueste Bug-Reports gefunden:
1. #123: Sitzungswiederherstellung schlägt unter Windows fehl
2. #124: Sandbox-Berechtigungslleck im workspace-write-Modus
3. ...

Ich werde #123 detailliert analysieren...

Szenario 2: Datenbank abfragen

codex --mcp postgres
> users-Tabelle nach recently registrierten Benutzern abfragen

[CODEx] Über PostgreSQL MCP Abfrage ausführen...
[CODEx] Ergebnisse:
- user_id: 1001, email: alice@example.com, created_at: 2026-06-07
- user_id: 1002, email: bob@example.com, created_at: 2026-06-06

Szenario 3: Sentry-Fehler排查en

codex --mcp sentry
> Kritische Fehler der letzten 24 Stunden analysieren

[CODEx] Über Sentry MCP abfragen...
[CODEx] 3 kritische Fehler gefunden:
1. TypeError: Cannot read property 'token' of undefined (auth/token.js:45)
2. ...

Empfohlene Reparatur: Nullwertprüfung vor dem Zugriff auf die token-Eigenschaft hinzufügen...

MCP-Server anzeigen und verwalten

# Konfigurierte MCP-Server auflisten
/mcp list

# Bestimmten Server aktivieren/deaktivieren
/mcp enable github
/mcp disable postgres

# Serverstatus anzeigen
/mcp status

Codex CLI vs. Claude Code: Umfassender Vergleich

Codex CLI und Claude Code sind beide repräsentative Produkte für Terminal-KI-Programmierungsassistenten. Jedes hat seine Vor- und Nachteile. Hier ist ein umfassender Vergleich:

Funktionsvergleichstabelle

Dimension	Claude Code	Codex CLI
Benutzerdefinierte Konfiguration	Unterstützt Statusleiste, Prompts, Ausgabestil	Profile für mehrere Szenarien, feine Kontrolle der Inferenzstufe
Visueller Kontext	Unterstützt Bildinput	Unterstützt Strg+V zum Einfügen von Bildern
Sitzungsverwaltung	Sitzungswiederherstellung, Hintergrundtasks	/resume, /fork, Transcripts-Aufzeichnung
Sicherheit	Eingebaute Sicherheitsprüfung	Dreistufiger Sandbox-Modus + vierstufige Genehmigung
Spezialmodi	Vim-Modus	—yolo Vollautomatisch (Gefahrenmodus)
MCP-Integration	Native Unterstützung	Integration über Konfigurationsdatei
Open-Source-Status	Closed Source	Open Source (Apache 2.0)
Modellauswahl	Nur Claude-Modelle	gpt-5.3-codex, gpt-5, o4-mini
Community-Ökosystem	Offizielle Anthropic-Unterstützung	GitHub 39K+ Stars, aktive Community

Preisvergleich

Punkt	Claude Code	Codex CLI
Tool selbst	Kostenlos	Kostenlos (Open Source)
Abonnementgebühr	Claude Pro 20 USD/Monat	Keine feste Monatsgebühr
API-Gebühren	Im Pro-Abonnement enthalten	Nach API-Nutzung abrechnen
Kostenloses Guthaben	Pro-Abonnement unbegrenzte Nutzung	Plus: 5 USD/Monat, Pro: 50 USD/Monat
Abrechnung nach Überschreitung	Keine (Pro unbegrenzt)	Nach OpenAI API-Preisen

Kostenschätzung:

• Leichte Benutzer (täglich 1–2 Stunden): Codex CLI monatlich durchschnittlich 5–15 USD (Nutzung des Abonnementguthabens), Claude Pro 20 USD
• Mittlere Benutzer (täglich 3–5 Stunden): Codex CLI monatlich durchschnittlich 20–50 USD, Claude Pro 20 USD
• Schwere Benutzer (täglich 6+ Stunden): Codex CLI monatlich durchschnittlich 50–150+ USD, Claude Pro 20 USD

Wie wählt man?

Wähle Codex CLI, wenn:

• Du Open-Source-Tools und transparente Konfigurationssysteme bevorzugst
• Feine Kontrolle über Modellauswahl und Inferenzstufe benötigst
• Das Projekt多种 Modellwechsel involviert (z. B. leichte Modelle für einfache Aufgaben)
• Sandbox-Sicherheit und Sitzungswiederherstellungsfunktionen wichtig sind
• Das Budget begrenzt ist und du Kosten durch Abonnementguthaben senken möchtest

Wähle Claude Code, wenn:

• Du bereits Claude Pro-Abonnent bist
• Reife und stabile Produkterfahrungen bevorzugst
• Nicht häufig Modelle wechseln musst
• Offizielle Anthropic-Unterstützung und Ökosystem-Integration wichtig sind

Hybride Nutzungsstrategie: Viele Entwickler installieren beide Tools gleichzeitig und wählen je nach Szenario:

• Tägliche Entwicklung mit Claude Code (stabil, sorglos)
• Komplexes Refactoring mit Codex CLI (mehrere Modelle, feine Kontrolle)
• Bei kostenbewusster Nutzung Codex CLI (Abonnementguthaben nutzen)

Häufig gestellte Fragen (FAQ)

Nach der Installation erscheint beim Ausführen “command not found”

Ursache: Das npm-Globalinstallationsverzeichnis ist nicht im PATH.

Lösung:

# codex-Installationsposition finden
which codex

# Wenn nicht gefunden, npm-Globalverzeichnis prüfen
npm config get prefix

# Das bin-Unterverzeichnis dieses Verzeichnisses zum PATH hinzufügen
echo 'export PATH=$(npm config get prefix)/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

Node.js-Version zu niedrig

Ursache: Codex CLI erfordert Node.js 18.x oder höher.

Lösung:

# Aktuelle Version prüfen
node --version

# Wenn niedriger als 18.x, auf LTS-Version upgraden
# macOS
brew install node@20

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

# nvm verwenden (empfohlen)
nvm install 20
nvm use 20

API-Key ungültig

Ursache: API-Key-Format falsch, abgelaufen oder unzureichende Berechtigungen.

Lösung:

1. API-Key-Format bestätigen: Sollte mit sk-proj- oder sk- beginnen
2. Key-Status auf der OpenAI Platform prüfen
3. Sicherstellen, dass das Konto ausreichendes Guthaben oder Abonnementguthaben hat
4. Umgebungsvariable neu exportieren:

   export OPENAI_API_KEY="sk-proj-dein-korrekter-Schlüssel"

Wie verwendet man Codex CLI in China?

Netzwerkprobleme: Codex CLI muss auf die OpenAI API zugreifen. Direkte Verbindungen aus China können instabil sein.

Lösungen:

1. Proxy verwenden: HTTP_PROXY-Umgebungsvariable konfigurieren

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

2. Relay-Dienste verwenden: Einige Cloud-Anbieter bieten API-Relays an
3. Lokale Modelle bereitstellen: In Kombination mit lokalen Model-Tools wie Ollama (Codex-Konfiguration muss geändert werden)

Kontoprobleme: Die Registrierung eines OpenAI-Kontos erfordert möglicherweise eine ausländische Telefonnummer oder E-Mail.

Zahlungsprobleme: ChatGPT-Abonnements erfordern internationale Kreditkarten oder Geschenkkarten.

Wie behandelt man Git-Warnungen?

Phänomen: Git-bezogene Warnungen erscheinen während der Codex-Ausführung.

Ursache: Git ist nicht installiert oder Benutzerinformationen sind nicht konfiguriert.

Lösung:

# Git installieren
# macOS
brew install git

# Ubuntu
sudo apt install git

# Benutzerinformationen konfigurieren
git config --global user.name "Dein Name"
git config --global user.email "deine@email.com"

# Repository initialisieren (wenn im Projektverzeichnis)
git init

Zusammenfassung und Schnellstart in drei Schritten

OpenAI Codex CLI repräsentiert die neueste Entwicklungsrichtung von Terminal-KI-Programmierungsassistenten. Es ist nicht nur ein Tool zur Code-Generierung, sondern eine komplette Entwicklungsplattform, die Sicherheits-Sandbox, Sitzungsverwaltung, MCP-Integration und produktionsreife Konfiguration integriert.

Kernwerte im Überblick

1. Sicherheit an erster Stelle: Dreistufiger Sandbox-Modus + vierstufige Genehmigungsstrategie,确保t kontrollierbare KI-Operationen
2. Flexible Konfiguration: Profile-System unterstützt一键切换 mehrerer Szenarien
3. Sitzungspersistenz: /resume und /fork sorgen dafür, dass Arbeitsfortschritt nicht verloren geht
4. Ökosystem-Erweiterung: MCP-Protokoll verbindet GitHub, Datenbanken und andere externe Tools
5. Kostenoptimierung: Mehrere Modellauswahlen + Inferenzstufenkontrolle, bedarfsgerechte Nutzung

Schnellstart in drei Schritten

Schritt 1: Installation und Authentifizierung

npm install -g @openai/codex
codex login  # oder API-Key verwenden

Schritt 2: Sicherheitsmodus wählen

# Für Anfänger empfohlen: Sicherer Review-Modus
codex --sandbox read-only

# Tägliche Entwicklung: Workspace-Schreibmodus
codex --sandbox workspace-write

Schritt 3: Erste Aufgabe starten

codex
> Erstelle eine einfache Express.js-API mit GET /health-Endpunkt

[CODEx] Ich werde folgende Dateien erstellen:
- package.json
- server.js
- routes/health.js

Ausführung beginnen... ✓

Nächste Lernressourcen

• Offizielle Dokumentation: developers.openai.com/codex
• GitHub-Repository: github.com/openai/codex
• IDE-Integrationsanleitung: developers.openai.com/codex/ide
• API-Preisdetails: openai.com/api/pricing
• Community-Diskussion: GitHub Issues und Reddit r/OpenAI

Egal ob erfahrener Entwickler oder KI-Programmier-Anfänger – Codex CLI kann deinen Workflow erheblich verbessern. Beginne noch heute und lass KI dein Pair-Programming-Partner im Terminal werden!

---

Weiterführende Lektüre:

• Aider Komplette Anleitung 2026: Das Open-Source-KI-Pair-Programming-Wunderwerkzeug im Terminal
• Claude Code CLI Komplette Anleitung 2026
• OpenCode CLI Tiefenbewertung 2026