Codex CLI: The Definitive Technical Reference

Kurzfassung: Codex ist ein plattformübergreifender Coding-Agent, der Ihre Codebasis liest, Befehle in einer Sandbox auf Betriebssystemebene ausführt, Dateien patcht und Aufgaben in die Cloud delegiert. Beherrschen Sie fünf Kernsysteme (config.toml, Sandbox-/Genehmigungsmodell, AGENTS.md, MCP und Skills), und Codex wird zum Produktivitätsmultiplikator. Nutzen Sie Profile für den Kontextwechsel, /compact zur Verwaltung des Kontextbudgets und AGENTS.md für toolübergreifende Projektanweisungen, die in Codex, Cursor, Amp und weiteren Tools funktionieren. GPT-5.4 ist mittlerweile das empfohlene Modell mit 1M-Kontextfenstern.

Codex arbeitet als plattformübergreifender Coding-Agent — nicht als Chatbot, der Code schreibt. Die CLI liest Ihre Codebasis, führt Befehle in einer Sandbox aus, patcht Dateien, verbindet sich über MCP mit externen Diensten und delegiert langlaufende Aufgaben in die Cloud. Lokal ausgeführt, denkt Codex dennoch global: Dieselbe Intelligenz treibt vier verschiedene Oberflächen an, je nachdem wie Sie arbeiten.

Der Unterschied zwischen gelegentlicher und effektiver Codex-Nutzung liegt in fünf Kernsystemen. Beherrschen Sie diese, wird Codex zum Produktivitätsmultiplikator:

1. Konfigurationssystem: steuert das Verhalten über config.toml
2. Sandbox- und Genehmigungsmodell: kontrolliert, was Codex ausführen darf
3. AGENTS.md: definiert projektweite Betriebsvereinbarungen
4. MCP-Protokoll: erweitert die Funktionalität um externe Dienste
5. Skills-System: bündelt wiederverwendbare Fachexpertise in Paketen

Über Monate hinweg habe ich Codex parallel zu Claude Code in Produktionscodebases, CI/CD-Pipelines und Team-Workflows eingesetzt. Dieser Leitfaden destilliert diese Erfahrung in die vollständige Referenz, die ich mir zu Beginn gewünscht hätte. Zu jeder Funktion finden Sie die tatsächliche Syntax, praxisnahe Konfigurationsbeispiele und die Stolperfallen, die selbst erfahrenen Nutzern begegnen.

Hinweis zur Stabilität: Mit [EXPERIMENTAL] gekennzeichnete Funktionen können sich zwischen Releases ändern. Codex Cloud, die MCP-Befehlsgruppe, der Code-Modus und die Hooks-Engine sind seit v0.117.0 experimentell. Die CLI-Kernfunktionalität, Sandbox, AGENTS.md, config.toml, Skills und das Plugin-System sind stabil.

Die wichtigsten Erkenntnisse

• Vier Oberflächen, ein Gehirn: CLI, Desktop-App, IDE-Erweiterung und Cloud-Aufgaben nutzen alle dieselbe GPT-5.x-Codex-Intelligenz — wählen Sie die Oberfläche, die zu Ihrem Workflow passt.
• Sandboxing auf Betriebssystemebene: Codex erzwingt Dateisystem- und Netzwerkbeschränkungen auf Kernel-Ebene (Seatbelt unter macOS, Landlock + seccomp unter Linux), nicht innerhalb von Containern.
• AGENTS.md ist toolübergreifend: Ihre Projektanweisungen funktionieren in Codex, Cursor, Copilot, Amp, Jules, Gemini CLI, Windsurf, Cline, Aider, Zed und über 60.000 Open-Source-Projekten. Einmal schreiben, überall verwenden.
• Profile sparen Kontextwechsel-Aufwand: Definieren Sie benannte Konfigurations-Presets (fast, careful, auto) und wechseln Sie mit --profile zwischen ihnen.
• Kontextmanagement ist entscheidend: GPT-5.4 bietet 1M Kontext; GPT-5.3-Codex stellt 272K Input bereit. In beiden Fällen sollten Sie /compact, fokussierte Prompts und @file-Referenzen nutzen, um Token-Budgets proaktiv zu verwalten.

So verwenden Sie diesen Guide

Dies ist eine Referenz mit über 2.500 Zeilen — steigen Sie dort ein, wo Ihr Erfahrungslevel passt:

Die Kurzreferenzkarte am Ende bietet eine übersichtliche Zusammenfassung aller wichtigen Befehle.

So funktioniert Codex: Das mentale Modell

Bevor Sie sich in die Funktionen vertiefen, sollten Sie verstehen, wie die Architektur von Codex alles beeinflusst, was Sie damit tun. Das System arbeitet über vier Oberflächen, die auf einer gemeinsamen Intelligenzschicht basieren:

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

Kernschicht: Die GPT-5.x-Codex-Modellfamilie treibt alles an. Seit v0.111.0 ist gpt-5.4 das empfohlene Modell — OpenAIs führendes Frontier-Modell, das die Programmierfähigkeiten von GPT-5.3-Codex mit stärkerem Reasoning, nativer Computernutzung und 1M-Kontextfenstern vereint.⁶⁶ Es liest Dateien, schreibt Patches, führt Shell-Befehle aus und analysiert Ihre Codebasis. Wenn der Kontext voll wird, komprimiert Codex die Konversation, um Platz freizugeben. Diese Schicht verbraucht Tokens.

Sicherheitsschicht: Jeder Befehl, den Codex ausführt, durchläuft eine Sandbox auf Betriebssystemebene. Unter macOS erzwingt Apples Seatbelt-Framework Beschränkungen auf Kernel-Ebene. Unter Linux filtern Landlock + seccomp Dateisystem- und Syscall-Zugriffe. Die Sandbox arbeitet auf Kernel-Ebene, nicht innerhalb von Containern. Die Genehmigungsrichtlinie bestimmt dann, wann eine menschliche Bestätigung erforderlich ist.

Erweiterungsschicht: MCP verbindet externe Dienste (GitHub, Figma, Sentry). Skills bündeln wiederverwendbare Workflows, die Codex bei Bedarf lädt. Apps stellen Verbindungen zu ChatGPT-Konnektoren her. Die Websuche liefert Echtzeitkontext aus dem Internet.

Oberflächenschicht: CLI für Terminal-Poweruser und Automatisierung. Desktop-App für mehrgleisiges Projektmanagement. IDE-Erweiterung für enge Edit-Compile-Test-Schleifen. Cloud für asynchrone Aufgaben, die unabhängig laufen.

Die zentrale Erkenntnis: Die meisten Nutzer verwenden nur eine Oberfläche. Poweruser nutzen alle vier: Cloud für langlaufende Aufgaben, CLI für deterministische Repository-Operationen, IDE-Erweiterung für enge Programmierzyklen und die Desktop-App für Planung und Koordination.

Inhaltsverzeichnis

1. Wie installiere ich Codex?
2. Schnellstart: Ihre erste Sitzung
3. Zentrale Interaktionsoberflächen
4. Konfigurationssystem im Detail
5. Welches Modell sollte ich wählen?
6. Was kostet Codex?
7. Entscheidungsrahmen
8. Wie funktioniert das Sandbox- und Genehmigungssystem?
9. Wie funktioniert AGENTS.md?
10. Hooks
11. Was ist MCP (Model Context Protocol)?
12. Code Mode
13. JavaScript REPL Runtime
14. Was sind Skills?
15. Plugins
16. Plan Mode und Zusammenarbeit
17. Gedächtnissystem
18. Sitzungsverwaltung
19. Nicht-interaktiver Modus (codex exec)
20. Codex Cloud und Hintergrundaufgaben
21. Die Codex Desktop-App
22. GitHub Action und CI/CD
23. Codex SDK
24. Leistungsoptimierung
25. Wie behebe ich Probleme?
26. Enterprise-Deployment
27. Best Practices und Anti-Patterns
28. Workflow-Rezepte
29. Migrationsguide
30. Kurzreferenzkarte
31. Changelog
32. Referenzen

Wie installiere ich Codex?

Paketmanager

# 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

Direktes Installationsskript (v0.106.0+)

Für macOS und Linux steht ein einzeiliges Installationsskript als GitHub-Release-Asset zur Verfügung:⁶²

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

Das Skript erkennt automatisch Ihre Plattform und Architektur, lädt die passende Binärdatei herunter und platziert sie in Ihrem PATH.

Binäre Downloads

Für Umgebungen ohne npm oder Homebrew können Sie plattformspezifische Binärdateien von den GitHub Releases herunterladen¹:

Systemvoraussetzungen

• macOS: Apple Silicon oder Intel (volle Sandbox-Unterstützung über Seatbelt)
• Linux: x86_64 oder arm64 (Sandbox über Landlock + seccomp)
• Windows: Native Sandbox mit eingeschränkten Tokens (seit v0.100.0 aus dem Experimentalstatus heraufgestuft). WSL wird ebenfalls unterstützt²

Authentifizierung

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

Zwei Authentifizierungswege:

1. ChatGPT-Konto (empfohlen): Melden Sie sich mit Ihrem bestehenden Plus-, Pro-, Team-, Business-, Edu- oder Enterprise-Abonnement an. Vollständiger Funktionszugang einschließlich Cloud-Aufgaben.
2. API Key: Setzen Sie ihn über die Umgebungsvariable CODEX_API_KEY oder mit codex login --with-api-key. Einige Funktionen (Cloud Threads) sind möglicherweise nicht verfügbar.

Expertentipp: Der Speicherort für Anmeldedaten lässt sich über cli_auth_credentials_store in config.toml konfigurieren. Optionen: file (Standard), keyring (Betriebssystem-Schlüsselbund) oder auto (Schlüsselbund falls verfügbar, andernfalls Datei).

Shell-Vervollständigung

# 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

Installation überprüfen

codex --version
# Codex CLI v0.104.0

Schnellstart: Ihre erste Sitzung

In 5 Minuten von null auf produktiv.

1. Installieren und authentifizieren:

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

2. Zu einem Projekt navigieren:

cd ~/my-project                  # Any git repo works

3. Codex starten:

codex

Die interaktive TUI erscheint. Codex liest Ihre Projektstruktur automatisch ein.

4. Eine Frage stellen:

> What does this project do? Summarize the architecture.

Codex liest zentrale Dateien und erklärt die Codebasis. Im Standard-Modus suggest werden keine Änderungen vorgenommen.

5. Eine Änderung vornehmen:

> Add input validation to the login endpoint

Codex schlägt Bearbeitungen als Diff vor. Prüfen und mit y bestätigen oder mit n ablehnen.

6. Einen Slash Command verwenden:

> /plan Refactor the database layer to use connection pooling

Codex erstellt einen Plan, ohne ihn auszuführen. Prüfen Sie den Plan und genehmigen Sie ihn, um die Ausführung zu starten.

7. Ihre Arbeit überprüfen:

> /diff

Alle Änderungen anzeigen, die Codex in der aktuellen Sitzung vorgenommen hat.

Nächste Schritte: - AGENTS.md mit Projektanweisungen einrichten (siehe Wie funktioniert AGENTS.md?) - Ein Profil für Ihren Workflow konfigurieren (siehe Profile) - codex exec für nicht-interaktive Automatisierung ausprobieren (siehe Nicht-interaktiver Modus)

Zentrale Interaktionsoberflächen

Codex bietet vier verschiedene Oberflächen, die auf derselben Intelligenz basieren. Jede ist für ein bestimmtes Workflow-Muster optimiert.

1. Interaktive CLI (Terminal UI)

codex                        # Launch TUI
codex "fix the failing tests" # Launch with initial prompt
codex -m gpt-5.3-codex      # Specify model
codex --full-auto            # Workspace-write sandbox + on-request approval

Die Terminal UI ist eine Vollbild-Anwendung mit:

• Composer: Prompts eingeben, Dateien mit @ anhängen, Shell-Befehle mit dem Präfix ! ausführen
• Ausgabebereich: Streaming von Modellantworten, Tool-Aufrufen und Befehlsausgaben
• Statusleiste: Modell, Token-Verbrauch, Git-Branch, Sandbox-Modus

Wichtige TUI-Tastenkombinationen:

Slash Commands in der TUI:

2. Codex Desktop App (macOS + Windows)

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

Die Desktop-App bietet Funktionen, die über die CLI hinausgehen:

• Multitasking: Mehrere parallele Agenten gleichzeitig über verschiedene Projekte hinweg ausführen
• Git-Worktree-Isolation: Jeder Thread arbeitet auf einer isolierten Kopie Ihres Repos
• Integrierte Diff-Überprüfung: Änderungen stagen, zurücksetzen und committen, ohne die App zu verlassen
• Integriertes Terminal: Pro Thread ein Terminal zum Ausführen von Befehlen
• Konversations-Forking: Konversationen verzweigen, um Alternativen zu erkunden
• Schwebende Pop-out-Fenster: Konversationen in portable Fenster ablösen
• Automatisierungen: Wiederkehrende Aufgaben planen (Issue-Triage, CI-Überwachung, Alert-Reaktion)

Wann die App, wann die CLI? Nutzen Sie die Desktop-App, wenn Sie mehrere Arbeitsströme koordinieren oder eine visuelle Diff-Überprüfung benötigen. Nutzen Sie die CLI, wenn Sie Terminal-Komposierbarkeit, Skripting oder CI/CD-Integration bevorzugen.

3. IDE-Erweiterung (VS Code, Cursor, Windsurf)

Die Codex-IDE-Erweiterung integriert sich direkt in Ihren Editor:

• Agentenmodus als Standard: Liest Dateien, nimmt Bearbeitungen vor, führt Befehle aus
• Inline-Bearbeitungen: Kontextbezogene Vorschläge in Ihren aktiven Dateien
• Gemeinsame Sitzungen: Sitzungen werden zwischen CLI und IDE-Erweiterung synchronisiert
• Gleiche Authentifizierung: Anmeldung mit ChatGPT-Konto oder API-Schlüssel

Installation über den VS Code Marketplace oder die Cursor/Windsurf-Erweiterungsverzeichnisse.³

4. Codex Cloud [EXPERIMENTELL]

Cloud-Aufgaben laufen asynchron in von OpenAI verwalteten Umgebungen:

• Abschicken und vergessen: Aufgaben in die Warteschlange stellen, die unabhängig von Ihrem lokalen Rechner ausgeführt werden
• Parallele Ausführung: Mehrere Cloud-Aufgaben gleichzeitig starten
• PR-Erstellung: Codex erstellt Pull Requests aus abgeschlossener Arbeit
• Lokales Anwenden: Cloud-Ergebnisse mit codex apply <TASK_ID> in Ihr lokales Repo übernehmen

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

Cloud-Aufgaben sind außerdem über chatgpt.com/codex zugänglich.⁴

Konfigurationssystem im Detail

Codex verwendet TOML für die Konfiguration. Das Verständnis der Vorranghierarchie ist entscheidend, da sie bestimmt, welche Einstellungen bei Konflikten gelten.

Vorrang (Höchste bis Niedrigste Priorität)

1. Sitzungsüberschreibungen (höchste): CLI-Flags (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) und -c key=value-Überschreibungen
2. Projektkonfiguration (.codex/config.toml, wird vom aktuellen Arbeitsverzeichnis aufwärts bis zum Projektstamm gesucht; das nächstgelegene Verzeichnis hat Vorrang)
3. Benutzerkonfiguration ($CODEX_HOME/config.toml, Standard ist ~/.codex/config.toml)
4. Systemkonfiguration (/etc/codex/config.toml unter Unix)
5. Eingebaute Standardwerte (niedrigste)

requirements.toml fungiert als Richtlinien-Einschränkungsebene, die festlegt, welche Werte Benutzer nach der normalen Konfigurationszusammenführung auswählen können. Siehe Enterprise-Bereitstellung.

Speicherorte der Konfigurationsdateien

Expertentipp: Die Umgebungsvariable CODEX_HOME überschreibt das Standardverzeichnis ~/.codex. Nützlich für CI/CD- oder Multi-Account-Konfigurationen.

Vollständige Konfigurationsreferenz

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.3-codex"                # Default model (272K input context)
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_context_window = 272000           # 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.2-codex"         # Model for /review command
oss_provider = "lmstudio"              # lmstudio|ollama (used with --oss)

# ─── Sandbox & Approval ───────────────────────────────
sandbox_mode = "workspace-write"        # read-only|workspace-write|danger-full-access
approval_policy = "on-request"          # untrusted|on-failure|on-request|never

[sandbox_workspace_write]
writable_roots = []                     # Additional writable paths
network_access = false                  # Allow outbound network
exclude_tmpdir_env_var = false          # Exclude $TMPDIR from sandbox
exclude_slash_tmp = false               # Exclude /tmp from sandbox

# ─── Web Search ────────────────────────────────────────
web_search = "live"                     # Web search mode (constrained by allowed modes)

# ─── Instructions ──────────────────────────────────────
developer_instructions = ""             # Additional injected instructions
model_instructions_file = ""            # Custom instructions file path
compact_prompt = ""                     # Custom history compaction prompt

# ─── Shell Environment ─────────────────────────────────
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

# ─── UI & Display ──────────────────────────────────────
file_opener = "vscode"                  # vscode|vscode-insiders|windsurf|cursor|none
hide_agent_reasoning = false
show_raw_agent_reasoning = false
check_for_update_on_startup = true

[tui]
notifications = false                   # Enable notifications
notification_method = "auto"            # auto|osc9|bel
animations = true
show_tooltips = true
alternate_screen = "auto"               # auto|always|never
status_line = ["model", "context-remaining", "git-branch"]

# ─── Project Trust ─────────────────────────────────────
project_doc_max_bytes = 32768           # Max AGENTS.md size (32 KiB)
project_doc_fallback_filenames = []     # Alternative instruction filenames
project_root_markers = [".git"]         # Project root detection

# ─── Feature Flags ─────────────────────────────────────
# Use `codex features list` for current names/stages/defaults.
[features]
shell_tool = true                       # Shell command execution (stable)
collaboration_modes = true              # Plan mode (stable)
personality = true                      # Personality selection (stable)
request_rule = true                     # Smart approvals (stable)
unified_exec = true                     # PTY-backed exec (stable)
shell_snapshot = true                   # Shell env snapshots (stable)
command_attribution = true              # Codex co-author in commits (v0.103.0+)
request_user_input = true               # Allow agent to ask clarifying questions in Default mode (v0.106.0+)
multi_agent = false                     # Enable multi-agent collaboration tools (v0.102.0+)
apply_patch_freeform = false            # Expose freeform apply_patch tool
apps = false                            # ChatGPT Apps/connectors (experimental)
child_agents_md = false                 # AGENTS.md guidance (experimental)
runtime_metrics = false                 # Runtime summary in turns
search_tool = false                     # Enable search_tool_bm25 for Apps discovery

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

Profile

Benannte Konfigurations-Presets für verschiedene Arbeitsmodi:

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

Aktivieren Sie ein Profil:

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

Expertentipp: Legen Sie ein Standardprofil mit profile = "fast" auf der obersten Ebene Ihrer Konfiguration fest. Überschreiben Sie es pro Sitzung mit --profile.

Benutzerdefinierte Modellanbieter

Verbindung zu Azure, lokalen Modellen oder Proxy-Diensten herstellen:

[model_providers.azure]
name = "Azure OpenAI"
base_url = "https://YOUR_PROJECT.openai.azure.com/openai"
wire_api = "responses"
query_params = { api-version = "2025-04-01-preview" }
env_key = "AZURE_OPENAI_API_KEY"

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

Warnung: Die chat/completions-Wire-API (wire_api = "chat") wurde für von OpenAI gehostete Modelle als veraltet markiert, wobei OpenAI die Entfernung im Februar 2026 ankündigte.³⁶ Lokale Anbieter (Ollama, LM Studio) akzeptieren dieses Format möglicherweise weiterhin. Verwenden Sie für OpenAI-Endpunkte stattdessen wire_api = "responses".

Verwenden Sie lokale Modelle mit dem --oss-Flag:

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

Oder in der Konfiguration festlegen:

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

Inline-Konfigurationsüberschreibungen

Überschreiben Sie jeden Konfigurationswert über die Befehlszeile:

codex -c model="gpt-5.2-codex" "refactor the API"
codex -c 'sandbox_workspace_write.network_access=true' "install dependencies"
codex -c model_reasoning_effort="xhigh" "debug the race condition"

Welches Modell sollte ich wählen?

Verfügbare Modelle (März 2026)

GPT-5.4 ist über alle Codex-Oberflächen verfügbar (CLI, App, IDE-Erweiterung, Cloud).⁶⁶ Die genaue Modellliste variiert je nach Konto und Rollout. Prüfen Sie Ihren lokalen Cache: ~/.codex/models_cache.json.

Hinweis zur Einstellung (11. März 2026): GPT-5.1-Modelle sind in ChatGPT nicht mehr verfügbar. Bestehende Unterhaltungen werden automatisch auf GPT-5.3 Instant, GPT-5.4 Thinking oder GPT-5.4 Pro fortgesetzt. GPT-5.1-Codex-Mini bleibt über API und CLI für kostenoptimierte Arbeitslasten verfügbar.⁷³

Modellauswahl-Flussdiagramm

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
   │     ├─ Pure coding task (refactor, migration, feature build)?
   │     │  ├─ Yes → gpt-5.3-codex (coding specialist, 272K context)
   │     │  └─ No → gpt-5.4 (recommended: coding + reasoning + computer use, 1M context)
   └─ Still unsure? → gpt-5.4

Reasoning-Aufwand

Steuern Sie, wie intensiv das Modell „nachdenkt”, bevor es antwortet:

Unterstützte Stufen sind modellabhängig. minimal ist nur für GPT-5-Modelle verfügbar. Nicht alle Modelle unterstützen jede Stufe.

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

Expertentipp: xhigh-Reasoning kann für denselben Prompt 3–5× mehr Token verbrauchen als medium. Reservieren Sie es für wirklich schwierige Probleme, bei denen sich das zusätzliche Nachdenken auszahlt.

Modellwechsel

Wechseln Sie Modelle mitten in der Sitzung mit dem /model slash command, oder legen Sie es pro Ausführung über --model / -m fest:

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

Was kostet Codex?

Siehe auch Modellauswahl für Fähigkeiten und Entscheidungsframeworks für die Wahl des richtigen Modells pro Aufgabe.

Zugang über ChatGPT-Tarife

Die Codex-Verfügbarkeit hängt von Ihrem ChatGPT-Tarif und Ihren Organisationseinstellungen ab:⁵³

Aktionstarife: Der kostenlose/Go-Zugang und die 2× Ratenlimits für kostenpflichtige Tarife fielen mit dem Start der Codex Desktop App zusammen (Februar 2026). Diese erhöhten Limits gelten für alle Oberflächen — App, CLI, IDE und Cloud. OpenAI hat kein Enddatum angekündigt.¹⁷

Credit-Kosten

Codex-Operationen verbrauchen Credits aus Ihrem Tarifkontingent:

Enterprise- und Edu-Tarife skalieren Credits mit der Vertragszuweisung. Prüfen Sie /status im TUI für die aktuelle Nutzung.

API-Abrechnung

Bei Verwendung von Codex über die API berechnet OpenAI die Nutzung pro Token gemäß der Standard-Preisgestaltung der OpenAI API für das gewählte Modell (zuzüglich etwaiger Prompt-Caching-Rabatte). Aktuelle Tarife finden Sie auf der offiziellen API-Preisseite.²¹

Strategien zur Kostenoptimierung

1. Profile verwenden: Erstellen Sie ein fast-Profil mit gpt-5.1-codex-mini und model_reasoning_effort = "low" für Routineaufgaben
2. Hohes Reasoning reservieren: Verwenden Sie xhigh nur für wirklich schwierige Probleme, da es 3–5× mehr Token kostet
3. --ephemeral verwenden: Überspringen Sie die Sitzungspersistenz in CI/CD, um den Overhead zu reduzieren
4. Reasoning-Zusammenfassungen minimieren: Setzen Sie model_reasoning_summary = "none", wenn Sie keine Erklärungen benötigen
5. Batchverarbeitung mit exec-Modus: codex exec vermeidet TUI-Overhead bei Automatisierungs-Workflows
6. Nutzung überwachen: Prüfen Sie /status im TUI und die Abrechnungs-Dashboards Ihrer Organisation

Praxisnahe Kostenbeispiele

Repräsentative API-Kosten für häufige Aufgaben (gpt-5.3-codex zu Standardpreisen, Reasoning auf medium):

Die Kosten variieren je nach Reasoning-Aufwand, Caching und Gesprächslänge. Verwenden Sie gpt-5.1-codex-mini für Routineaufgaben, um die Kosten um ca. 40–60 % zu senken. Gecachte Eingabe-Token werden mit einem Rabatt abgerechnet.

Versteckter Token-Overhead

Jeder Tool-Aufruf fügt über Ihren sichtbaren Prompt hinaus Token hinzu:

Expertentipp: Überwachen Sie Ihre tatsächliche Nutzung über /status im TUI. Die Token-Anzahl umfasst den gesamten Overhead, nicht nur Ihre sichtbaren Nachrichten. Falls Sie die Kosten überraschen, prüfen Sie, wie viele MCP-Server verbunden sind — jeder fügt Tool-Definitionen zu jedem API-Aufruf hinzu.

Kostenmanagement für Teams

Strategien zur Kostenkontrolle im Team: - requirements.toml festlegen, um Modell- und Reasoning-Aufwand-Limits organisationsweit durchzusetzen - gpt-5.1-codex-mini für CI/CD verwenden — automatisierte Pipelines benötigen selten maximales Reasoning - Profilbasierte Budgetierung — definieren Sie ci-, review- und dev-Profile mit angemessenen Kostenobergrenzen - Überwachung via OpenTelemetry — Enterprise-Deployments können Nutzungstelemetrie in bestehende Observability-Stacks exportieren

Entscheidungsrahmen

Wann welche Oberfläche verwenden

Wann welchen Sandbox-Modus verwenden

Wann welche Reasoning-Stufe verwenden

Plan-Modus vs. direkte Ausführung

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

Steer-Modus: Enter vs. Tab

Faustregel: Enter = „Stopp, hör jetzt zu.” Tab = „Wenn du fertig bist, mach auch noch das.”

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

Welches Profil?

Ordnen Sie Ihre Aufgabe einem vorkonfigurierten Profil zu:

config.toml-Einrichtung:

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

Profil pro Sitzung wechseln: codex --profile careful

Wie funktioniert das Sandbox- und Approval-System?

Codex verwendet ein zweischichtiges Sicherheitsmodell, das trennt, was technisch möglich ist, von wann Codex eine menschliche Genehmigung einholt. Der Ansatz unterscheidet sich grundlegend vom Berechtigungssystem von Claude Code — Codex setzt Einschränkungen auf Betriebssystem-Kernel-Ebene durch.⁵ Siehe auch Enterprise Deployment für requirements.toml-Einschränkungen, die Administratoren organisationsweit durchsetzen.

Schicht 1: Sandbox (Was möglich ist)

Die Sandbox steuert Dateisystem- und Netzwerkzugriff mithilfe betriebssystemeigener Mechanismen:

Plattformspezifische Durchsetzung:

• macOS: Apples Seatbelt-Framework über sandbox-exec mit modusspezifischen Profilen, die zur Laufzeit kompiliert und vom Kernel durchgesetzt werden⁶
• Linux: Landlock für Dateisystembeschränkungen + seccomp für Syscall-Filterung. Ein eigenständiger Hilfsprozess (codex-linux-sandbox) bietet Defense-in-Depth-Isolation.⁵ Bubblewrap (bwrap) wird mitgeliefert und als Teil des Linux-Builds kompiliert (seit v0.100.0 von optional hochgestuft)⁷. Version 0.117.0 verbesserte die Sandbox-Zuverlässigkeit auf älteren Distributionen mit Legacy-Kernel-Konfigurationen.⁷⁷
• Windows: Native Sandbox mit eingeschränkten Tokens (seit v0.100.0 von experimentell hochgestuft). WSL wird ebenfalls unterstützt (erbt Linux Landlock + seccomp). Version 0.117.0 enthält Verbesserungen der Restricted-Token-Sandbox für bessere Prozessisolation.⁷⁷

Warum das wichtig ist: Im Gegensatz zu containerbasierten Sandboxing-Lösungen (Docker) ist Sandboxing auf Betriebssystemebene schneller, schlanker und schwerer zu umgehen. Der Kernel setzt Einschränkungen durch, bevor Codex den Systemaufruf überhaupt sieht.

Sicherheitskorrekturen: - zsh-fork Sandbox-Bypass (v0.106.0): Eine Schwachstelle wurde behoben, bei der Shell-Ausführung über zsh-Forking die Sandbox-Beschränkungen umgehen konnte.⁶² Falls Sie eine ältere Version verwenden, aktualisieren Sie umgehend. - Eingabegrößenbeschränkung (v0.106.0): Codex erzwingt jetzt eine Eingabeobergrenze von etwa 1 Million Zeichen, um Hänger durch übermäßig große Payloads zu verhindern.⁶² - Linux /dev-Dateisystem (v0.105.0): Sandbox-Befehle unter Linux erhalten nun ein minimales /dev-Dateisystem, was die Kompatibilität mit Tools verbessert, die Gerätknoten erwarten.⁶³

ReadOnlyAccess-Richtlinie (v0.100.0+): Eine konfigurierbare Richtlinienform für granulare Lesezugriffskontrolle. Verwenden Sie sie, um einzuschränken, aus welchen Verzeichnissen Codex lesen darf — selbst im workspace-write-Modus:

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

Schicht 2: Approval Policy (Wann gefragt wird)

Die Approval Policy bestimmt, wann Codex pausiert und um menschliche Bestätigung bittet:

Eindeutige Approval-IDs (v0.104.0+)

Codex weist nun jedem Befehl innerhalb einer mehrstufigen Shell-Ausführung eindeutige Approval-IDs zu. Dadurch sind Genehmigungen granular — die Genehmigung eines Befehls in einer Sequenz genehmigt nicht automatisch nachfolgende Befehle in derselben Shell-Ausführung.⁵¹

Flexible Approval-Steuerung (v0.105.0+)

Der Genehmigungsablauf unterstützt jetzt zusätzliche Sandbox-Berechtigungen und granulare Ablehnung:⁶³

• Zusätzliche Sandbox-Berechtigungen: Wenn ein Befehl Zugriff über den aktuellen Sandbox-Modus hinaus benötigt, kann Codex spezifische zusätzliche Berechtigungen anfordern, anstatt einen vollständigen Moduswechsel zu verlangen
• Granulare Ablehnung: Einzelne Tool-Aufrufe können mit Feedback abgelehnt werden, sodass Codex seinen Ansatz anpassen kann, anstatt denselben Befehl einfach erneut auszuführen

Laufzeit-Berechtigungsanfragen (v0.113.0+)

Codex enthält jetzt ein integriertes request_permissions-Tool, mit dem das Modell zur Laufzeit zusätzliche Berechtigungen anfordern kann.⁷¹ Wenn das Modell auf eine Aufgabe stößt, die erhöhte Zugriffsrechte erfordert, kann es über den TUI-Genehmigungsablauf formell bestimmte Berechtigungen (Dateisystempfade, Netzwerkzugriff usw.) anfordern, anstatt stillschweigend zu scheitern oder einen Neustart mit anderen Flags zu erfordern.

Permission-Profile-Konfigurationssprache (v0.113.0+)

Eine neue Konfigurationssprache für Berechtigungsprofile trennt Dateisystem- und Netzwerk-Sandbox-Richtlinien in separate, kombinierbare Abschnitte auf:⁷¹

[permission_profile.filesystem]
read = ["~/Projects", "/usr/local"]
write = ["~/Projects/my-app"]

[permission_profile.network]
allow = ["api.github.com", "registry.npmjs.org"]
deny = ["*"]   # Global wildcard domains now rejected (hardened in v0.113.0)

Dies ersetzt den monolithischen Sandbox-Modus durch feingranulare, ressourcenbezogene Richtlinien. Ausführbare Berechtigungsprofile lassen sich außerdem mit der Pro-Turn-Sandbox-Richtlinie für die Skill-Ausführung integrieren (v0.112.0).⁷⁰

Das --full-auto-Flag

--full-auto ist ein praktischer Alias für:

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

Kritischer Fallstrick: --full-auto überschreibt jeden expliziten --sandbox-Wert. Wenn Sie --full-auto --sandbox read-only übergeben, erhalten Sie workspace-write, weil --full-auto Vorrang hat.⁸

Empfohlene Konfigurationen

Tägliche Entwicklung (sicherer Standard):

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

Power-User (voller Zugriff, Mensch in der Schleife):

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

Diese Kombination gilt in der Community als empfohlener „Sweet Spot”: maximale Fähigkeiten, aber Genehmigung für jeden einzelnen Befehl erforderlich.⁹

CI/CD-Automatisierung:

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

Smart Approvals mit Guardian-Subagent (v0.115.0+)

Smart Approvals können Überprüfungsanfragen über einen Guardian-Subagenten leiten, anstatt für jede Aktion eine menschliche Genehmigung zu verlangen. Die Guardian-Sitzung bleibt über Genehmigungen hinweg bestehen, um den Prompt-Cache wiederzuverwenden und Startaufwand zu vermeiden. Jede Überprüfung erhält eine saubere Historie (frühere Entscheidungen fließen nicht in spätere Überprüfungen ein).⁷⁵

Konfigurieren Sie den Reviewer in config.toml:

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

Dies ist besonders nützlich für CI/CD-Workflows, bei denen Sie eine automatisierte Überprüfung mit Begründung wünschen, anstatt pauschal approval_policy = "never" zu setzen.

Netzwerkzugriff aktivieren

Codex blockiert den Netzwerkzugriff im workspace-write-Modus standardmäßig. Aktivieren Sie ihn bei Bedarf:

# 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

WebSocket-Proxy-Unterstützung (v0.104.0+)

Für Unternehmensumgebungen, die WebSocket-Datenverkehr über einen Proxy leiten, unterstützt Codex jetzt die Umgebungsvariablen WS_PROXY und WSS_PROXY:⁵¹

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

Diese ergänzen die bestehende HTTPS_PROXY- und SOCKS5-Proxy-Unterstützung (v0.93.0+) und decken alle Transportschichten ab.

Sandbox testen

Überprüfen Sie das Sandbox-Verhalten, bevor Sie ihm vertrauen:

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

Wenn die Sandbox korrekt funktioniert, sollten beide Befehle mit einem „Permission denied”-Fehler fehlschlagen — die Sandbox verhindert das Lesen sensibler Systemdateien selbst im --full-auto-Modus. Falls einer der Befehle erfolgreich ist, muss Ihre Sandbox-Konfiguration untersucht werden.

Wie funktioniert AGENTS.md?

AGENTS.md ist das Projektanweisungssystem von Codex — ein offener Standard¹⁰, der inzwischen von der Agentic AI Foundation der Linux Foundation verwaltet wird. Unterstützt von Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode und über 60.000 Open-Source-Projekten. Es legt fest, wie sich Codex innerhalb eines bestimmten Repositorys oder Verzeichnisses verhält. Siehe Skills für wiederverwendbare Expertisepakete, die AGENTS.md ergänzen.

Erkennungshierarchie

Codex erstellt beim Sitzungsstart eine Anweisungskette, indem es den Verzeichnisbaum durchläuft:

1. Global (~/.codex/): AGENTS.override.md > AGENTS.md
2. Projekt (Git-Root bis zum aktuellen Verzeichnis): Jede Ebene wird auf AGENTS.override.md > AGENTS.md > Fallback-Dateinamen geprüft
3. Zusammenführung: Dateien werden von der Wurzel abwärts verkettet; näher gelegene Dateien erscheinen später im Prompt und überschreiben frühere Anweisungen

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

Was eine gute AGENTS.md ausmacht

Basierend auf direkten Empfehlungen von Codex selbst und Community-Mustern¹¹:

EMPFOHLEN: - Seien Sie konkret: "Use rg --files for discovery" ist besser als "search efficiently" - Definieren Sie Abschlusskriterien: Was bedeutet „fertig”? (Tests bestanden, Lint sauber usw.) - Geben Sie Befehle an: Build, Test, Lint, Format (exakte Aufrufe) - Gliedern Sie nach Aufgaben: Abschnitte für Coding, Review, Release, Incident/Debug - Definieren Sie Eskalation: Was tun bei Blockaden oder unerwartetem Zustand

VERMEIDEN: - Komplette Styleguides ohne Ausführungsregeln einfügen - Vage Anweisungen verwenden („sei vorsichtig”, „optimiere”) - Widersprüchliche Prioritäten mischen (Geschwindigkeit + erschöpfende Verifizierung + kein Laufzeitbudget) - Prosadokumentation schreiben (AGENTS.md ist eine operative Richtlinie, kein README)

Beispiel: Produktionsreife AGENTS.md

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

Der Override-Mechanismus

AGENTS.override.md auf jeder Verzeichnisebene ersetzt die normale AGENTS.md für diesen Geltungsbereich. Einsatzmöglichkeiten:

• Release-Freezes: „Keine neuen Funktionen, nur Fehlerbehebungen”
• Incident-Modus: „Alle Änderungen müssen vom Bereitschaftsdienst geprüft werden”
• Temporäre Härtung: „Keine Abhängigkeitsupdates in diesem Sprint”

Konfiguration

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

Scaffold-Generierung

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

Oder überprüfen Sie Ihre Anweisungskette:

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

Hooks

Codex führte Hooks in v0.99.0 (AfterAgent) und v0.100.0 (AfterToolUse) ein und ergänzte dann in v0.114.0 eine experimentelle Hook-Engine mit SessionStart- und Stop-Events.⁷² Das System deckt inzwischen den gesamten Sitzungslebenszyklus sowie Automatisierung auf Tool-Ebene ab und schließt damit die Lücke zum Hook-Modell von Claude Code.

Verfügbare Hook-Events

Hook-Konfiguration

Hooks werden in .codex/config.toml konfiguriert:

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

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

Die Standardausgabe des SessionStart-Hooks fließt in den Modellkontext ein — ideal, um dynamische Informationen (Datum, Branchnamen, Umgebungsvariablen) beim Sitzungsstart zu injizieren.

Claude Code-Hook-Muster replizieren

Falls Sie von Claude Code migrieren, lässt sich vergleichbare Automatisierung folgendermaßen erreichen:

Expertentipp: Die Hook-Engine ist experimentell und wird aktiv erweitert. Prüfen Sie das Codex-Changelog auf neue Hook-Events in jeder Version.

Was ist MCP (Model Context Protocol)? [EXPERIMENTAL]

MCP erweitert die Fähigkeiten von Codex, indem es Verbindungen zu externen Tools und Diensten herstellt. Die Befehlsgruppe codex mcp ist derzeit als experimentell gekennzeichnet, und sowohl Befehle als auch Konfigurationsformat können sich zwischen Releases ändern. Codex unterstützt zwei Transporttypen: STDIO (lokale Prozesse) und Streamable HTTP (Remote-Server).¹²

MCP-Server konfigurieren

STDIO-Server (lokale Prozesse):

# 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

HTTP-Server (Remote):

[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

CLI-Verwaltung

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

Innerhalb einer Sitzung zeigt /mcp die aktiven Server und verfügbaren Tools an.

Codex ALS MCP-Server betreiben

Codex kann sich selbst als MCP-Server für die Multi-Agenten-Orchestrierung bereitstellen:¹³

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

Der Server stellt zwei Tools bereit: 1. codex(): Startet eine neue Sitzung mit Prompt-, Sandbox-, Modell- und Genehmigungsparametern 2. codex-reply(): Setzt eine bestehende Sitzung mit threadId und Prompt fort

Verwendung mit dem Agents SDK (Python):

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    name="Codex CLI",
    params={"command": "npx", "args": ["-y", "codex", "mcp-server"]},
    client_session_timeout_seconds=360000,
) as codex_mcp_server:
    agent = Agent(name="Developer", mcp_servers=[codex_mcp_server])
    result = await Runner.run(agent, "Fix the failing tests")

Wichtige MCP-Server

Praktische Muster

Muster 1: Kontextbewusste Entwicklung — Kombinieren Sie Context7 mit Ihrer Framework-Dokumentation, damit Codex stets aktuelle API-Referenzen zur Verfügung hat:

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

Muster 2: Ausgabelimits — MCP-Tool-Antworten werden standardmäßig bei ca. 25.000 Zeichen abgeschnitten. Verwenden Sie bei Tools mit umfangreichen Rückgabedaten (Datenbankabfragen, Log-Erfassungen) enabled_tools, um die Auswahl auf bestimmte Tools einzuschränken und die Antworten fokussiert zu halten.

Muster 2a: Multimodale Tool-Ausgabe (v0.107.0) — Benutzerdefinierte Tools können nun multimodale Ausgaben (Bilder, Rich Content) zusammen mit Text zurückgeben. Dadurch können Tools, die visuelle Artefakte erzeugen — Screenshots, Diagramme, Diagramm-Renderings — diese direkt an das Modell zur Analyse übergeben.⁶⁴

Muster 3: MCP-Governance im Unternehmen — Legen Sie über requirements.toml fest, welche MCP-Server Entwickler verwenden dürfen:

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

Jeder Server, der keiner Identität in requirements.toml entspricht, wird beim Start blockiert. Siehe Enterprise Deployment für die vollständige Richtlinienkonfiguration.

Code Mode [EXPERIMENTAL]

Code Mode (v0.114.0) bietet stärker isolierte Programmier-Workflows, indem der Handlungsrahmen des Agenten auf Code-fokussierte Operationen beschränkt wird.⁷² Ist diese Funktion aktiviert, konzentriert sich der Agent auf das Lesen, Schreiben und Testen von Code — ohne weitergehende Systeminteraktionen.

Diese Funktion ist experimentell. Prüfen Sie die Release-Notes auf Aktualisierungen.

JavaScript REPL Runtime [EXPERIMENTAL]

Codex v0.100.0 führte eine experimentelle JavaScript REPL Runtime (js_repl) ein, die den Zustand über Tool-Aufrufe hinweg beibehält. In v0.106.0 wurde die REPL zum Slash-Befehl /experimental befördert — mit Kompatibilitätsprüfungen beim Start, die Node.js 22.22.0 oder höher erfordern.⁶²

JS REPL aktivieren:

# In config.toml
[features]
js_repl = true

Alternativ kann die Aktivierung innerhalb einer Sitzung über /experimental im TUI erfolgen.

Anwendungsbeispiel: Bei aktivierter REPL kann Codex den Zustand über mehrere Tool-Aufrufe innerhalb einer Sitzung aufrechterhalten:

// Codex can accumulate data across multiple tool calls
const results = await fetchTestResults();
const failures = results.filter(r => r.status === "failed");
console.log(`${failures.length} failures out of ${results.length} tests`);
// Variable 'failures' persists and is available in subsequent tool calls

Voraussetzungen: Node.js 22.22.0+ (Kompatibilität wird beim Start geprüft). Version 0.105.0 brachte verbesserte Fehlerberichte und Wiederherstellungsmechanismen bei REPL-Ausfällen.⁶³

Diese Funktion ist experimentell. Die Schnittstelle kann sich zwischen Releases ändern.

Was sind Skills?

Skills sind wiederverwendbare, aufgabenspezifische Fähigkeitspakete, die Codex bei Bedarf lädt. Sie folgen dem offenen Agent-Skills-Standard.¹⁴

Skill-Struktur

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)

Speicherorte für die Erkennung

Codex speichert vom Benutzer installierte Skills in $CODEX_HOME/skills (Standard: ~/.codex/skills), einschließlich integrierter System-Skills unter .system/. Codex unterstützt symbolisch verlinkte Skill-Ordner.

Einen Skill erstellen

SKILL.md-Format:

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

## Sicherheitsaudit-Verfahren

1. Suchen Sie nach hartcodierten Geheimnissen mit `rg -i "(api_key|password|secret|token)\s*=" --type py`
2. Prüfen Sie auf SQL-Injection: Achten Sie auf String-Interpolation in Abfragen
3. Überprüfen Sie die Eingabevalidierung an allen API-Endpunkten
4. Prüfen Sie Abhängigkeiten auf Schwachstellen: `pip audit` oder `npm audit`
5. Überprüfen Sie Authentifizierungs- und Autorisierungsmuster
6. Dokumentieren Sie die Ergebnisse mit Schweregraden (Critical/High/Medium/Low)

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

Skills aufrufen

• Explizit: Über das /skills-Menü oder durch Erwähnung von $skill-name im Prompt
• Implizit: Codex erkennt automatisch passende Skills anhand der Aufgabenbeschreibung (sofern allow_implicit_invocation: true gesetzt ist)
• Erstellen: Verwenden Sie $skill-creator, um interaktiv einen neuen Skill zu erstellen
• Installieren: Verwenden Sie $skill-installer install <name>, um Community-Skills zu installieren

Aktivieren/Deaktivieren

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

Skills vs. Slash Commands

Skills debuggen

Falls ein Skill nicht aktiviert wird:

1. Prüfen Sie die Erkennung: /skills sollte ihn im TUI auflisten
2. Überprüfen Sie den Pfad: Stellen Sie sicher, dass sich der Skill-Ordner an einem erkannten Speicherort befindet (~/.codex/skills/, Projektstammverzeichnis oder /etc/codex/skills/)
3. Prüfen Sie enabled: Skills mit enabled = false in config.toml werden nicht geladen
4. Prüfen Sie die implizite Aktivierung: Wenn Sie auf automatische Erkennung setzen, stellen Sie sicher, dass allow_implicit_invocation: true in agents/openai.yaml gesetzt ist
5. Verwenden Sie Schlüsselwörter: Nehmen Sie die description-Begriffe des Skills in Ihren Prompt auf, um die implizite Zuordnung zu verbessern

Praxisbeispiel: Deploy-Skill

Ein vollständiger Skill mit mehreren Dateien, der Referenzen und Skripte kombiniert:

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

Aufruf mit: $deploy to staging oder $deploy production with canary rollout

Plugins

Plugins vereinen Skills, MCP-Einträge und App-Konnektoren in einem einzigen installierbaren Paket (v0.110.0+).⁶⁷ Seit v0.117.0 sind Plugins vollwertige Bestandteile: produktbezogene Plugins werden beim Start automatisch synchronisiert, /plugins bietet einen In-TUI-Browser zur Entdeckung und Verwaltung, und Installations-/Deinstallationsvorgänge funktionieren sowohl über CLI als auch über das TUI.⁷⁷

Plugin-Quellen

Plugin-Erkennung

Codex teilt dem Modell beim Sitzungsstart mit, welche Plugins aktiviert sind (v0.111.0), was die Auffindbarkeit installierter MCPs, Apps und Skills verbessert.⁶⁷ Das Modell kann während einer Sitzung basierend auf dem Aufgabenkontext relevante Plugins vorschlagen. In v0.117.0 werden produktbezogene Plugins beim Start synchronisiert, sodass der aktuelle Plugin-Katalog ohne manuellen Eingriff verfügbar ist.⁷⁷

@plugin-Erwähnungen (v0.112.0+)

Referenzieren Sie jedes installierte Plugin direkt im Chat mit @plugin-name.⁷⁰ Wenn Sie ein Plugin erwähnen, wird dessen Kontext (Fähigkeiten, Tools, Konfiguration) automatisch in das Kontextfenster des Modells aufgenommen — Sie müssen nicht beschreiben, was das Plugin kann.

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

Dies funktioniert mit jedem installierten Plugin, einschließlich benutzerdefinierter Skills, MCP-Server und App-Konnektoren.

Plugin-Marktplatz (v0.113.0+)

Der Plugin-Marktplatz bietet jetzt umfangreichere Entdeckungsmöglichkeiten mit Metadaten, Kategorien und Bewertungen.⁷¹ Authentifizierungsprüfungen bei der Installation stellen sicher, dass Plugins, die API-Schlüssel oder OAuth benötigen, über gültige Anmeldeinformationen verfügen. Ein Deinstallations-Endpunkt entfernt Plugins und ihre zugehörige Konfiguration sauber.

Plugins verwalten

codex plugin list              # Show installed plugins
codex plugin install <name>    # Install from marketplace
codex plugin uninstall <name>  # Remove plugin and config (v0.113.0+)

Im TUI können Sie über /plugins (v0.117.0+) Plugins interaktiv durchsuchen, installieren und entfernen, ohne Ihre Sitzung zu verlassen.⁷⁷

Expertentipp: Plugins konsolidieren, was früher separate MCP-Konfiguration, Skill-Installation und App-Konnektor-Einrichtung erforderte. Ein einzelnes Plugin kann alle drei bündeln — das beschleunigt das Team-Onboarding und macht die Konfiguration portabler.

Planmodus & Zusammenarbeit

Der Planmodus ermöglicht es Codex, einen Ansatz zu entwerfen, bevor Änderungen ausgeführt werden. Er ist standardmäßig aktiviert (seit v0.94.0).¹⁵ Siehe Entscheidungsrahmen für den Entscheidungsbaum „Planmodus vs. direkte Ausführung”.

Planmodus aktivieren

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

Im Planmodus verhält sich Codex wie folgt: - Liest Dateien und analysiert die Codebasis - Schlägt einen Implementierungsplan vor - Nimmt keine Änderungen vor, bis Sie zustimmen - Streamt den Plan in einer dedizierten TUI-Ansicht

Steuermodus

Der Steuermodus (standardmäßig aktiviert seit v0.98.0) ermöglicht es Ihnen, neue Anweisungen einzugeben, während Codex aktiv arbeitet, ohne die aktuelle Aufgabe zu unterbrechen.¹⁵

Es gibt zwei Eingabemethoden:

Praxisbeispiele:

# 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

Der Steuermodus ist im TUI immer aktiv. Wenn Sie lieber warten möchten, bis Codex fertig ist, bevor Sie neue Anweisungen geben, tippen Sie nach Abschluss des Durchgangs einfach normal — ein spezieller Modus ist dafür nicht erforderlich.

TUI-Verbesserungen (v0.105.0–v0.106.0)

Syntaxhervorhebung (v0.105.0): Das TUI hebt jetzt eingezäunte Codeblöcke und Diffs inline hervor. Verwenden Sie /theme, um ein Farbschema auszuwählen.⁶³

Neue TUI-Befehle (v0.105.0+):⁶³

Sprachtranskription (v0.105.0, experimentell): Drücken Sie die Leertaste, um Prompts per Sprachtranskription zu diktieren. Diese Funktion ist experimentell und erfordert möglicherweise Mikrofonberechtigungen.⁶³ Seit v0.107.0 unterstützen Echtzeit-Sprachsitzungen die Auswahl von Mikrofon- und Lautsprechergeräten, sodass Sie spezifische Audio-Ein-/Ausgabegeräte auswählen können.⁶⁴

Weitere Verbesserungen: - Lange Links bleiben jetzt auch bei Zeilenumbrüchen im TUI anklickbar (v0.105.0)⁶³ - Lokale Dateilinks werden mit verbesserter Formatierung dargestellt (v0.106.0)⁶² - Die Ctrl+C-Behandlung für Sub-Agenten wurde korrigiert, sodass Kindprozesse ordnungsgemäß beendet werden (v0.106.0)⁶²

Speichersystem

Codex verfügt über ein persistentes Speichersystem (v0.100.0+), das Fakten, Präferenzen und Projektkontext sitzungsübergreifend speichert.²⁵

Speicherbefehle

Einträge werden als Markdown-Dateien unter ~/.codex/memory/ gespeichert. Codex lädt sie beim Sitzungsstart und nutzt sie, um das Verhalten in allen künftigen Sitzungen zu steuern.

Was gespeichert werden sollte

Der Speicher eignet sich am besten für dauerhafte Präferenzen und Projektfakten:

• Projektkonventionen: „Dieses Projekt verwendet Tabs, keine Leerzeichen” oder „API-Antworten enthalten immer ein meta-Feld”
• Werkzeugpräferenzen: „Verwende pnpm statt npm” oder „Führe Tests mit pytest -x --tb=short aus”
• Architekturentscheidungen: „Das Auth-Modul befindet sich in src/core/auth/, nicht in src/middleware/“
• Workflow-Präferenzen: „Führe immer den Linter aus, bevor Du mir einen Diff zeigst”

Speicher in Pipelines

Beim Ausführen von codex exec werden gespeicherte Einträge automatisch geladen. Dadurch profitieren CI/CD-Pipelines und Skripte vom selben Kontext wie interaktive Sitzungen — Anweisungen müssen nicht bei jedem Aufruf wiederholt werden.

Speicherverfeinerungen (v0.101.0–v0.107.0)

• Secret-Bereinigung: Einträge werden vor dem Schreiben auf die Festplatte automatisch auf Secrets geprüft
• CWD-Awareness: Speicherdateien enthalten nun den Arbeitsverzeichnis-Kontext für projektspezifischen Abruf
• Ausschluss von Entwicklernachrichten: Entwickler-/Systemnachrichten werden von der Phase-1-Speichereingabe ausgeschlossen, was die Speicherqualität durch Fokussierung auf Benutzerinteraktionen verbessert
• Diff-basiertes Vergessen (v0.106.0): Der Speicher nutzt nun diff-basiertes Vergessen, um veraltete Fakten zu entfernen und den Speicher schlank und relevant zu halten⁶²
• Nutzungsbasierte Auswahl (v0.106.0): Der Speicherabruf ist nun nutzungsbasiert und priorisiert häufig abgerufene sowie kürzlich relevante Einträge⁶²
• Konfigurierbarer Speicher (v0.107.0): Der Speicher ist nun vollständig konfigurierbar. Mit codex debug clear-memories können Sie alle gespeicherten Einträge zurücksetzen — nützlich beim Wechsel zwischen nicht zusammenhängenden Projekten oder wenn der Speicherzustand veraltet ist⁶⁴

Speicher vs. AGENTS.md

Tipp: Verwenden Sie /m_update für Fakten, die dauerhaft bestehen bleiben sollen. Für sitzungsspezifischen Kontext teilen Sie Codex die Information einfach direkt im Gespräch mit. Für geteilten Teamkontext verwenden Sie AGENTS.md.

Sitzungsverwaltung

Codex speichert Sitzungen unter ~/.codex/sessions/ und ermöglicht so das Fortsetzen, Verzweigen und parallele Arbeiten über CLI und Desktop-Oberflächen hinweg.

Fortsetzen

Dort weitermachen, wo Sie aufgehört haben:

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

Der Slash-Befehl /resume innerhalb der TUI öffnet denselben interaktiven Picker mit Suchfunktion.

Verzweigen

Verzweigen Sie ein Gespräch, um Alternativen zu erkunden, ohne den aktuellen Fortschritt zu verlieren:

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

Verzweigungen erzeugen unabhängige Threads, die bis zum Verzweigungspunkt dieselbe Historie teilen. Änderungen in einer Verzweigung wirken sich nicht auf die andere aus. Dies ist nützlich, um Ansätze zu vergleichen (z. B. „verzweige und probiere Redis statt Memcached”) oder riskante Änderungen sicher zu erkunden.

Thread-Verzweigung in Sub-Agents (v0.107.0): Threads können nun in unabhängige Sub-Agents verzweigt werden, sodass ein Gespräch parallele Arbeitsströme erzeugen kann, die autonom ausgeführt werden. Dies erweitert das bestehende Verzweigungsmodell — statt nur das Gespräch zu verzweigen, wird der verzweigte Thread zu einem Sub-Agent mit eigenem Ausführungskontext.⁶⁴ Ab v0.117.0 verwenden Sub-Agents pfadbasierte Adressen (z. B. /root/agent_a) mit strukturiertem Inter-Agent-Messaging, was die Multi-Agent-Koordination expliziter und leichter debugbar macht.⁷⁷

Thread-Übersicht

Aktive Sitzungen anzeigen und verwalten:

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

In der Desktop-App sind Threads in der Seitenleiste mit vollständiger Historie und Diff-Vorschau sichtbar.

Sitzungslebenszyklus

Sitzungen werden zwischen CLI und Desktop-App synchronisiert — beginnen Sie in der einen Oberfläche und fahren Sie in der anderen fort.

Nicht-interaktiver Modus (codex exec)

codex exec führt Codex nicht-interaktiv für Skripting, CI/CD und Automatisierung aus.¹⁶

Grundlegende Verwendung

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

Standardmäßig schreibt codex exec Fortschritts-/Ereignisinformationen nach stderr und die abschließende Agent-Nachricht nach stdout. Dieses Design macht es kompatibel mit Standard-Unix-Pipelines.

JSON-Lines-Ausgabe

Mit --json wird stdout zu einem JSONL-Ereignisstrom:

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

Ereignistypen: 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}}

Strukturierte Ausgabe

Erzwingen Sie die Antwortstruktur mit JSON Schema:

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

-o / --output-last-message schreibt die abschließende Nachricht in eine Datei.

Sitzung fortsetzen und überprüfen

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

Wichtige Flags

CI-Authentifizierung

codex exec unterstützt CODEX_API_KEY für nicht-interaktive Authentifizierung in Automatisierungsumgebungen.

Codex Cloud und Hintergrundaufgaben [EXPERIMENTELL]

Status: Codex Cloud ist eine experimentelle Funktion. Schnittstellen, Preise und Verfügbarkeit können sich ändern. OpenAI verwaltet die Cloud-Umgebungen; Sie kontrollieren die Infrastruktur nicht.

Codex Cloud führt Aufgaben asynchron in von OpenAI verwalteten Umgebungen aus.⁴ Siehe auch GitHub Action & CI/CD zur Integration von Codex in Ihre CI-Pipeline.

Funktionsweise

1. Aufgabe einreichen (über chatgpt.com/codex, Slack-Integration oder CLI)
2. Codex klont Ihr Repository in eine isolierte Cloud-Sandbox
3. Der Agent arbeitet eigenständig: liest Code, führt Tests aus, nimmt Änderungen vor
4. Nach Abschluss erstellt Codex einen PR oder stellt einen Diff zur Überprüfung bereit
5. Ergebnisse lokal anwenden mit codex apply <TASK_ID>

Internetzugang in der Cloud

Der Internetzugang des Agents ist standardmäßig deaktiviert und wird pro Umgebung konfiguriert:

• Aus: Kein Internetzugang für den Agent (Standard)
• An: Optionale Domain-Allowlist + HTTP-Methodenbeschränkungen

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

Setup-Skripte können weiterhin das Internet zur Installation von Abhängigkeiten nutzen, auch wenn der Agent-Internetzugang deaktiviert ist.

Slack-Integration

Erwähnen Sie @Codex in einem Slack-Kanal oder -Thread, um eine Cloud-Aufgabe zu starten.

Voraussetzungen: 1. Berechtigter ChatGPT-Plan (Plus, Pro, Business, Enterprise oder Edu) 2. Verbundenes GitHub-Konto 3. Mindestens eine konfigurierte Cloud-Umgebung 4. Slack-App für Ihren Workspace installiert

Codex antwortet mit einem Aufgabenlink und postet die Ergebnisse nach Abschluss.

Cloud-CLI

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)

## Die Codex Desktop App

Die Codex Desktop App (macOS und Windows) bietet eine grafische Oberfläche, die für die Verwaltung mehrerer Projekte optimiert ist.[^17] Die Windows-Version wurde am 4. März 2026 mit nativer PowerShell-Unterstützung und nativer Windows-Sandbox veröffentlicht.[^68]

### Installation

```bash
codex app                      # Auto-downloads and installs on first run

Oder direkt herunterladen: Codex.dmg (macOS) | Im Microsoft Store erhältlich (Windows)

Wichtigste Funktionen

Thread-Modi

Jeder Thread läuft in einem von drei Modi, der beim Erstellen ausgewählt wird:

Worktree-Isolationsmechanik:

Wenn Sie einen Worktree-Thread starten, führt die Desktop-App folgende Schritte aus: 1. Erstellt einen neuen Git-Worktree (git worktree add) in einem temporären Verzeichnis 2. Checkt einen frischen Branch von Ihrem aktuellen HEAD aus 3. Führt den Agenten innerhalb des Worktrees aus — alle Dateiänderungen bleiben isoliert 4. Zeigt nach Abschluss eine Diff-Ansicht — Sie entscheiden, welche Änderungen zurückgeführt werden

Dadurch können mehrere Worktree-Threads gleichzeitig auf demselben Repository laufen, ohne Konflikte zu verursachen. Jeder erhält seinen eigenen Branch und sein eigenes Arbeitsverzeichnis.

Automatisierungen

Automatisierungen werden lokal in der App ausgeführt, daher muss die App laufen und das Projekt auf der Festplatte verfügbar sein:

• In Git-Repos verwenden Automatisierungen dedizierte Hintergrund-Worktrees (isoliert von Ihrem Arbeitsverzeichnis)
• In Nicht-Git-Projekten erfolgt die Ausführung direkt im Projektverzeichnis
• Automatisierungen nutzen Ihre Standard-Sandbox-Einstellungen

Einrichtung einer Automatisierung: 1. Öffnen Sie ein Projekt in der Desktop-App 2. Klicken Sie auf den Reiter „Automatisierungen” in der Seitenleiste 3. Definieren Sie einen Trigger (Zeitplan, Webhook oder manuell) 4. Verfassen Sie den Prompt und wählen Sie den Ausführungsmodus (Local oder Worktree) 5. Legen Sie die Reasoning-Stufe für den Automatisierungslauf fest (App v26.312)⁷⁴ 6. Automatisierungen laufen planmäßig ab und stellen die Ergebnisse zur Überprüfung in eine Warteschlange

Beispielhafte Anwendungsfälle: - Issue-Triage: Neue Issues automatisch kategorisieren und priorisieren - CI-Überwachung: Build-Fehler beobachten und Lösungsvorschläge generieren - Alert-Reaktion: Auf Monitoring-Alerts mit diagnostischer Analyse reagieren - Abhängigkeitsaktualisierungen: Sicherheitspatches prüfen und anwenden

Ergebnisse erscheinen in einer Überprüfungswarteschlange zur Genehmigung durch eine Person.

Windows-Unterstützung

Die Codex Desktop App wurde am 4. März 2026 (App v26.304) für Windows veröffentlicht — mit nativer PowerShell-Unterstützung, nativer Windows-Sandbox und vollem Funktionsumfang einschließlich Skills, Automatisierungen und Worktrees, ohne dass WSL erforderlich ist.⁶⁸

GitHub Action & CI/CD

Die offizielle GitHub Action integriert Codex in Ihre CI/CD-Pipeline.¹⁹

Grundlegende Verwendung

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

Konfigurationsoptionen

Ausgabe: final-message, der finale Codex-Antworttext für nachgelagerte Steps/Jobs.

Sicherheitsstrategien

Zugriffskontrollen

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

Standard: Nur Mitarbeiter mit Schreibzugriff können Codex-Workflows auslösen.

Codex SDK

Das TypeScript SDK bettet die Agenten-Fähigkeiten von Codex in benutzerdefinierte Anwendungen ein.²⁰

Installation

npm install @openai/codex-sdk

Grundlegende Verwendung

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

Erweiterte SDK-Funktionen

• runStreamed(...): Asynchroner Event-Stream für Zwischenergebnisse
• outputSchema: Erzwingt JSON-strukturierte Endausgabe
• Multimodale Eingabe: Text und lokale Bilder übergeben ({ type: "local_image", path: "..." })
• Bild-Workflows (v0.117.0): view_image gibt URLs zurück, generierte Bilder lassen sich erneut öffnen und die Bildhistorie überlebt Sitzungsfortsetzungen⁷⁷

Thread- und Client-Konfiguration

// Custom working directory, skip git check
const thread = codex.startThread({
  workingDirectory: "/path/to/project",
  skipGitRepoCheck: true,
});

// Custom environment and config overrides
const codex = new Codex({
  env: { CODEX_API_KEY: process.env.MY_KEY },
  config: { model: "gpt-5.2-codex" },
});

Sitzungen werden unter ~/.codex/sessions gespeichert.

Laufzeitumgebung: Node.js 18+.

Leistungsoptimierung

Kontextverwaltung

Die Flaggschiff-Modelle verfügen über 272K-Token-Eingabefenster (128K Ausgabe, 400K Gesamtbudget), doch dieses Budget füllt sich schneller als erwartet. Gehen Sie proaktiv vor:

1. Verwenden Sie /compact regelmäßig: Fasst den Gesprächsverlauf zusammen, um Token freizugeben
2. Stellen Sie lokale Dokumentation bereit: Hochwertige AGENTS.md und lokale Dokumentation reduzieren den Explorationsaufwand (der Kontext verbraucht)
3. Nutzen Sie @ zum Anhängen bestimmter Dateien: Referenzieren Sie Dateien direkt, anstatt Codex danach suchen zu lassen
4. Halten Sie Prompts fokussiert: Eingegrenzte Prompts mit konkreten Dateien verbrauchen weniger Kontext als offene Exploration

Token-Effizienz

Geschwindigkeitsoptimierung

1. gpt-5.3-codex-spark: Variante mit geringerer Latenz für interaktives Pair-Programming
2. --profile fast: Vorkonfiguriertes Mini-Modell mit niedrigem Reasoning-Level
3. Parallele Tool-Ausführung: Codex führt unabhängige Lese-/Prüfvorgänge parallel aus — strukturieren Sie Ihre Prompts entsprechend
4. Ergebnisorientierte Schleifen: Fordern Sie „implementieren, testen, beheben, stoppen wenn grün” an, statt Schritt-für-Schritt-Anweisungen zu geben

Wie behebe ich Probleme?

Häufige Probleme und Lösungen

Referenz für Fehlermeldungen

Diagnosetools

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

Diagnosebefehle innerhalb der TUI-Sitzung:

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

Hinweis: codex --verbose ist kein gültiges Top-Level-Flag. Verwenden Sie stattdessen die oben genannten Debug-Unterbefehle und TUI-Diagnosetools.

Neuinstallation

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

Debug-Modus

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

Probleme melden

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

Alternativ können Sie Issues unter github.com/openai/codex/issues einreichen.¹

Unternehmenseinsatz

Administratorsteuerung (requirements.toml)

Administratoren setzen Unternehmensrichtlinien über requirements.toml durch – eine administratorseitig erzwungene Konfigurationsdatei, die sicherheitsrelevante Einstellungen einschränkt, welche Benutzer nicht überschreiben können:²²

# /etc/codex/requirements.toml

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

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

Anders als die benutzerseitige config.toml, die Präferenzen festlegt, ist requirements.toml eine harte Einschränkungsebene, die vorgibt, welche Werte Benutzer auswählen dürfen – Benutzer können sie nicht überschreiben. Administratorregeln in requirements.toml können ausschließlich auffordern oder verbieten (niemals stillschweigend erlauben).

macOS-MDM-Konfiguration

Verteilen Sie die Konfiguration per MDM über die Präferenzdomäne com.openai.codex.²² Codex unterstützt standardmäßige macOS-MDM-Payloads (Jamf Pro, Fleet, Kandji usw.). Kodieren Sie TOML als Base64 ohne Zeilenumbrüche:

Rangfolge (höchste bis niedrigste):

1. Verwaltete macOS-Einstellungen (MDM)
2. Cloud-basierte Anforderungen (ChatGPT Business / Enterprise)
3. /etc/codex/requirements.toml (lokales Dateisystem)

Cloud-Anforderungen füllen lediglich nicht gesetzte Anforderungsfelder aus, sodass höherrangige verwaltete Ebenen stets Vorrang haben. Cloud-Anforderungen werden nach dem Best-Effort-Prinzip abgerufen; schlägt der Abruf fehl oder kommt es zu einer Zeitüberschreitung, arbeitet Codex ohne die Cloud-Ebene weiter.

OpenTelemetry-Integration

Codex unterstützt die Weitergabe von OpenTelemetry-Trace-Kontexten aus standardmäßigen OTel-Umgebungsvariablen bis hin zu OpenAI-API-Aufrufen. Setzen Sie die standardmäßigen Umgebungsvariablen vor dem Start von 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

• Standardmäßige OTEL_*-Umgebungsvariablen werden berücksichtigt (Endpunkt, Dienstname, Ressourcenattribute)
• Der Trace-Kontext wird durch Codex an API-Aufrufe weitergegeben, was durchgängige Observability ermöglicht
• Verwenden Sie Ressourcenattribute, um Traces nach Team, Umgebung oder Projekt zu taggen
• Beachten Sie die Datenschutzanforderungen bei aktiviertem Prompt-/Tool-Logging – Traces können Code-Ausschnitte enthalten

Unternehmenszugang

• ChatGPT Business / Enterprise / Edu: Vom Organisationsadministrator gesteuerter Zugang mit automatisch angewandten Cloud-Anforderungen. Unterstützt SSO via SAML/OIDC über Ihren Identitätsanbieter (Okta, Entra ID usw.)
• API: Standard-API-Authentifizierung, Abrechnung und Organisations-/Projektsteuerung. OpenAI veröffentlicht SOC-2-Typ-II- und SOC-3-Berichte; HIPAA BAA ist für den Enterprise-Tarif verfügbar
• Codex SDK: Integration in interne Tools und Workflows
• Richtliniendurchsetzung im großen Maßstab: Verwenden Sie per MDM verteilte requirements_toml_base64 oder dateisystembasierte /etc/codex/requirements.toml

Datenverarbeitung und Compliance: - API-Ein-/Ausgaben werden gemäß den Business-/Enterprise-/API-Bedingungen von OpenAI nicht für das Training verwendet - Bezüglich Datenresidenz wird API-Datenverkehr von OpenAI standardmäßig über US-basierte Infrastruktur geroutet; für EU-Datenresidenzanforderungen wenden Sie sich an das Enterprise-Vertriebsteam von OpenAI - Sitzungsprotokolle werden lokal gespeichert; nur API-Aufrufe verlassen den Rechner - ChatGPT Enterprise unterstützt Compliance-Frameworks einschließlich SOC 2, DSGVO und CCPA

Rollout-Strategie

Empfohlener phasenweiser Rollout für Organisationen:

1. Pilot (Woche 1–2): Bereitstellung für 3–5 erfahrene Entwickler mit requirements.toml, die den untrusted-Sandbox-Modus und cached-Websuche erzwingt. Feedback zu AGENTS.md-Mustern und MCP-Serveranforderungen sammeln.
2. Teamerweiterung (Woche 3–4): Rollout auf das gesamte Team. Team-Standard-config.toml per MDM oder Repository verteilen. workspace-write-Sandbox für vertrauenswürdige Repositories aktivieren.
3. CI-Integration (Woche 5–6): codex-action in CI/CD-Pipelines für automatisierte PR-Überprüfung und Testgenerierung einbinden. --ephemeral verwenden, um Kosten planbar zu halten.
4. Organisationsweit (Monat 2+): Bereitstellung per MDM mit requirements.toml, die genehmigte MCP-Server, Sandbox-Richtlinien und Modell-Allowlists erzwingt.

Audit-Muster

Codex-Nutzung überwachen und Compliance sicherstellen:

• OpenTelemetry-Traces: API-Aufrufvolumen, Token-Verbrauch und Latenz pro Team überwachen
• Sitzungspersistenz: ~/.codex/sessions/ für Compliance-Überprüfungen auditieren (mit --ephemeral in sensiblen Kontexten deaktivierbar)
• MCP-Identitätsdurchsetzung: requirements.toml protokolliert blockierte Serverversuche – auf unautorisierte Tool-Nutzung prüfen
• Git-Audit-Trail: Alle Codex-Dateiänderungen durchlaufen standardmäßiges Git – Überprüfung über Branch-Verlauf und PR-Diffs

Best Practices und Anti-Patterns

Prompting-Muster

1. Einschränkungsgetriebene Prompts: Beginnen Sie mit Grenzen. „Ändern Sie NICHT die API-Verträge. Refaktorisieren Sie nur die interne Implementierung.”
2. Strukturierte Reproduktionsschritte: Nummerierte Schritte führen zu besseren Fehlerbehebungen als vage Beschreibungen
3. Verifizierungsanfragen: Schließen Sie mit „Führen Sie Lint und die kleinste relevante Testsuite aus. Berichten Sie Befehle und Ergebnisse.”
4. Dateireferenzen: Verwenden Sie @filename, um bestimmte Dateien dem Kontext hinzuzufügen
5. Ergebnisorientierte Schleifen: „Implementieren, Tests ausführen, Fehler beheben, erst stoppen wenn alle Tests bestehen.” Codex iteriert bis zur Fertigstellung

Testing-Philosophie

Die Community konvergiert bei testgetriebener KI-Zusammenarbeit:²³

• Definieren Sie Tests vorab als Abschlusssignale
• Lassen Sie Codex iterieren, bis die Tests bestehen (Red → Green → Refactor)
• Übernehmen Sie Tiger Style-Programmiermuster
• Stellen Sie exakten Dateitext bereit, wenn Sie Patches anfordern. Codex verwendet striktes Matching, kein unscharfes AST-basiertes Patching

Best Practices für Kontextmanagement

• Stellen Sie hochwertige lokale Dokumentation bereit, anstatt sich auf Websuche zu verlassen
• Pflegen Sie strukturiertes Markdown mit Inhaltsverzeichnissen und Fortschrittsdateien („Progressive Disclosure”)
• Vereinheitlichen Sie Zeilenenden (LF vs CRLF) in versionierten Dateien, um Patch-Fehler zu vermeiden
• Halten Sie AGENTS.md knapp, da lange Anweisungen aus dem Kontext verdrängt werden

Git-Workflow

• Erstellen Sie immer einen neuen Branch, bevor Sie Codex auf unbekannten Repositories ausführen
• Verwenden Sie Patch-basierte Workflows (git diff / git apply) anstelle direkter Bearbeitungen
• Überprüfen Sie Codex-Vorschläge wie Code-Review-PRs
• Verwenden Sie /diff, um Änderungen vor dem Commit zu verifizieren

Community-Skills und Prompts

Das Repository feiskyer/codex-settings bietet von der Community gepflegte Konfigurationen:²⁴

Wiederverwendbare Prompts (in ~/.codex/prompts/): - deep-reflector: Erkenntnisse aus Entwicklungssitzungen extrahieren - github-issue-fixer [issue-number]: Systematische Fehleranalyse und PR-Erstellung - github-pr-reviewer [pr-number]: Code-Review-Workflows - ui-engineer [requirements]: Produktionsreife Frontend-Entwicklung

Community-Skills: - claude-skill: Aufgaben an Claude Code mit Berechtigungsmodi übergeben - autonomous-skill: Multi-Session-Aufgabenautomatisierung mit Fortschrittsverfolgung - deep-research: Parallele Teilaufgaben-Orchestrierung - kiro-skill: Anforderungen → Design → Aufgaben → Ausführungspipeline

Anti-Patterns

Häufige Fehler, die Tokens verschwenden, schlechte Ergebnisse liefern oder frustrierende Workflows erzeugen.

Kosten-Anti-Patterns

Kontext-Anti-Patterns

Workflow-Anti-Patterns

Prompt-Anti-Patterns

Workflow-Rezepte

Durchgängige Muster für gängige Entwicklungsszenarien.

Rezept 1: Neues Projekt aufsetzen

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

Überprüfen Sie die generierte AGENTS.md, passen Sie sie an Ihre Konventionen an, dann:

> Run the health endpoint test and confirm it passes

Rezept 2: Täglicher Entwicklungsablauf

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.

Mit /diff überprüfen, dann committen.

Rezept 3: Komplexes Refactoring mit Plan-Modus

codex

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

Überprüfen Sie den Plan. Genehmigen oder steuern Sie nach:

[Tab] Also add a migration script using Alembic

Nachdem Codex ausgeführt hat, verifizieren Sie:

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

Rezept 4: PR-Review mit 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

Rezept 5: Debugging mit Cloud Tasks [EXPERIMENTELL]

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

Fortschritt später prüfen:

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

Den Fix lokal anwenden, wenn fertig:

codex apply <TASK_ID>

Migrationsleitfaden

Von Claude Code

Wichtige Unterschiede:

• Sandbox auf Betriebssystemebene: Codex verwendet Seatbelt/Landlock, keine Container. Die Beschränkungen greifen auf Kernel-Ebene, unterhalb der Anwendungsschicht.
• Hooks werden erweitert: Codex unterstützt derzeit 5 Hook-Events: SessionStart, Stop und UserPromptSubmit (v0.114.0–v0.116.0, experimentell) sowie AfterAgent (v0.99.0) und AfterToolUse (v0.100.0). Das System deckt Sitzungslebenszyklus, Prompt-Abfangen und werkzeugbasierte Automatisierung ab, allerdings bieten die 12+ Lifecycle-Events von Claude Code nach wie vor eine breitere Abdeckung. Für Automatisierungsmuster, die noch nicht abgedeckt sind, verwenden Sie AGENTS.md-Anweisungen oder Skills.
• Sub-Agents v2 (v0.117.0): Sub-Agents nutzen jetzt pfadbasierte Adressen (z. B. /root/agent_a) mit strukturiertem Inter-Agent-Messaging und Agent-Auflistung.⁷⁷ Dies erweitert die bestehende Infrastruktur (max. 6 gleichzeitig, reduziert von 12 in v0.91.0). Multi-Agent-Rollen lassen sich weiterhin über die Konfiguration anpassen (v0.104.0+).⁴⁹ In v0.105.0 wurde spawn_agents_on_csv für Fanout über Zeilen mit Fortschrittsverfolgung und ETA hinzugefügt.⁶³ Codex bietet nach wie vor kein Äquivalent zu Claude Codes explizitem Task-Tool-UX für benutzergesteuerte Delegation — verwenden Sie Cloud-Tasks oder SDK-Orchestrierung für Delegationsmuster.
• AGENTS.md ist toolübergreifend: Ihre AGENTS.md funktioniert in Cursor, Copilot, Amp, Jules, Gemini CLI und über 60.000 Open-Source-Projekten. CLAUDE.md ist Claude-exklusiv.
• Profile ersetzen manuelles Umschalten: Statt bei jedem Aufruf Flags zu ändern, definieren Sie Profile in config.toml.

Von GitHub Copilot

Was Sie gewinnen: - Sandboxing auf Betriebssystemebene (Seatbelt/Landlock — kernelbasiert statt containerbasiert) - Cloud-Task-Delegation mit codex apply - Konfigurationsprofile für Workflow-Wechsel - Desktop-App mit Worktree-Isolation

Von Cursor

Kurzreferenzkarte

╔═══════════════════════════════════════════════════════════════╗
║                    CODEX CLI QUICK REFERENCE                  ║
╠═══════════════════════════════════════════════════════════════╣
║                                                               ║
║  LAUNCH                                                       ║
║  codex                      Interactive TUI                   ║
║  codex "prompt"             TUI with initial prompt           ║
║  codex exec "prompt"        Non-interactive mode              ║
║  codex app                  Desktop app                       ║
║  codex resume               Resume previous session           ║
║  codex fork                 Fork a session                    ║
║                                                               ║
║  FLAGS                                                        ║
║  -m, --model <model>        Select model                      ║
║  -p, --profile <name>       Load config profile               ║
║  -s, --sandbox <mode>       Sandbox mode                      ║
║  -C, --cd <dir>             Working directory                 ║
║  -i, --image <file>         Attach image(s)                   ║
║  -c, --config <key=value>   Override config                   ║
║  --full-auto                workspace-write + on-request      ║
║  --oss                      Use local models (Ollama)         ║
║  --search                   Enable live web search            ║
║                                                               ║
║  SLASH COMMANDS (in TUI)                                      ║
║  /compact      Free tokens   /diff        Git diff            ║
║  /review       Code review   /plan        Plan mode           ║
║  /model        Switch model  /status      Session info        ║
║  /fork         Fork thread   /init        AGENTS.md scaffold  ║
║  /mcp          MCP tools     /skills      Invoke skills       ║
║  /ps           Background    /personality Style               ║
║  /permissions  Approval mode /statusline  Footer config       ║
║  /fast         Toggle fast mode (default: on)                ║
║  /copy         Copy last response to clipboard                ║
║  /clear        Clear screen  /theme       Syntax highlighting ║
║  /experimental Toggle experimental features (js_repl)        ║
║                                                               ║
║  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 --full-auto "task"          Sandboxed auto        ║
║  codex exec --json -o out.txt "task"    JSON + file output    ║
║  codex exec --output-schema s.json      Structured output     ║
║  codex exec resume --last "continue"    Resume session        ║
║                                                               ║
║  MCP MANAGEMENT [EXPERIMENTAL]                                ║
║  codex mcp add <name> -- <cmd>    Add STDIO server            ║
║  codex mcp add <name> --url <u>   Add HTTP server             ║
║  codex mcp list                    List servers                ║
║  codex mcp login <name>           OAuth flow                  ║
║  codex mcp remove <name>          Delete server               ║
║                                                               ║
║  PLUGINS                                                      ║
║  codex plugin list              List installed plugins        ║
║  codex plugin install <name>    Install from marketplace      ║
║                                                               ║
║  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-failure    Auto-run until failure                         ║
║  on-request    Prompt for boundary violations                 ║
║  never         No prompts                                     ║
║                                                               ║
║  MODELS (March 2026, v0.116.0)                                ║
║  gpt-5.4               Recommended flagship (1M context)     ║
║  gpt-5.3-codex         Coding specialist (272K in / 400K)    ║
║  gpt-5.3-codex-spark   Interactive, lower latency (128K)     ║
║  gpt-5.2-codex         Long-horizon refactors (272K / 400K)  ║
║  gpt-5.1-codex-mini    Quick tasks, cost-efficient (272K/400K)║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Änderungsprotokoll

References

Note on OpenAI blog URLs: References ¹⁷, ²⁶–³¹, ³⁴, ⁶⁶, ⁶⁸, and ⁶⁹ link to openai.com/index/ blog posts which return HTTP 403 to automated access due to Cloudflare bot protection. These URLs are valid when accessed via a standard web browser.