Codex CLI: Die maßgebliche technische Referenz

TL;DR: Codex ist ein Multi-Surface-Coding-Agent, der Ihre Codebasis liest, Befehle in einer Sandbox auf Betriebssystemebene ausführt, Dateien patcht und Aufgaben an die Cloud delegiert. Beherrschen Sie fünf Kernsysteme (config.toml, Sandbox-/Genehmigungsmodell, AGENTS.md, MCP und Skills), und Codex wird zum Force Multiplier. Verwenden Sie Profile für Kontextwechsel, /compact zur Verwaltung des Kontextbudgets, /goal für persistierte Arbeitsziele und AGENTS.md für tool-übergreifende Projektanweisungen, die in Codex, Cursor, Amp und mehr funktionieren. GPT-5.5 (eingeführt am 23. April 2026) ist der empfohlene Standard in Codex — 400K Kontextfenster in Codex (1M in der API), 5 $/30 $ pro MTok, 82,7 % Terminal-Bench 2.0 SOTA.⁸³ Mit CLI v0.130.0 (8. Mai 2026) liefert Codex einen Top-Level-Befehl codex remote-control für die headless App-Server-Steuerung, Multi-Environment-view_image-Auflösung, Bedrock-Authentifizierung über AWS-aws login-Console-Login-Anmeldedaten, App-Server-Thread-Paginierung, Plugin-Detail-Sichtbarkeit für gebündelte Hooks mit Share-Link-Metadaten und Discoverability-Steuerungen, Live-Config-Refresh für laufende Threads, konfigurierbare OpenTelemetry-Trace-Metadaten sowie weiteres Sandbox-Hardening unter Linux und Windows. v0.129.0 (7. Mai 2026) ergänzte modales Vim-Editing (/vim), einen neu gestalteten Workflow-Picker, einen In-TUI-/hooks-Browser, eine themenbewusste Statuszeile, Plugin-Workspace-Sharing mit Marketplace-Operationen sowie eine Änderung des /goal-Lebenszyklus. Bevorzugen Sie weiterhin explizite Sandbox-/Genehmigungs-Flags oder Berechtigungsprofile gegenüber dem veralteten --full-auto; js_repl bleibt entfernt.^86878991

Codex agiert als Multi-Surface-Coding-Agent und nicht als Chatbot, der Code schreibt. Die CLI liest Ihre Codebasis, führt Befehle in einer Sandbox aus, patcht Dateien, verbindet sich mit externen Diensten über MCP und delegiert langlaufende Aufgaben an die Cloud. Lokal ausgeführt, aber global gedacht — dieselbe Intelligenz treibt fünf verschiedene Surfaces an, je nachdem, wie Sie arbeiten, einschließlich der neuen Chrome-Erweiterung, die Codex in Ihrem Browser ausführt, ohne ihn zu übernehmen.⁹⁰

Der Unterschied zwischen gelegentlicher und effektiver Codex-Nutzung lässt sich auf fünf Kernsysteme zurückführen. Beherrschen Sie diese, wird Codex zum Force Multiplier:

1. Konfigurationssystem: steuert das Verhalten über config.toml
2. Sandbox- und Genehmigungsmodell: kontrolliert, was Codex tun darf
3. AGENTS.md: definiert Betriebsverträge auf Projektebene
4. MCP-Protokoll: erweitert Funktionen auf externe Dienste
5. Skills-System: bündelt wiederverwendbare Domänenexpertise

Ich habe monatelang Codex parallel zu Claude Code in produktiven Codebasen, CI/CD-Pipelines und Team-Workflows eingesetzt. Dieser Guide destilliert diese Erfahrung zu der vollständigen Referenz, die ich mir gewünscht hätte, als ich anfing. Jede Funktion enthält tatsächliche Syntax, reale Konfigurationsbeispiele und die Edge Cases, an denen erfahrene Benutzer scheitern.

Hinweis zur Stabilität: Funktionen, die mit [EXPERIMENTAL] oder under development gekennzeichnet sind, können zwischen Releases Änderungen unterliegen. Mit v0.130.0 (8. Mai 2026) bleiben Codex Cloud und Code Mode experimentell oder in Entwicklung, während die Kern-CLI, Sandboxing, AGENTS.md, config.toml, Skills, Hooks, Multi-Agent-Tools und Plugins stabile Surfaces sind. v0.130.0 fügt den Top-Level-Befehl codex remote-control hinzu (einfacherer Einstiegspunkt für einen headless, remote steuerbaren App-Server), Multi-Environment-view_image-Auflösung, Bedrock-Authentifizierung über AWS-aws login-Console-Login-Anmeldedaten, App-Server-Thread-Paginierung mit unloaded-/summary-/full-turn-Views, Plugin-Detail-Sichtbarkeit für gebündelte Hooks plus Share-Link-Metadaten und Discoverability-Steuerungen, Live-App-Server-Config-Refresh (laufende Threads übernehmen Config-Änderungen ohne Neustart), entfernten Wortlaut „research preview” aus dem Startbanner von codex exec, konfigurierbare OpenTelemetry-Trace-Metadaten, Linux-Sandbox-Startup-Hardening und Windows-Sandbox-Grant für den Desktop-Runtime-Binary-Cache.⁹¹ v0.129.0 (7. Mai 2026) brachte modales Vim-Editing im Composer (/vim + konfigurierbarer Default-Mode), einen neu gestalteten TUI-Workflow-Picker (einfacheres Resume/Fork, Raw-Scrollback), den /hooks-Browser, eine themenbewusste Statuszeile mit optionalen PR- und Branch-Zusammenfassungen, Plugin-Workspace-Sharing mit Marketplace-Operationen und Share-Access-Controls sowie Source-Filtering, eine Änderung des /goal-Lebenszyklus (experimentelle Goals bleiben über Resume hinweg pausiert, sofern nicht explizit reaktiviert), Linux-Sandbox-Startup-Hardening, Verbesserungen der Windows-Sandbox-Zuverlässigkeit und ein Bubblewrap-Update auf 0.11.2 mit Upstream-Sicherheitspatches.⁸⁹ v0.128.0 (30. April 2026) führte persistierte /goal-Workflows, codex update, konfigurierbare TUI-Keymaps und erweiterte Berechtigungsprofile ein; das veraltete --full-auto bleibt deprecated, und js_repl bleibt entfernt.⁸⁶⁸⁷

Wichtigste Erkenntnisse

• Fünf Oberflächen, ein Gehirn: CLI, Desktop-App, IDE-Erweiterung, Cloud-Tasks und die neue Chrome-Erweiterung teilen sich alle dieselbe GPT-5.x-Codex-Intelligenz – wählen Sie also die Oberfläche, die zu Ihrem Workflow passt.⁹⁰
• Sandboxing auf Betriebssystemebene: Codex setzt Dateisystem- und Netzwerkbeschränkungen auf Kernel-Ebene durch (Seatbelt unter macOS, Landlock + seccomp unter Linux), nicht innerhalb von Containern.
• AGENTS.md ist werkzeugü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 zwischen ihnen mit --profile.
• Kontextverwaltung ist entscheidend: GPT-5.4 bietet 1M Kontext; GPT-5.4 mini stellt 400K für Subagent-Arbeit bereit; GPT-5.3-Codex bietet 272K Eingabe. Nutzen Sie /compact, fokussierte Prompts und @file-Referenzen, um Token-Budgets proaktiv zu verwalten.

So nutzen Sie diesen Leitfaden

Dies ist eine Referenz mit über 2.500 Zeilen – starten Sie dort, wo Ihr Erfahrungsstand passt:

Die Quick Reference Card am Ende bietet eine überschaubare Zusammenfassung aller wichtigen Befehle.

So funktioniert Codex: Das mentale Modell

Bevor wir uns den Funktionen widmen, sollten Sie verstehen, wie die Architektur von Codex alles prägt, was Sie damit tun. Das System arbeitet über vier Oberflächen hinweg, gestützt auf eine gemeinsame Intelligenzschicht:

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

Core Layer: Die GPT-5.x-Modellfamilie treibt alles an. Seit dem 23. April 2026 ist gpt-5.5 das empfohlene Modell, sofern verfügbar – 400K Kontext in Codex (1M in der API), 82,7 % Terminal-Bench 2.0 SOTA. gpt-5.4 bleibt während des Rollouts der Fallback-Standard (1M Kontext, native Computernutzung).⁸³⁶⁴ Es liest Dateien, schreibt Patches, führt Shell-Befehle aus und denkt über Ihre Codebasis nach. Wenn der Kontext sich füllt, komprimiert Codex die Konversation, um Platz freizugeben. Diese Schicht verbraucht Tokens.

Security Layer: Jeder Befehl, den Codex ausführt, durchläuft eine Sandbox auf Betriebssystemebene. Unter macOS setzt Apples Seatbelt-Framework Beschränkungen auf Kernel-Ebene durch. Unter Linux filtern Landlock + seccomp den Dateisystem- und Syscall-Zugriff. Die Sandbox arbeitet auf Kernel-Ebene, nicht innerhalb von Containern. Die Approval Policy entscheidet anschließend, wann eine menschliche Bestätigung eingeholt werden soll.

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

Surface Layer: CLI für Terminal-Power-User und Automatisierung. Desktop-App für Multi-Thread-Projektmanagement. IDE-Erweiterung für Edit-Compile-Test-Schleifen. Cloud für asynchrone Tasks, die unabhängig laufen.

Die zentrale Erkenntnis: Die meisten Benutzer verwenden nur eine Oberfläche. Power-User nutzen alle vier: Cloud für langlaufende Tasks, CLI für deterministische Repo-Operationen, IDE-Erweiterung für enge Coding-Schleifen 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 funktionieren Sandbox und Approval-System?
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 & Zusammenarbeit
17. Memory-System
18. Session-Management
19. Nicht-interaktiver Modus (codex exec)
20. Codex Cloud & Hintergrund-Tasks
21. Die Codex Desktop-App
22. GitHub Action & CI/CD
23. Codex SDK
24. Leistungsoptimierung
25. Wie behebe ich Probleme?
26. Enterprise-Bereitstellung
27. Best Practices & Anti-Patterns
28. Workflow-Rezepte
29. Migrationsleitfaden
30. Quick Reference Card
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 ist ein einzeiliges Installationsskript als GitHub-Release-Asset verfügbar:⁶⁰

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

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

Binärdownloads

Für Umgebungen ohne npm oder Homebrew laden Sie plattformspezifische Binärdateien von GitHub Releases herunter:¹

Systemanforderungen

• macOS: Apple Silicon oder Intel (vollständige Sandbox-Unterstützung über Seatbelt)
• Linux: x86_64 oder arm64 (Sandbox über Landlock + seccomp)
• Windows: Native Sandbox mit eingeschränkten Tokens (in v0.100.0 von experimentell hochgestuft). 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. Voller Funktionszugriff einschließlich Cloud-Aufgaben.
2. API Key: Legen Sie ihn über die Umgebungsvariable CODEX_API_KEY oder codex login --with-api-key fest. Einige Funktionen (Cloud-Threads) sind möglicherweise nicht verfügbar.

Expertentipp: Die Speicherung von Anmeldedaten ist über cli_auth_credentials_store in config.toml konfigurierbar. Optionen: file (Standard), keyring (OS-Schlüsselbund) oder auto (keyring, falls verfügbar, sonst Datei-Fallback).

Shell-Vervollständigungen

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

Schnellstart: Ihre erste Sitzung

In 5 Minuten von null zu produktiver Arbeit.

1. Installieren und authentifizieren:

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

2. Zu einem Projekt wechseln:

cd ~/my-project                  # Any git repo works

3. Codex starten:

codex

Sie sehen die interaktive TUI. Codex liest Ihre Projektstruktur automatisch.

4. Eine Frage stellen:

> What does this project do? Summarize the architecture.

Codex liest die wichtigsten Dateien und erklärt die Codebasis. Im standardmäßigen suggest-Modus werden keine Änderungen vorgenommen.

5. Eine Änderung vornehmen:

> Add input validation to the login endpoint

Codex schlägt Änderungen als Diff vor. Prüfen Sie sie und genehmigen Sie sie mit y, oder lehnen Sie sie mit n ab.

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 anschließend, um mit der Ausführung zu beginnen.

7. Ihre Arbeit prüfen:

> /diff

Sehen Sie alle Änderungen, die Codex in der aktuellen Sitzung vorgenommen hat.

Als Nächstes: - Richten Sie AGENTS.md mit Projektanweisungen ein (siehe Wie funktioniert AGENTS.md?) - Konfigurieren Sie ein Profil für Ihren Workflow (siehe Profile) - Probieren Sie codex exec für nicht interaktive Automatisierung aus (siehe Nicht interaktiver Modus)

Kernschnittstellen für die Interaktion

Codex bietet vier verschiedene Schnittstellen, die alle auf derselben Intelligenz basieren. Jede Oberfläche ist für ein anderes Workflow-Muster optimiert.

1. Interaktive CLI (Terminal UI)

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

Die Terminal-UI ist eine Vollbildanwendung mit:

• Composer: Geben Sie Prompts ein, hängen Sie Dateien mit @ an, führen Sie Shell-Befehle mit dem Präfix ! aus
• Output-Bereich: Streaming der Modellantworten, Tool-Aufrufe und Befehlsausgaben
• Statusleiste: Modell, Token-Verbrauch, Git-Branch, Sandbox-Modus

Wichtige TUI-Tastenkürzel:

Änderung der Statusleiste (v0.121.0): Der alte Kontextfenster-Indikator in der Statusleiste wurde durch einen Kontext-Prozent-Indikator ersetzt, der anzeigt, wie voll Ihr Kontextfenster ist. Wenn Sie Skripte oder Hooks haben, die die Statusleiste parsen, prüfen Sie diese Formatänderung.⁸² Codex zeigt zudem eine Update-Ankündigung der CLI an, sobald eine neue Version verfügbar ist.

Slash-Befehle, die in der TUI verfügbar sind:

Neugestaltung des Workflow-Pickers (v0.129.0): Resume und Fork sind nun aus einem überarbeiteten Picker leichter erreichbar, und ein neuer Raw-Scrollback-Modus ermöglicht es Ihnen, durch das ungerenderte Transkript zu scrollen, wenn Sie Befehle oder Modellausgaben wortgetreu kopieren müssen. Nützlich beim Sichten einer langen Debugging-Session oder beim Weiterleiten der Ausgabe an ein anderes Tool.⁸⁹

2. Codex Desktop App (macOS + Windows)

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

Die Desktop-App fügt Funktionen hinzu, die die CLI nicht bietet:

• Multitasking: Mehrere parallele Agenten in verschiedenen Projekten gleichzeitig ausführen
• Git-Worktree-Isolation: Jeder Thread arbeitet an einer isolierten Kopie Ihres Repos
• Inline-Diff-Review: Änderungen stagen, zurücksetzen und committen, ohne die App zu verlassen
• Integriertes Terminal: Pro-Thread-Terminal zum Ausführen von Befehlen
• Konversations-Forking: Konversationen abzweigen, um Alternativen zu erkunden
• Floating Pop-out-Fenster: Konversationen in portable Fenster auskoppeln
• Automatisierungen: Wiederkehrende Aufgaben planen (Issue-Triage, CI-Monitoring, Alert-Response)

Wann die App vs. die CLI verwenden: Nutzen Sie die Desktop-App, wenn Sie mehrere Arbeitsstränge koordinieren oder eine visuelle Diff-Review benötigen. Nutzen Sie die CLI, wenn Sie Terminal-Komponierbarkeit, Scripting oder CI/CD-Integration wünschen.

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

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

• Standardmäßig im Agent-Modus: Liest Dateien, nimmt Bearbeitungen vor, führt Befehle aus
• Inline-Bearbeitungen: Kontextabhängige Vorschläge in Ihren aktiven Dateien
• Geteilte Sessions: Sessions werden zwischen CLI und IDE-Erweiterung synchronisiert
• Gleiche Authentifizierung: Anmelden mit ChatGPT-Konto oder API-Schlüssel

Installieren Sie sie aus dem VS Code Marketplace oder den Erweiterungsstores von Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Cloud-Tasks laufen asynchron in von OpenAI verwalteten Umgebungen:

• Fire and forget: Tasks in die Warteschlange stellen, die unabhängig von Ihrer lokalen Maschine ausgeführt werden
• Parallele Ausführung: Mehrere Cloud-Tasks gleichzeitig ausführen
• PR-Erstellung: Codex erstellt Pull Requests aus abgeschlossener Arbeit
• Lokales Apply: 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-Tasks sind außerdem über chatgpt.com/codex zugänglich.⁴

5. Codex for Chrome [NEW]

Codex erscheint als Browser-Erweiterung für Chrome und ergänzt eine fünfte Oberfläche neben der CLI, der Desktop-App, der IDE-Erweiterung und der Cloud. Die Erweiterung ist so konzipiert, dass sie Ihr normales Browsen begleitet, statt es zu übernehmen: Codex arbeitet im Hintergrund parallel über mehrere Tabs hinweg, und Sie behalten die Kontrolle darüber, welche Seiten es anfasst.⁹⁰

• Parallele Tab-Ausführung: Codex operiert über mehrere Tabs gleichzeitig, ohne den aktiven Tab zu blockieren.
• Pro-Site-Kontrolle: Sie geben per Allow-List vor, mit welchen Websites Codex interagieren darf; standardmäßig besteht kein Zugriff.
• Browser als Werkbank: Die Erweiterung eignet sich am besten für App- und Website-Arbeit, bei der die Seite die Quelle der Wahrheit ist — Admin-Konsolen, interne Dashboards, Content-Management-UIs, Ticketsysteme — und nicht als Ersatz für die CLI bei lokalen Repos.
• Gleiches Gehirn: Codex for Chrome nutzt dieselbe GPT-5.x-Codex-Intelligenz wie die anderen Oberflächen, sodass eine AGENTS.md- oder Skills-Konfiguration, die in der CLI funktioniert, dieselben Konventionen in die browserbasierte Arbeit überträgt.

Installieren Sie die Erweiterung aus den Codex Chrome extension docs.⁹⁰

Konfigurationssystem im Detail

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

Vorrangigkeit (höchste bis niedrigste)

1. Sitzungs-Overrides (höchste): CLI-Flags (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) und -c key=value-Overrides
2. Projektkonfiguration (.codex/config.toml, ausgehend vom CWD aufwärts bis zur Projektwurzel ermittelt; das nächstgelegene Verzeichnis gewinnt)
3. Benutzerkonfiguration ($CODEX_HOME/config.toml, standardmäßig ~/.codex/config.toml)
4. Systemkonfiguration (/etc/codex/config.toml unter Unix)
5. Eingebaute Standardwerte (niedrigste)

requirements.toml fungiert als Richtlinien-Beschränkungsebene, die einschränkt, welche Werte Benutzer nach dem normalen Konfigurations-Merge 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-Setups.

Vollständige Konfigurationsreferenz

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.5"                      # Recommended model when available
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_context_window = 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.5"               # Optional 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-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 Konfigurationsvoreinstellungen für unterschiedliche 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. Pro Sitzung können Sie es mit --profile überschreiben.

Benutzerdefinierte Model Provider

Verbinden Sie sich mit Azure, AWS Bedrock, lokalen Modellen oder Proxy-Diensten:

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

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

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

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

Warnung: Die chat/completions-Wire-API (wire_api = "chat") wurde für von OpenAI gehostete Modelle als veraltet eingestuft, wobei OpenAI die Entfernung im Februar 2026 angekündigt hat.³⁴ Lokale Provider (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 legen Sie es in der Konfiguration fest:

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

Inline-Konfigurations-Overrides

Überschreiben Sie jeden Konfigurationswert über die Befehlszeile:

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

## Welches Modell sollte ich wählen?

### Verfügbare Modelle (April 2026)

| Modell | Input / Gesamtkontext | Standard-Reasoning | Am besten geeignet für |
|-------|--------:|-------------------|----------|
| **gpt-5.5** (Codex) | 400K / 400K | `medium` | **Neues Flaggschiff (23. April 2026)** — 82,7 % Terminal-Bench 2.0 SOTA; empfohlener Standard für die meisten Codex-Aufgaben. **In API**: 1M Kontextfenster.[^160] |
| **gpt-5.5-pro** | 1M / 1M | `high` | Höchste Aufwandsstufe bei GPT-5.5 (24. April 2026, in API verfügbar)[^160] |
| **gpt-5.4** | 1M / 1M | `medium` | Vorheriges Flaggschiff; bleibt Standard, während GPT-5.5 über alle Oberflächen ausgerollt wird |
| **gpt-5.4-mini** | 400K / 400K | `medium` | Subagenten-Arbeit, einfachere Aufgaben — 30 % des GPT-5.4-Kontingents, 2-mal schneller[^81] |
| **gpt-5.3-codex** | 272K / 400K | `medium` | Coding-Spezialist: komplexes Software Engineering |
| **gpt-5.3-codex-spark** | 128K / 128K | `high` | Nahezu sofortige Iteration, nur Text (Pro-Benutzer, Cerebras-Partnerschaft)[^69] |
| **gpt-5.2-codex** | 272K / 400K | `medium` | Legacy-Modell; OpenAI nennt `gpt-5.4` als Ersatz für die Abschaltung am 23. Juli 2026[^165] |
| **gpt-5.1-codex-mini** | 272K / 400K | `medium` | Kostensensitives Legacy-Modell; OpenAI nennt `gpt-5.4-mini` als Ersatz für die Abschaltung am 23. Juli 2026[^165] |

> **GPT-5.5 (23. April 2026)** ist OpenAIs empfohlene Wahl für die meisten Codex-Aufgaben: komplexes Coding, Computer Use, Wissensarbeit und Research-Workflows. Verfügbar in Codex CLI / Web / Desktop seit dem 23. April für ChatGPT Plus / Pro / Business / Enterprise / Edu / Go; in der OpenAI API seit dem 24. April. **Kontextfenster: 400K in Codex, 1M in der API** — Codex begrenzt das Fenster auf 400K, um Durchsatz und Kosten über die Abonnenten-Stufen hinweg auszubalancieren; die API stellt die vollen 1M bereit. Preise (API): **5 $ Input / 30 $ Output pro MTok** (2× der GPT-5.4-Tarif; OpenAI gibt eine effektive Erhöhung von ~20 % nach Token-Effizienz-Verbesserungen an). Benchmarks: **82,7 % Terminal-Bench 2.0** (aktueller SOTA über alle öffentlich verfügbaren Modelle), 84,9 % GDPval (44 Berufe), 78,7 % OSWorld-Verified, 98,0 % Tau2-bench Telecom (ohne Prompt-Tuning). OpenAI hat GPT-5.5 + Codex intern verwendet, um die Serving-Infrastruktur vor dem Launch neu zu schreiben — was zu einer 20%igen Steigerung der Token-Generierungsgeschwindigkeit führte.[^160]
>
> GPT-5.4 bleibt über alle Codex-Oberflächen hinweg verfügbar (CLI, App, IDE-Extension, Cloud).[^66] Die genaue Modellliste variiert je nach Konto und Rollout. Prüfen Sie Ihren lokalen Cache: `~/.codex/models_cache.json`.
>
> **Deprecation-Hinweis (11. März 2026)**: GPT-5.1-Modelle sind in ChatGPT nicht mehr verfügbar. Bestehende Konversationen 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 kostensensitive Workloads verfügbar.[^73]
>
> **Free-Tier-Hinweis (5. Mai 2026)**: GPT-5.5 Instant wurde am 5. Mai 2026 für die kostenlose ChatGPT-Stufe ausgerollt. Dies erweitert die Zielgruppe der GPT-5.5-Familie über bezahlte Pläne hinaus, der Zugriff auf Codex CLI erfordert jedoch weiterhin ein berechtigtes Plus- / Pro- / Business- / Enterprise- / Edu- / Go-Abonnement oder einen API-Schlüssel.[^169]
>
> **GPT-5.4 mini (17. März 2026)**: Eine kleinere, schnellere Variante von GPT-5.4 mit 400K Kontext zu 0,75 $ / 4,50 $ pro MTok — nutzt nur 30 % des GPT-5.4-Kontingents. Ideal für die Subagenten-Delegation: Lassen Sie GPT-5.4 Planung und Koordination übernehmen, während GPT-5.4-mini-Subagenten engere Teilaufgaben (Codebase-Suche, Datei-Review, Dokumentenverarbeitung) parallel bearbeiten.[^81]

### Modell-Auswahl-Flussdiagramm

```text
Is this a quick fix or simple question?
├─ Yes → gpt-5.1-codex-mini (fastest, cheapest)
└─ No
   ├─ Do you need real-time pairing speed?
   │  ├─ Yes → gpt-5.3-codex-spark (near-instant, Pro only)
   │  └─ No
   │     ├─ Subagent or parallel subtask (search, review, processing)?
   │     │  ├─ Yes → gpt-5.4-mini (30% of GPT-5.4 quota, 2x faster)
   │     │  └─ No
   │     │     ├─ Pure coding task (refactor, migration, feature build)?
   │     │     │  ├─ Yes → gpt-5.3-codex (coding specialist, 272K context)
   │     │     │  └─ No → gpt-5.5 (new flagship: 400K context in Codex / 1M in API, 82.7% Terminal-Bench 2.0 SOTA)
   └─ Still unsure? → gpt-5.5

Reasoning-Aufwand

Steuern Sie, wie viel 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 beim gleichen Prompt 3-5× mehr Tokens als medium verbrauchen. Reservieren Sie es für wirklich harte Probleme, bei denen sich das zusätzliche Nachdenken auszahlt.

TUI-Schnellsteuerung für Reasoning (v0.124.0+).⁸⁵ In einer interaktiven TUI-Sitzung senkt Alt+, das Reasoning um eine Stufe und Alt+. erhöht es um eine Stufe — nützlich, wenn ein schwieriges Problem mitten in der Sitzung einen vorübergehenden medium → high → xhigh-Anstieg ohne /effort oder -c rechtfertigt. Wenn Sie mitten in der Sitzung ein Modell-Upgrade akzeptieren, wird das Reasoning auf den Standard des neuen Modells zurückgesetzt, statt die vorherige Stufe zu übernehmen.

Modell-Wechsel

Wechseln Sie das Modell mitten in einer Sitzung mit dem /model-Slash-Befehl, oder setzen Sie es pro Lauf über --model / -m:

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

Was kostet Codex?

Siehe auch Modellauswahl für Funktionen und Entscheidungsrahmen zur Wahl des passenden Modells pro Aufgabe.

Zugang über ChatGPT-Pläne

Die Verfügbarkeit von Codex hängt von Ihrem ChatGPT-Plan und den Einstellungen Ihrer Organisation ab:⁵¹

Preisaktualisierung April 2026: Der Business-Jahrespreis ist von 25 $ auf 20 $/Sitz/Monat gesunken. Codex-only Sitze mit Pay-as-you-go-Abrechnung sind jetzt für Business- und Enterprise-Workspaces verfügbar — keine feste Sitzgebühr, abgerechnet nach Token-Verbrauch.⁷⁹ Die promotionalen 2x Rate Limits für Bezahlpläne (vom Desktop-App-Launch im Februar 2026) bleiben aktiv.¹⁶

Mai 2026 Erhöhung der Nutzungslimits (bis 31. Mai 2026): Codex auf dem Plus-Plan läuft mit einem 25× 5-Stunden-Limit (gegenüber dem Standard-20×-Boost), und die 100 $/Monat-Stufe ist verdoppelt für denselben Zeitraum. Nutzen Sie diese Phase für längere Cloud-Task-Batches oder höher durchsatzfähige Agent-Läufe, ohne an Ihre normale 5-Stunden-Grenze zu stoßen.⁸⁹

Credit-Kosten

Codex-Operationen verbrauchen Credits aus Ihrer Plan-Zuteilung:

Enterprise- und Edu-Pläne skalieren Credits mit der Vertragszuteilung. Prüfen Sie /status im TUI für den aktuellen Verbrauch.

API-Abrechnung

Bei der Nutzung von Codex über das API rechnet OpenAI die Nutzung pro Token zu den standardmäßigen OpenAI API-Preisen für das ausgewählte Modell ab (plus etwaige 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 sparsam einsetzen: Verwenden Sie xhigh nur für wirklich schwierige Probleme, da es 3-5x mehr Tokens kostet
3. --ephemeral nutzen: Überspringen Sie die Sitzungspersistenz in CI/CD, um Overhead zu reduzieren
4. Reasoning-Zusammenfassungen minimieren: Setzen Sie model_reasoning_summary = "none", wenn Sie keine Erklärungen benötigen
5. Batch 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

Praxisbeispiele für Kosten

Repräsentative API-Kosten für gängige Aufgaben (gpt-5.3-codex zum Standardpreis, mittleres Reasoning):

Kosten variieren je nach Reasoning-Aufwand, Caching und Konversationslänge. Verwenden Sie gpt-5.1-codex-mini für Routineaufgaben, um die Kosten um ~40-60 % zu senken. Gecachte Input-Tokens werden mit Rabatt abgerechnet.

Versteckter Token-Overhead

Jeder Tool-Aufruf fügt Tokens jenseits Ihres sichtbaren Prompts hinzu:

Experten-Tipp: Überwachen Sie Ihren tatsächlichen Verbrauch über /status im TUI. Die Token-Zählung 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.

Team-Kostenmanagement

Strategien zur Team-Kostenkontrolle: - requirements.toml einsetzen, 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 - Profilbasiertes Budgetieren — definieren Sie ci-, review- und dev-Profile mit angemessenen Kostenobergrenzen - Über OpenTelemetry überwachen — Enterprise-Deployments können Nutzungstelemetrie in bestehende Observability-Stacks exportieren

Entscheidungsrahmen

Wann welche Oberfläche verwenden

Wann welcher Sandbox-Modus

Wann welche Reasoning-Stufe

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:

Konfiguration in config.toml:

# Default profile
profile = "default"

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

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

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

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

Profile pro Sitzung wechseln: codex --profile careful

Wie funktioniert das Sandbox- und Genehmigungssystem?

Codex verwendet ein zweischichtiges Sicherheitsmodell, das was technisch möglich ist von wann Codex eine menschliche Genehmigung anfordert trennt. Der Ansatz unterscheidet sich grundlegend vom Berechtigungssystem von Claude Code — Codex setzt Einschränkungen auf der OS-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 den Dateisystem- und Netzwerkzugriff über OS-native Mechanismen:

Plattformspezifische Durchsetzung:

• macOS: Apples Seatbelt-Framework über sandbox-exec mit moduspezifischen Profilen, die zur Laufzeit kompiliert und vom Kernel durchgesetzt werden⁶. Ab v0.121.0 können macOS-Sandbox-Profile bestimmte Unix-Sockets (z. B. docker.sock, Editor-IPC-Sockets) auf eine Allowlist setzen, und private DNS-Auflösung wird standardmäßig nicht mehr blockiert.⁸²
• 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 (in v0.100.0 von optional hochgestuft)⁷. v0.117.0 verbesserte die Sandbox-Zuverlässigkeit auf älteren Distributionen mit Legacy-Kernel-Konfigurationen.⁷⁵ v0.129.0 härtete den Sandbox-Start auf Linux und hob das mitgelieferte Bubblewrap auf 0.11.2 mit Upstream-Sicherheitspatches an; v0.130.0 fügte weitere Start-Härtung hinzu.⁸⁹⁹¹
• Windows: Native Sandbox mit eingeschränkten Token (in v0.100.0 von experimentell hochgestuft). WSL wird ebenfalls unterstützt (erbt Linux Landlock + seccomp). v0.117.0 enthält Verbesserungen der Sandbox mit eingeschränkten Token für eine bessere Prozessisolation.⁷⁵ v0.130.0 gewährt Sandbox-Benutzern Zugriff auf den Desktop-Runtime-Binärcache, sodass die Windows-Sandbox Runtime-Binärdateien für Workspace-Sandbox-Benutzer zuverlässig auflösen kann.⁹¹

Warum das wichtig ist: Im Gegensatz zu container-basiertem Sandboxing (Docker) ist OS-Level-Sandboxing schneller, leichter und schwerer zu umgehen. Der Kernel setzt Einschränkungen durch, bevor Codex den Systemaufruf überhaupt sieht.

Sicherheitskorrekturen: - zsh-fork Sandbox-Bypass (v0.106.0): Behoben wurde eine Schwachstelle, bei der die Shell-Ausführung über zsh-Forking Sandbox-Einschränkungen umgehen konnte.⁶⁰ Wenn Sie eine frühere Version verwenden, aktualisieren Sie sofort. - Eingabegrößenbegrenzung (v0.106.0): Codex setzt jetzt eine Eingabebegrenzung von etwa 1 Million Zeichen durch, um Hänger durch übermäßig große Payloads zu verhindern.⁶⁰ - Sicheres Devcontainer-Profil (v0.121.0): Ein neues gehärtetes Customer-Profil für Docker-Devcontainer verwendet Bubblewrap für das Sandboxing innerhalb des Containers. WSL2 wird unterstützt; WSL1 wird explizit abgelehnt (Bubblewrap ist mit dem Kernel-Shim von WSL1 inkompatibel).⁸² - Guardian-Review + Hooks (v0.121.0): Hooks sind während Guardian-Review-Sitzungen deaktiviert, sodass Pre-/Post-Tool-Hooks die Entscheidungen des Guardian-Subagenten nicht beeinflussen können.⁸² Wenn Sie sich für Logging oder Validierung auf Hooks verlassen, beachten Sie, dass ein Guardian-Review diese überspringt — greifen Sie auf App-Server-Observability zurück, wenn Sie einen vollständigen Audit-Trail benötigen. - Linux /dev-Dateisystem (v0.105.0): Sandboxed-Befehle unter Linux erhalten jetzt ein minimales /dev-Dateisystem, was die Kompatibilität mit Tools verbessert, die Geräteknoten erwarten.⁶¹

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

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

Schicht 2: Genehmigungsrichtlinie (Wann nachfragen)

Die Genehmigungsrichtlinie bestimmt, wann Codex pausiert, um eine menschliche Bestätigung anzufordern:

on-failure erscheint noch in einigen älteren Beispielen und Kompatibilitätspfaden, aber die aktuellen OpenAI-Konfigurationsdokumente kennzeichnen es als veraltet. Bevorzugen Sie on-request für interaktive Läufe und never für nicht-interaktive Läufe, die bereits eine externe Sicherheitsgrenze haben.⁸⁷

Eindeutige Genehmigungs-IDs (v0.104.0+)

Codex weist nun jedem Befehl innerhalb einer mehrstufigen Shell-Ausführung eindeutige Genehmigungs-IDs zu. Das bedeutet, dass Genehmigungen granular sind — die Genehmigung eines Befehls in einer Sequenz genehmigt nicht automatisch nachfolgende Befehle im selben Shell-Aufruf.⁴⁹

Flexible Genehmigungssteuerung (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 bestimmte zusätzliche Berechtigungen anfordern, anstatt einen vollständigen Moduswechsel zu erfordern
• Granulare Ablehnung: Lehnen Sie einzelne Tool-Aufrufe mit Feedback ab, damit Codex seinen Ansatz anpassen kann, anstatt einfach denselben Befehl erneut zu versuchen

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öhten Zugriff erfordert, kann es bestimmte Berechtigungen (Dateisystempfade, Netzwerkzugriff usw.) formell über den TUI-Genehmigungsablauf anfordern, anstatt stillschweigend zu scheitern oder den Benutzer zu zwingen, mit anderen Flags neu zu starten.

Berechtigungsprofile (v0.113.0+, erweitert in v0.128.0)

Berechtigungsprofile teilen Dateisystem- und Netzwerk-Sandbox-Richtlinien in benannte, wiederverwendbare Abschnitte auf. Setzen Sie default_permissions auf ein integriertes Profil wie :read-only, :workspace oder :danger-no-sandbox, oder verweisen Sie es auf eine benutzerdefinierte [permissions.<name>]-Tabelle.⁸⁷

default_permissions = "project-safe"

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

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

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

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

Verwenden Sie none für sensible Dateien und Globs, die auch dann unlesbar sein sollten, wenn das Projekt-Root beschreibbar ist. Bevorzugen Sie für einmalige Befehlsausnahmen Regeln gegenüber einer breiten Erweiterung eines Profils.⁸⁷

Legacy --full-auto-Hinweise

Ältere Anleitungen beschrieben --full-auto als praktischen Alias für:

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

In v0.128.0 markieren die Release Notes --full-auto als veraltet, und die aktuelle CLI-Hilfe listet es nicht mehr für interaktive Läufe auf. Verwenden Sie stattdessen die expliziten Flags oben oder ein benanntes Permissions-Profil.⁸⁶

Sandbox-Zuverlässigkeit (v0.129.0): Die Härtung des Linux-Sandbox-Starts reduziert Race Conditions auf langsamen Dateisystemen oder symbolisch verlinkten Checkouts; Verbesserungen der Windows-Sandbox-Zuverlässigkeit beheben mehrere Edge-Case-Abstürze während lang laufender Ausführungen; und das mitgelieferte Bubblewrap wird auf 0.11.2 mit Upstream-Sicherheitspatches angehoben. Keine Konfigurationsänderungen erforderlich. Führen Sie codex update aus, um diese zu übernehmen.⁸⁹

Empfohlene Konfigurationen

Tägliche Entwicklung (sicherer Standard):

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

Power-User (voller Zugriff, Human-in-the-Loop):

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

Die Kombination ist der von der Community empfohlene „Sweet Spot”: maximale Fähigkeit, aber Genehmigung für jeden Befehl erforderlich.⁸

CI/CD-Automatisierung:

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

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

Smart Approvals können Review-Anfragen über einen Guardian-Subagenten leiten, anstatt für jede Aktion eine menschliche Genehmigung zu erfordern. Die Guardian-Sitzung bleibt über Genehmigungen hinweg bestehen, um den Prompt-Cache wiederzuverwenden und den Startaufwand zu vermeiden. Jede Überprüfung erhält einen sauberen Verlauf (frühere Entscheidungen sickern nicht in spätere Überprüfungen durch).⁷³

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 anstelle eines pauschalen approval_policy = "never" wünschen.

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-Verkehr ü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.

Testen der Sandbox

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

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

Wenn die Sandbox korrekt funktioniert, sollten beide Befehle unter einem workspace-bezogenen Profil mit einem Permission-Denied-Fehler fehlschlagen. Wenn einer der Befehle erfolgreich ist, muss Ihre Sandbox-Konfiguration überprüft 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 wird er von Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode und mehr als 60.000 Open-Source-Projekten. Er legt fest, wie sich Codex in einem bestimmten Repository oder Ordner verhält. Informationen zu wiederverwendbaren Wissenspaketen, die AGENTS.md ergänzen, finden Sie unter Skills.

Discovery-Hierarchie

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

1. Global (~/.codex/): AGENTS.override.md > AGENTS.md
2. Projekt (vom git-Root bis zum aktuellen Verzeichnis): Auf jeder Ebene wird nach AGENTS.override.md > AGENTS.md > Fallback-Dateinamen gesucht
3. Zusammenführung: Dateien werden von der Wurzel abwärts aneinandergereiht; nähere Dateien erscheinen später im Prompt und überschreiben frühere Vorgaben

~/.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 ein gutes AGENTS.md ausmacht

Basierend auf direkten Empfehlungen von Codex selbst und Mustern aus der Community¹⁰:

DO: - Seien Sie konkret: "Use rg --files for discovery" ist besser als "search efficiently" - Definieren Sie den Abschluss: Was bedeutet „fertig“? (Tests bestehen, Lint ohne Fehler usw.) - Nehmen Sie Befehle auf: Build, Test, Lint, Formatierung (exakte Aufrufe) - Strukturieren Sie nach Aufgabe: Abschnitte für Coding, Review, Release, Incident/Debugging - Definieren Sie Eskalation: Was zu tun ist, wenn etwas blockiert oder ein unerwarteter Zustand auftritt

DON’T: - Keine vollständigen Styleguides ohne Ausführungsregeln hineinkopieren - Keine mehrdeutigen Anweisungen verwenden („vorsichtig sein“, „optimieren“) - Keine widersprüchlichen Prioritäten mischen (Geschwindigkeit + vollständige Verifikation + kein Runtime-Budget) - Keine Prosadokumentation schreiben (AGENTS.md ist operative Richtlinie, kein README)

Beispiel: Produktions-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.

Umgang mit Secrets in Agent-Sitzungen

Behandeln Sie den für Codex sichtbaren Verlauf als Sicherheitsfläche, nicht nur den Quellcode. Die Release Notes von Codex dokumentieren Arbeiten an Shell-Snapshots und der Redaktion von Umgebungsvariablen, und das Memory-System scannt Speicher-Schreibvorgänge auf Secrets. Diese Schutzmechanismen machen Befehlsausgaben, Sitzungstranskripte, Shell-Snapshots, lokale Logs oder Hilfsskripte jedoch nicht zu sicheren Orten, um Zugangsdaten auszugeben.³⁷⁵⁵⁹⁵

Die operative Regel ist einfach: Geben Sie keine Secrets aus, die das Modell prüfen kann; halten Sie Hilfszugangsdaten in Konfigurationen, die Umgebungsvariablen erfordern; trennen Sie bei Audits ausführbaren Quellcode, Dokumentation, generierte Caches, Sitzungstranskripte, Shell-Snapshots, Logs und bewusst angelegte Secret-Speicher; redigieren Sie den lokalen Verlauf, wenn eine Secret-Form mit hoher Sicherheit auftaucht; und stufen Sie Präventions-Hooks erst hoch, nachdem der manuelle Hygienekreislauf bewährt ist. Die öffentliche Lektion sind die Oberflächenkarte und die Akzeptanzkriterien, nicht private Token-Werte, exakte Pfade oder Detektor-Interna.⁹⁵

Der Override-Mechanismus

AGENTS.override.md auf einer beliebigen Verzeichnisebene ersetzt das normale AGENTS.md für diesen Geltungsbereich. Verwenden Sie es für:

• Release-Freezes: „Keine neuen Funktionen, nur Fixes“
• Incident-Modus: „Alle Änderungen müssen vom Bereitschaftsdienst geprüft werden“
• Temporäre Härtung: „Keine Dependency-Updates 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 verifizieren 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 Hooks-Engine mit den Events SessionStart und Stop.⁷⁰ Seit v0.124.0 (23. April 2026) sind Hooks stabil.⁸⁵ Sie lassen sich jetzt inline in config.toml und requirements.toml konfigurieren — eine separate Hook-Skriptdatei ist nicht mehr erforderlich — und sie beobachten MCP-Tools neben apply_patch und langlebigen Bash-Sitzungen. Das System deckt jetzt den Sitzungslebenszyklus und Tool-Level-Automatisierung 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)'"

stdout des SessionStart-Hooks fließt in den Kontext des Modells ein und eignet sich damit ideal, um beim Sitzungsstart dynamische Informationen einzuspeisen (Datumsangaben, Branch-Namen, Umgebungsvariablen).

Claude Code-Hook-Muster nachbilden

Wenn Sie von Claude Code migrieren, können Sie ähnliche Automatisierung so umsetzen:

Expertentipp: Seit v0.124.0 (23. April 2026) ist die Hooks-Engine stabil. Neue Hook-Events werden weiterhin in Releases ausgeliefert — prüfen Sie das Codex changelog.

Hook-Browser in der TUI (v0.129.0): Führen Sie /hooks in der TUI aus, um verfügbare Hooks zu entdecken, aktuell aktive Hooks zu sehen und einzelne Hooks ein- oder auszuschalten, ohne config.toml zu bearbeiten. Nützlich, wenn Sie einen fehlerhaften, von einem Plugin gebündelten Hook untersuchen oder einen AfterToolUse-Linter vorübergehend für eine konzentrierte Bearbeitungssitzung deaktivieren.⁸⁹

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 experimental gekennzeichnet, und Befehle sowie das Konfigurationsformat können sich zwischen Releases ändern. Codex unterstützt zwei Transporttypen: STDIO (lokale Prozesse) und Streamable HTTP (Remote-Server).¹¹

Änderungen an MCP in v0.121.0: Tools werden jetzt mit einem namespace registriert, sodass Tool-Namen in Listen als <server>:<tool> statt als bloße Namen erscheinen — aktualisieren Sie alle Skripte oder Prompts, die per grep nach unqualifizierten Tool-Namen suchen. Ein neues Flag supports_parallel_tool_calls wird an eingebundene MCPs durchgereicht und ermöglicht parallele Ausführung für Server, die Unterstützung dafür deklarieren. Sandbox-Statusmetadaten fließen nun über MCP Tool-Metadaten, damit Server ihr Verhalten anpassen können (z. B. warnen, wenn sie unter einer read-only Sandbox laufen). Die benutzerdefinierte Anfrage codex/sandbox-state wurde entfernt — verwenden Sie stattdessen den Metadatenpfad. Phase 3 des Rollouts von MCP Apps landet hier mit Tool-Call-Unterstützung; abgeflachte deferred Tool Calls werden nun für Server unterstützt, die das Deferred-Call-Muster verwenden.⁸²

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

In der Sitzung zeigt /mcp aktive Server und verfügbare Tools an. /mcp verbose (v0.123.0+)⁸⁴ gibt vollständige Serverdiagnosen, Ressourcen und Ressourcenvorlagen zurück — nützlich, wenn ein Server nicht geladen wird oder Tools nicht dort erscheinen, wo Sie sie erwarten. Das einfache /mcp bleibt schnell.

Das Laden von Plugin-MCP (v0.123.0+) akzeptiert sowohl das standardmäßige mcpServers-Schema als auch Server-Maps auf oberster Ebene in .mcp.json, sodass Plugins, die nach beiden Konventionen erstellt wurden, sauber geladen werden.⁸⁴

Codex ALS MCP Server ausführen

Codex kann sich selbst als MCP Server für Multi-Agent-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")

Nennenswerte MCP Server

Praktische Muster

Muster 1: Kontextbewusste Entwicklung — Kombinieren Sie Context7 mit Ihrer Framework-Dokumentation, damit Codex immer aktuelle API Referenzen hat:

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

Muster 2: Ausgabelimits — Antworten von MCP Tools werden standardmäßig bei etwa 25.000 Zeichen gekürzt. Für Tools, die große Payloads zurückgeben (Datenbankabfragen, Log-Erfassungen), verwenden Sie enabled_tools, um auf bestimmte Tools zu beschränken und Antworten fokussiert zu halten.

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

Muster 3: Enterprise-Governance für MCP — 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-Bereitstellung für die vollständige Richtlinienkonfiguration.

Code-Modus [EXPERIMENTAL]

Der Code-Modus (v0.114.0) bietet stärker isolierte Coding-Workflows, indem der Umfang des Agenten auf codebezogene Operationen beschränkt wird.⁷⁰ Wenn er aktiviert ist, 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 Updates.

JavaScript REPL-Laufzeitumgebung [REMOVED]

Codex v0.100.0 fügte eine experimentelle JavaScript REPL-Laufzeitumgebung (js_repl) hinzu, und v0.106.0 machte sie über die /experimental-Oberfläche zugänglich.⁶⁰ Diese Anleitung ist nun historisch. In v0.128.0 enthält das Release-Changelog „Remove js_repl feature“, und die aktuelle Funktionsliste markiert sowohl js_repl als auch js_repl_tools_only als entfernt.⁸⁶

Fügen Sie neuen Konfigurationen kein features.js_repl = true hinzu. Verwenden Sie Shell-Befehle, eingecheckte Skripte, MCP Tools oder einen Codex Skill mit einem scripts/-Verzeichnis, wenn Sie wiederholbare ausführbare Logik benötigen.

Was sind Skills?

Skills sind wiederverwendbare, aufgabenbezogene 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)

Discovery-Orte

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

Einen Skill erstellen

SKILL.md-Format:

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

## Security Audit Procedure

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

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: /skills-Menü oder $skill-name-Erwähnung im Prompt
• Implizit: Codex erkennt passende Skills automatisch anhand der Aufgabenbeschreibung (wenn allow_implicit_invocation: true)
• Creator: Verwenden Sie $skill-creator, um interaktiv einen neuen Skill zu erstellen
• Installer: 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

Wenn ein Skill nicht aktiviert wird:

1. Discovery prüfen: /skills sollte ihn in der TUI auflisten
2. Pfad prüfen: Stellen Sie sicher, dass sich der Skill-Ordner an einem erkannten Ort befindet (~/.codex/skills/, Projektstamm oder /etc/codex/skills/)
3. enabled prüfen: Skills mit enabled = false in config.toml werden nicht geladen
4. Implizite Aktivierung prüfen: Wenn Sie sich auf die automatische Erkennung verlassen, stellen Sie sicher, dass allow_implicit_invocation: true in agents/openai.yaml gesetzt ist
5. Keywords verwenden: Nehmen Sie Begriffe aus der description des Skills in Ihren Prompt auf, um das implizite Matching zu verbessern

Produktionsbeispiel: Deploy-Skill

Ein vollständiger Multi-Datei-Skill, der zeigt, wie Referenzen und Skripte zusammenarbeiten:

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 bündeln Skills, MCP-Einträge, hooks und App-Connectors in einem einzigen installierbaren Paket (v0.110.0+).⁶⁵ Seit v0.117.0 sind Plugins First-Class-Citizens: produktbezogene Plugins synchronisieren sich beim Start automatisch, und /plugins bietet einen Browser innerhalb der TUI für Discovery und Verwaltung.⁷⁵ v0.128.0 erweiterte Plugin-Workflows um Marketplace-Installation, Remote-Bundle-Caching, Remote-Uninstall-APIs, Plugin-gebündelte hooks, den Aktivierungsstatus von hooks und den Import externer Agent-Konfigurationen.⁸⁶ v0.129.0 (7. Mai 2026) ergänzt Plugin-Workspace-Sharing (ein Plugin-Set an Teammitglieder weitergeben, ohne es erneut zu veröffentlichen), Share-Zugriffskontrollen (Aktivieren/Deaktivieren und Widerrufen pro Empfänger), Quellfilterung (begrenzen, aus welchen Marketplaces ein Workspace lädt) und Marketplace-Operationen, die direkt aus dem /plugins-Browser statt über die CLI aufgerufen werden können.⁸⁹ v0.130.0 (8. Mai 2026) macht Plugin-Paketierung transparenter und den Share-Workflow besser steuerbar:⁹¹

• Gebündelte hooks in Plugin-Details sichtbar. Die Detailansicht von /plugins listet jetzt jeden Lifecycle-hook auf, den ein Plugin bündelt (SessionStart, UserPromptSubmit, Stop usw.). Bevor Sie ein Plugin installieren, sehen Sie genau, welche hooks es für Ihre Sitzung registriert — keine überraschenden hook-Nebeneffekte mehr von einem Plugin, dem Sie nur wegen seiner Tools vertrauen.
• Plugin-Share-Metadaten in shareContext. Wenn ein Plugin aus einem Workspace geteilt wird, stellt die Share-Link-Payload jetzt Link-Metadaten bereit (Ersteller, Umfang, Aktualität), sodass empfangende Sitzungen die Herkunft anzeigen und entscheiden können, ob sie den Share akzeptieren.
• Discovery-Kontrollen in Share-Einstellungen. Share-Einstellungen stellen einen Discoverability-Schalter bereit, damit Teams Plugins für bestimmte Workspaces oder Empfängerlisten veröffentlichen können, ohne sie organisationsweit allgemein auffindbar zu machen.

Plugin-Quellen

Plugin-Discovery

Codex teilt dem Modell beim Sitzungsstart mit, welche Plugins aktiviert sind (v0.111.0), wodurch die Discovery installierter MCPs, Apps und Skills verbessert wird.⁶⁵ Das Modell kann während einer Sitzung anhand des Aufgabenkontexts relevante Plugins vorschlagen. In v0.117.0 werden produktbezogene Plugins beim Start synchronisiert, sodass der aktuelle Plugin-Katalog ohne manuelles Eingreifen verfügbar ist.⁷⁵

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

Verweisen Sie direkt im Chat mit @plugin-name auf jedes installierte Plugin.⁶⁸ Wenn Sie ein Plugin erwähnen, wird sein Kontext (Fähigkeiten, Tools, Konfiguration) automatisch in das Kontextfenster des Modells aufgenommen — Sie müssen nicht beschreiben, was das Plugin tut.

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

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

Plugin-Marketplace (v0.113.0+)

Der Plugin-Marketplace bietet jetzt eine reichhaltigere Discovery mit Metadaten, Kategorien und Bewertungen.⁶⁹ Auth-Prüfungen während der Installation verifizieren, dass Plugins, die API-Schlüssel oder OAuth benötigen, vor der Installation gültige Anmeldedaten haben. Ein Uninstall-Endpunkt entfernt Plugins und die zugehörige Konfiguration sauber.

Drittanbieter-Marketplaces hinzufügen (v0.121.0+)

Die aktuellen OpenAI Codex-Dokumente führen die Verwaltung von Marketplace-Quellen unter codex plugin marketplace. Das formalisiert die Verteilung von Drittanbieter-Plugins über OpenAIs First-Party-Marketplace hinaus und unterstützt GitHub-Repo-Kurzschreibweise, HTTP(S)-Git-URLs, SSH-URLs und lokale Marketplace-Stammverzeichnisse; verwenden Sie --ref, um eine Git-Ref festzulegen, und wiederholen Sie --sparse PATH nur für Git-basierte Marketplace-Repos.⁹³

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

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

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

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

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

Nach dem Hinzufügen erscheinen die Plugins eines Marketplace im /plugins-Browser neben den Standard-Plugins. App-Server-Aufrufer (IDE-/Desktop-Integrationen) verfügen über einen parallelen Endpunkt, um Marketplaces programmatisch zu registrieren.⁸²

Sicherheitsaspekt: Drittanbieter-Marketplaces führen beliebigen Plugin-Code mit Ihren Codex-Berechtigungen aus. Prüfen Sie Quellen, bevor Sie sie hinzufügen, und bevorzugen Sie bei ersten Ausführungen eine sandboxed Ausführung.

Plugins verwalten

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

In der TUI verwenden Sie /plugins (v0.117.0+), um einzelne Plugins interaktiv zu durchsuchen, zu installieren und zu entfernen, ohne Ihre Sitzung zu verlassen.⁷⁵

Expertentipp: Plugins konsolidieren, wofür früher separate MCP-Konfiguration, Skill-Installation und App-Connector-Setup nötig waren. Ein einzelnes Plugin kann alle drei bündeln — dadurch wird das Team-Onboarding schneller und die Konfiguration portabler.

Plan-Modus & Zusammenarbeit

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

Plan-Modus aktivieren

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

Im Plan-Modus tut Codex Folgendes: - 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

Steer-Modus

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

Es gibt zwei Methoden zur Einschleusung:

Praktische Beispiele:

# 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 Steer-Modus ist in der TUI immer aktiv. Wenn Sie lieber warten möchten, bis Codex fertig ist, bevor Sie Anweisungen geben, tippen Sie einfach normal, nachdem der Turn abgeschlossen ist – kein spezieller Modus erforderlich.

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

Syntaxhervorhebung (v0.105.0): Die TUI hebt nun eingezäunte Codeblöcke und Diffs inline syntaktisch 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.⁶¹ Ab v0.107.0 unterstützen Echtzeit-Sprachsitzungen die Auswahl von Mikrofon- und Lautsprechergeräten, sodass Sie spezifische Audio-Eingabe-/Ausgabe-Hardware wählen können.⁶²

Weitere Verbesserungen: - Lange Links bleiben nun klickbar, auch wenn sie über mehrere TUI-Zeilen umgebrochen werden (v0.105.0)⁶¹ - Lokale Datei-Links werden mit verbesserter Formatierung gerendert (v0.106.0)⁶⁰ - Ctrl+C-Behandlung für Sub-Agenten korrigiert, sodass Kindprozesse korrekt beendet werden (v0.106.0)⁶⁰

Memory-System

Codex verfügt über ein persistentes Memory-System (v0.100.0+), das Fakten, Präferenzen und Projektkontext über Sitzungen hinweg speichert.²⁴

Memory-Befehle

Erinnerungen werden in Markdown-Dateien unter ~/.codex/memory/ gespeichert. Codex lädt sie zu Beginn der Sitzung und nutzt sie, um das Verhalten in allen zukünftigen Sitzungen zu beeinflussen.

Was gespeichert werden sollte

Memory eignet sich am besten für persistente Präferenzen und Projektfakten:

• Projektkonventionen: „Dieses Projekt verwendet Tabs, keine Leerzeichen” oder „API-Antworten enthalten immer ein meta-Feld”
• Tool-Präferenzen: „Verwende pnpm statt npm” oder „Tests mit pytest -x --tb=short ausführen”
• Architekturentscheidungen: „Das Auth-Modul liegt in src/core/auth/, nicht in src/middleware/“
• Workflow-Präferenzen: „Linter immer ausführen, bevor mir ein Diff gezeigt wird”

Memory in Pipelines

Beim Ausführen von codex exec werden Erinnerungen automatisch geladen. Dies bedeutet, dass CI/CD-Pipelines und Skripte vom selben Kontext profitieren wie interaktive Sitzungen – ohne dass Anweisungen bei jedem Aufruf wiederholt werden müssen.

Memory-Verfeinerungen (v0.101.0–v0.107.0)

• Geheimnis-Bereinigung: Erinnerungen werden automatisch auf Geheimnisse gescannt, bevor sie auf die Festplatte geschrieben werden
• CWD-Bewusstsein: Memory-Dateien enthalten nun den Kontext des Arbeitsverzeichnisses für projektspezifische Abrufe
• Ausschluss von Entwicklernachrichten: Entwickler-/Systemnachrichten werden vom Phase-1-Memory-Input ausgeschlossen, was die Memory-Qualität verbessert, indem der Fokus auf Benutzerinteraktionen gelegt wird
• Diff-basiertes Vergessen (v0.106.0): Memory verwendet nun diff-basiertes Vergessen, um veraltete Fakten zu entfernen, sodass der Memory-Speicher im Laufe der Zeit schlank und relevant bleibt⁶⁰
• Nutzungsbasierte Auswahl (v0.106.0): Der Memory-Abruf ist nun nutzungsbewusst und priorisiert häufig zugegriffene und kürzlich relevante Erinnerungen⁶⁰
• Konfigurierbare Erinnerungen (v0.107.0): Erinnerungen sind nun vollständig konfigurierbar. Verwenden Sie codex debug clear-memories, um alle gespeicherten Erinnerungen für einen Neuanfang zurückzusetzen – nützlich, wenn Sie zwischen unzusammenhängenden Projekten wechseln oder wenn der Memory-Zustand abgedriftet ist⁶²
• Phase-2-Modell-Upgrade (v0.121.0): Das Phase-2-Memory-Konsolidierungsmodell ist nun gpt-5.4 (gegenüber dem vorherigen Standard). Die Phase-2-Pipeline läuft zwischen Sitzungen, um Phase-1-Transkripte zu dauerhaften Fakten zu destillieren; der Modellwechsel verbessert die Abrufqualität bei gleichen Token-Kosten.⁸²
• TUI-Memory-Menü (v0.121.0): Eine neue In-Session-UI macht Memory-Modus, individuelles Löschen einzelner Erinnerungen und einen Reset-Button zugänglich. Das Memory-Reset bewahrt nun vergangene Rollouts, anstatt sie zu invalidieren, sodass das Zurücksetzen die zukünftige Abruffläche bereinigt, ohne die Sitzungswiedergabe zu beeinträchtigen.⁸²

Memory vs. AGENTS.md

Tipp: Verwenden Sie /m_update für Fakten, die unbegrenzt bestehen bleiben sollen. Für sitzungsspezifischen Kontext teilen Sie Codex dies einfach direkt im Gespräch mit. Für gemeinsamen Team-Kontext verwenden Sie AGENTS.md.

Sitzungsverwaltung

Codex persistiert Sitzungen unter ~/.codex/sessions/ und ermöglicht so Resume-, Fork- und Multi-Thread-Workflows über CLI- und Desktop-Oberflächen hinweg.

Resume

Setzen Sie dort fort, 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.

Fork

Verzweigen Sie eine Konversation, um Alternativen zu erkunden, ohne Ihren aktuellen Fortschritt zu verlieren:

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

Forks erstellen unabhängige Threads, die denselben Verlauf bis zum Fork-Punkt teilen. Änderungen in einem Fork wirken sich nicht auf den anderen aus. Dies ist nützlich, um Ansätze zu vergleichen (z. B. „forken und stattdessen Redis statt Memcached versuchen”) oder riskante Änderungen sicher zu erkunden.

Thread-Forking in Sub-Agenten (v0.107.0): Threads können nun in unabhängige Sub-Agenten geforkt werden, sodass eine Konversation parallele Arbeitsstränge spawnen kann, die autonom ausgeführt werden. Dies erweitert das bestehende Fork-Modell – statt nur die Konversation zu verzweigen, wird der geforkte Thread zu einem Sub-Agenten mit eigenem Ausführungskontext.⁶² Ab v0.117.0 verwenden Sub-Agenten pfadbasierte Adressen (z. B. /root/agent_a) mit strukturiertem Inter-Agent-Messaging, was die Mehragenten-Koordination expliziter und besser debugbar macht.⁷⁵

Thread-Auflistung

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ändigem Verlauf und Diff-Vorschauen sichtbar.

Sitzungslebenszyklus

Sitzungen werden zwischen CLI und Desktop-App synchronisiert – beginnen Sie in einer und setzen 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 --sandbox workspace-write --ask-for-approval on-request "fix the CI failure"
codex exec --json "triage open bugs" -o result.txt

Standardmäßig schreibt codex exec Fortschritt/Ereignisse nach stderr und die finale Agentennachricht nach stdout. Dieses Design macht es kompatibel mit standardmäßigen 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 ein bestimmtes Antwortformat mit JSON Schema:

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

-o / --output-last-message schreibt die finale 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 die nicht-interaktive Authentifizierung in Automatisierungsumgebungen.

codex exec-Startbanner (v0.130.0). Das codex exec-Startbanner druckt nicht mehr den veralteten Hinweis „research preview”. Wenn Ihre CI die Startausgabe abgreift, ist der Banner-Text jetzt schlanker; strukturierte --json-Ereignisse bleiben unverändert.⁹¹

codex remote-control (v0.130.0+)

codex remote-control ist ein Top-Level-Befehl, der einen headless App-Server startet, der von einem anderen Prozess gesteuert werden soll — IDE-Erweiterungen, benutzerdefinierte Orchestratoren oder Remote-Control-Planes. Er ersetzt den Multi-Flag-Aufruf codex app-server, den viele Integratoren von Hand zusammengestellt haben, und bietet Drittanbieter-Tools einen einzigen, stabilen Einstiegspunkt in dieselbe App-Server-Runtime, die unter den Desktop- und IDE-Oberflächen ausgeliefert wird.⁹¹

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

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

Kombinieren Sie codex remote-control mit den App-Server-Paginierungs-APIs unten, wenn Sie UIs erstellen, die große Thread-Historien aufzählen müssen, ohne jeden Turn auf einmal in den Speicher zu laden.

App-Server-Thread-Paginierung (v0.130.0+)

App-Server-Clients können große Threads jetzt über drei verschiedene Turn-Item-Ansichten paginieren:⁹¹

Kombinieren Sie die Paginierung mit der in v0.121.0 eingeführten ThreadStore-Schnittstelle, um lang laufende Threads effizient zu durchlaufen, insbesondere in Remote-Control-Deployments, bei denen sich der Orchestrator auf einer anderen Maschine als die Rollout-Dateien befinden kann.⁸²

Live App-Server-Konfigurations-Aktualisierung (v0.130.0+)

Live App-Server-Threads übernehmen jetzt config.toml-Änderungen, ohne dass ein Neustart erforderlich ist — bearbeiten Sie die Konfiguration, speichern Sie, und der laufende Thread spiegelt die neuen Werte beim nächsten Turn wider. Dies ist das Bugfix-Pendant zu codex remote-control: Ein lang laufender headless Server kann an Ort und Stelle neu konfiguriert werden, anstatt heruntergefahren zu werden.⁹¹

Codex Cloud & Hintergrundaufgaben [EXPERIMENTAL]

Status: Codex Cloud ist eine experimentelle Funktion. Schnittstellen, Preisgestaltung und Verfügbarkeit können sich ändern. OpenAI verwaltet die Cloud-Umgebungen, und Sie haben keine Kontrolle über die Infrastruktur.

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

Funktionsweise

1. Aufgabe einreichen (über chatgpt.com/codex, Slack-Integration oder CLI)
2. Codex klont Ihr Repo in eine isolierte Cloud-Sandbox
3. Der Agent arbeitet selbstständig: liest Code, führt Tests aus, nimmt Änderungen vor
4. Wenn fertig, erstellt Codex einen PR oder liefert ein Diff zur Überprüfung
5. Wenden Sie die Ergebnisse lokal mit codex apply <TASK_ID> an

Internetzugang in der Cloud

Agent-Internet ist standardmäßig deaktiviert und wird pro Umgebung konfiguriert:

• Off: Kein Agent-Internetzugang (Standard)
• On: Optionale Domain-Allowlist + HTTP-Methoden-Beschrä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 das Agent-Internet 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 Ergebnisse, wenn die Aufgabe abgeschlossen ist.

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.¹⁶ Die Windows-Version startete am 4. März 2026 mit nativer PowerShell-Unterstützung und nativer Windows-Sandbox.⁶⁶

Installation

codex app                      # Auto-downloads and installs on first run

Oder direkt herunterladen: Codex.dmg (macOS) | Verfügbar im Microsoft Store (Windows)

Hauptfunktionen

Thread-Modi

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

Mechanik der Worktree-Isolation:

Wenn Sie einen Worktree-Thread starten, geht die Desktop App folgendermaßen vor: 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. Lässt den Agent innerhalb des Worktrees laufen — alle Dateiänderungen sind isoliert 4. Zeigt nach Abschluss eine Diff-Prüfung an — Sie wählen, welche Änderungen zurück gemergt werden

Dadurch können mehrere Worktree-Threads gleichzeitig auf demselben Repo laufen, ohne dass es zu Konflikten kommt. Jeder erhält seinen eigenen Branch und sein eigenes Arbeitsverzeichnis.

Automatisierungen

Automatisierungen laufen lokal in der App, daher muss die App ausgeführt werden 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 werden Läufe direkt im Projektverzeichnis ausgeführt
• Automatisierungen verwenden Ihre Standard-Sandbox-Einstellungen

Eine Automatisierung einrichten: 1. Öffnen Sie ein Projekt in der Desktop App 2. Klicken Sie auf den Tab „Automations” in der Seitenleiste 3. Definieren Sie einen Trigger (Zeitplan, Webhook oder manuell) 4. Schreiben Sie den Prompt und wählen Sie den Ausführungsmodus (lokal oder Worktree) 5. Stellen Sie das Reasoning-Level für den Automatisierungslauf ein (App v26.312)⁷² 6. Automatisierungen laufen nach Zeitplan und stellen Ergebnisse zur Prüfung in eine Warteschlange

Beispiel-Anwendungsfälle: - Issue-Triage: Neue Issues automatisch kategorisieren und priorisieren - CI-Monitoring: Build-Fehler beobachten und Fixes vorschlagen - Alert-Response: Auf Monitoring-Alerts mit diagnostischer Analyse reagieren - Dependency-Updates: Auf Sicherheits-Patches prüfen und diese anwenden

Die Ergebnisse erscheinen in einer Prüf-Warteschlange zur menschlichen Genehmigung.

Windows-Unterstützung

Die Codex Desktop App startete am 4. März 2026 unter Windows (App v26.304) mit nativer PowerShell-Unterstützung, nativer Windows-Sandbox und voller Funktionsparität, 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 Schritte/Jobs.

Sicherheitsstrategien

Zugriffskontrollen

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

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

Codex SDK

Das TypeScript SDK bettet die Agent-Fähigkeiten von Codex in eigene 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 Zwischen-Updates
• outputSchema: Erzwingt JSON-strukturierte finale Ausgabe
• Multimodale Eingabe: Text + lokale Bilder übergeben ({ type: "local_image", path: "..." })
• Bild-Workflows (v0.117.0): view_image gibt URLs zurück, generierte Bilder sind erneut zu öffnen, und der Bildverlauf bleibt nach dem Wiederaufnehmen einer Sitzung erhalten⁷⁵
• Multi-Environment view_image (v0.130.0): Für Sitzungen, die sich über mehrere Umgebungen erstrecken (eingeführt in v0.124.0 mit Auswahl von Environment + Working-Directory pro Turn, verfeinert in v0.125.0 mit Sticky Environments), löst view_image Dateipfade nun über das ausgewählte Environment statt über das lokale Dateisystem des Orchestrators auf. Ein aus einer Remote-Umgebung angehängtes Bild wird relativ zum Working-Directory dieser Umgebung abgerufen und nicht relativ zum Host, auf dem das SDK läuft.⁹¹

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

Sitzungen werden unter ~/.codex/sessions persistiert.

Runtime: Node.js 18+.

Performance-Optimierung

Context-Management

Context-Fenster variieren je nach Modell. Stand April 2026: GPT-5.5 in Codex bietet 400K (1M in der API). GPT-5.4 / GPT-5.4-mini bieten 1M / 400K (in Codex API-äquivalent). Die Familie GPT-5.3-Codex / GPT-5.2-Codex läuft mit 272K Input + 128K Output (400K Gesamtbudget). Alle füllen sich schneller, als Sie erwarten würden — verwalten Sie sie proaktiv:

1. /compact regelmäßig verwenden: Fasst den Konversationsverlauf zusammen, um Tokens freizugeben
2. Lokale Dokumentation bereitstellen: Hochwertige AGENTS.md und lokale Dokumentation reduzieren den Explorations-Overhead (der Context verbraucht)
3. @ zum Anhängen bestimmter Dateien verwenden: Dateien direkt referenzieren, statt Codex sie suchen zu lassen
4. Prompts fokussiert halten: Eingegrenzte Prompts mit exakten Dateien verbrauchen weniger Context als offene Exploration

Token-Effizienz

Geschwindigkeitsoptimierung

1. gpt-5.3-codex-spark: Variante mit niedrigerer Latenz für interaktives Pairing
2. --profile fast: Vorkonfiguriertes Mini-Modell mit niedrigem Reasoning
3. Parallele Tool-Ausführung: Codex führt unabhängige Reads/Checks gleichzeitig aus, daher sollten Sie Prompts so strukturieren, dass dies möglich ist
4. Ergebnisorientierte Schleifen: Bitten Sie um „implementieren, testen, beheben, anhalten, wenn grün” statt um schrittweise Anweisungen

Wie behebe ich Probleme?

Häufige Probleme und Lösungen

Referenz für Fehlermeldungen

Diagnose-Tools

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

TUI-Diagnose innerhalb der 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 die TUI-Diagnose.

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

Oder reichen Sie Issues unter github.com/openai/codex/issues ein.¹

Codex Security [PREVIEW]

Codex Security ist am 6. März 2026 in die Research-Preview-Phase gestartet und bringt kontextbewusste Application-Security-Reviews in den Codex-Stack.⁷⁷ Verfügbar für ChatGPT Pro-, Enterprise-, Business- und Edu-Kunden über Codex web.

Funktionsweise: Codex Security analysiert Repositories, um ein projektspezifisches Threat-Model zu erstellen, identifiziert Schwachstellen klassifiziert nach realer Auswirkung und prüft Befunde unter Druck in einer Sandbox-Umgebung, um sie zu validieren. Der Agent hebt Befunde mit höherer Konfidenz samt Fixes hervor und reduziert so das Rauschen unbedeutender Bugs.

Leistung: Während der Research Preview hat Codex Security 1,2 Millionen Commits gescannt und 10.561 Schwachstellen mit hohem Schweregrad identifiziert. Die Präzision verbesserte sich im Lauf der Zeit — das Rauschen wurde um 84 % reduziert, überbewertete Schweregrade um über 90 % verringert und die Falsch-Positiv-Rate halbiert. Das System hat reale Schwachstellen in OpenSSH, GnuTLS und Chromium gefunden, mit 14 zugewiesenen CVEs.⁷⁷

Hinweis: Codex Security ist getrennt vom in CLI integrierten Sandbox-Sicherheitsmodell. Die Sandbox schützt Ihren Rechner vor Codex; Codex Security schützt Ihre Codebasis vor Schwachstellen.

Enterprise-Bereitstellung

Admin-Steuerung (requirements.toml)

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

# /etc/codex/requirements.toml

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

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

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

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

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

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

Im Gegensatz zur benutzerseitigen config.toml, die Präferenzen festlegt, ist die requirements.toml eine harte Einschränkungsebene, die festlegt, welche Werte Benutzer auswählen können, und Benutzer können sie nicht überschreiben. Admin-Anforderungsregeln können nur prompt oder forbid (niemals stillschweigend zulassen).

macOS MDM-Konfiguration

Verteilen Sie über MDM unter Verwendung der Präferenzdomäne com.openai.codex.²¹ Codex respektiert die standardmäßigen macOS-MDM-Payloads (Jamf Pro, Fleet, Kandji usw.). Kodieren Sie TOML als base64 ohne Zeilenumbruch:

Rangfolge (höchste bis niedrigste):

1. macOS verwaltete Präferenzen (MDM)
2. Aus der Cloud abgerufene Anforderungen (ChatGPT Business / Enterprise)
3. /etc/codex/requirements.toml (lokales Dateisystem)

Cloud-Anforderungen füllen nur nicht gesetzte Anforderungsfelder, sodass höher priorisierte verwaltete Ebenen immer Vorrang haben. Cloud-Anforderungen sind Best-Effort; wenn der Abruf fehlschlägt oder eine Zeitüberschreitung auftritt, fährt Codex ohne die Cloud-Ebene fort.

OpenTelemetry-Integration

Codex unterstützt die Weitergabe des OpenTelemetry-Trace-Kontexts von standardmäßigen OTel-Umgebungsvariablen bis zu OpenAI-API-Aufrufen. Setzen Sie die standardmäßigen Umgebungsvariablen, bevor Sie Codex starten:

# 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 (Endpoint, Servicename, Ressourcenattribute)
• Der Trace-Kontext wird durch Codex an API-Aufrufe weitergeleitet und ermöglicht so eine durchgängige Observability
• Verwenden Sie Ressourcenattribute, um Traces nach Team, Umgebung oder Projekt zu kennzeichnen
• Beachten Sie die Datenschutzanforderungen, wenn Sie Prompt-/Tool-Logging aktivieren — Traces können Code-Snippets enthalten
• Konfigurierbare OpenTelemetry-Trace-Metadaten (v0.130.0+). Über den standardmäßigen OTEL_RESOURCE_ATTRIBUTES-Umschlag hinaus stellt das codex-otel-Crate jetzt konfigurierbare Trace-Metadaten bereit, sodass Administratoren Traces mit organisationsspezifischen Dimensionen (Cost-Center, Projekt-ID, Ticket-Referenz) kennzeichnen können, ohne OTEL_RESOURCE_ATTRIBUTES bei jedem Aufruf von Grund auf neu aufzubauen. Kombinieren Sie dies mit der reichhaltigeren Review-/Feedback-Analytik, die in derselben Version ausgeliefert wurde, für ein einheitliches Debugging und Triage über CLI-, App-Server- und Remote-Control-Sitzungen hinweg.⁹¹

Enterprise-Zugriff

• ChatGPT Business / Enterprise / Edu: Vom Org-Admin gesteuerter Zugriff, wobei aus der Cloud abgerufene Anforderungen automatisch angewendet werden. Unterstützt SSO über SAML/OIDC durch Ihren Identity Provider (Okta, Entra ID usw.)
• API: Standardmäßige API-Authentifizierung, Abrechnung und Org-/Projekt-Steuerung. OpenAI veröffentlicht SOC 2 Type II- und SOC 3-Berichte; HIPAA BAA für die Enterprise-Stufe verfügbar
• Codex SDK: Einbettung 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-Eingaben/-Ausgaben werden gemäß den Business-/Enterprise-/API-Bedingungen von OpenAI nicht für das Training verwendet - Für die Datenhaltung wird der OpenAI-API-Verkehr standardmäßig über US-basierte Infrastruktur geleitet; für EU-Datenhaltungsanforderungen wenden Sie sich an das Enterprise-Sales-Team von OpenAI - Sitzungstranskripte werden lokal gespeichert; nur API-Aufrufe verlassen den Rechner - ChatGPT Enterprise unterstützt Compliance-Frameworks einschließlich SOC 2, GDPR und CCPA

Rollout-Strategie

Empfohlener phasenweiser Rollout für Organisationen:

1. Pilot (Phase 1): Bereitstellung für 3-5 Senior-Ingenieure mit requirements.toml, die den Sandbox-Modus untrusted und cached Web-Suche erzwingt. Sammeln Sie Feedback zu AGENTS.md-Mustern und Anforderungen an MCP-Server.
2. Team-Erweiterung (Phase 2): Rollout auf das gesamte Team. Verteilen Sie die teamübergreifende config.toml per MDM oder Repository. Aktivieren Sie die workspace-write-Sandbox für vertrauenswürdige Repositories.
3. CI-Integration (Phase 3): Fügen Sie codex-action zu CI/CD-Pipelines hinzu für automatisierte PR-Überprüfung und Testgenerierung. Verwenden Sie --ephemeral, um die Kosten kalkulierbar zu halten.
4. Organisationsweit (Phase 4): Bereitstellung über MDM mit requirements.toml, die genehmigte MCP-Server, Sandbox-Richtlinien und Modell-Allowlists erzwingt.

Audit-Muster

Verfolgen Sie die Codex-Nutzung und setzen Sie Compliance durch:

• OpenTelemetry-Traces: Überwachen Sie API-Aufrufvolumen, Token-Nutzung und Latenz pro Team
• Sitzungspersistenz: Auditieren Sie ~/.codex/sessions/ für die Compliance-Überprüfung (deaktivieren mit --ephemeral in sensiblen Kontexten)
• MCP-Identitätsdurchsetzung: requirements.toml protokolliert blockierte Server-Versuche — überprüfen Sie auf nicht autorisierte Tool-Nutzung
• Git-Audit-Trail: Alle Codex-Dateiänderungen laufen über das standardmäßige Git — Überprüfung über Branch-Verlauf und PR-Diffs

Best Practices & Anti-Patterns

Prompting-Muster

1. Constraint-driven Prompts: Beginnen Sie mit Grenzen. „Ändern Sie NICHT die API-Verträge. Refaktorieren Sie nur die interne Implementierung.”
2. Strukturierte Reproduktionsschritte: Nummerierte Schritte führen zu besseren Bug-Fixes als vage Beschreibungen
3. Verifikationsanfragen: Schließen Sie mit „Führen Sie Lint und die kleinste relevante Test-Suite aus. Berichten Sie Befehle und Ergebnisse.”
4. Dateireferenzen: Verwenden Sie @filename, um spezifische Dateien an den Kontext anzuhängen
5. Outcome-driven Loops: „Implementieren, Tests ausführen, Fehler beheben, erst stoppen, wenn alle Tests bestehen.” Codex iteriert bis zur Fertigstellung

Test-Philosophie

Die Community konvergiert auf testgetriebene KI-Kollaboration:²²

• Definieren Sie Tests im Voraus als Abschlusssignale
• Lassen Sie Codex iterieren, bis Tests bestehen (red → green → refactor)
• Übernehmen Sie Tiger Style-Programmiermuster
• Stellen Sie exakten Dateitext bereit, wenn Sie Patches anfordern. Codex verwendet striktes Matching, kein Fuzzy-AST-basiertes Patching

Best Practices für das Kontext-Management

• Stellen Sie hochwertige lokale Dokumentation bereit, anstatt sich auf Web-Suche zu verlassen
• Pflegen Sie strukturiertes Markdown mit Inhaltsverzeichnissen und Fortschrittsdateien („progressive disclosure”)
• Normalisieren Sie Zeilenenden (LF vs. CRLF) über alle versionierten Dateien hinweg, um Patch-Fehler zu vermeiden
• Halten Sie AGENTS.md prägnant, da lange Anweisungen aus dem Kontext gedrängt werden

Git-Workflow

• Erstellen Sie immer einen neuen Branch, bevor Sie Codex auf unbekannten Repos ausführen
• Verwenden Sie patch-basierte Workflows (git diff / git apply) statt direkter Bearbeitungen
• Prü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 stellt von der Community gepflegte Konfigurationen bereit:²³

Wiederverwendbare Prompts (in ~/.codex/prompts/): - deep-reflector: Lerneffekte 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 mit Berechtigungsmodi an Claude Code übergeben - autonomous-skill: Sitzungsübergreifende Aufgabenautomatisierung mit Fortschrittsverfolgung - deep-research: Parallele Sub-Task-Orchestrierung - kiro-skill: Pipeline „Requirements → Design → Tasks → Execution”

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

End-to-End-Muster für gängige Entwicklungsszenarien.

Rezept 1: Einrichtung eines neuen Projekts

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

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

> Run the health endpoint test and confirm it passes

Rezept 2: Täglicher Entwicklungs-Flow

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 prü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.

Plan prüfen. Genehmigen oder steuern:

[Tab] Also add a migration script using Alembic

Nachdem Codex ausgeführt hat, verifizieren:

> 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 [EXPERIMENTAL]

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

Fortschritt später prüfen:

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

Den Fix lokal anwenden, sobald fertig:

codex apply <TASK_ID>

Migrationsleitfaden

Von Claude Code

Wichtige Unterschiede, die Sie verstehen sollten:

• Sandbox auf Betriebssystemebene: Codex verwendet Seatbelt/Landlock, keine Container. Die Einschränkungen wirken auf Kernel-Ebene, also unterhalb der Anwendungsschicht.
• Hooks werden ausgebaut: Codex unterstützt mittlerweile 5 Hook-Ereignisse: SessionStart, Stop und UserPromptSubmit (v0.114.0–v0.116.0, experimentell) sowie AfterAgent (v0.99.0) und AfterToolUse (v0.100.0). Das System deckt den Sitzungslebenszyklus, das Abfangen von Prompts und die Tool-Automatisierung ab, wobei die 12+ Lebenszyklus-Ereignisse von Claude Code weiterhin eine breitere Abdeckung bieten. Für noch nicht abgedeckte Automatisierungsmuster nutzen Sie AGENTS.md-Anweisungen oder Skills.
• Sub-Agents v2 (v0.117.0): Sub-Agents verwenden jetzt pfadbasierte Adressen (z. B. /root/agent_a) mit strukturiertem Inter-Agent-Messaging und Agent-Listing.⁷⁵ Dies erweitert die bestehende Maschinerie (max. 6 gleichzeitig, reduziert von 12 in v0.91.0). Multi-Agent-Rollen bleiben über die Konfiguration anpassbar (v0.104.0+).⁴⁷ v0.105.0 brachte spawn_agents_on_csv für Fanout über Zeilen hinweg mit Fortschrittsverfolgung und ETA.⁶¹ Codex fehlt weiterhin die explizite Task-Tool-UX von Claude Code 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 60.000+ Open-Source-Projekten. CLAUDE.md ist Claude-exklusiv.
• Profile ersetzen manuelles Umschalten: Statt Flags pro Lauf zu ändern, definieren Sie Profile in der config.toml.

Von GitHub Copilot

Was Sie gewinnen: - Sandboxing auf Betriebssystemebene (Seatbelt/Landlock — kernel-erzwungen statt containerbasiert) - Cloud-Task-Delegation mit codex apply - Konfigurationsprofile zum Wechseln zwischen Workflows - Desktop-App mit Worktree-Isolation

Von Cursor

Schnellreferenzkarte

╔═══════════════════════════════════════════════════════════════╗
║                    CODEX CLI QUICK REFERENCE                  ║
╠═══════════════════════════════════════════════════════════════╣
║                                                               ║
║  LAUNCH                                                       ║
║  codex                      Interactive TUI                   ║
║  codex "prompt"             TUI with initial prompt           ║
║  codex exec "prompt"        Non-interactive mode              ║
║  codex app                  Desktop app                       ║
║  codex resume               Resume previous session           ║
║  codex fork                 Fork a session                    ║
║                                                               ║
║  FLAGS                                                        ║
║  -m, --model <model>        Select model                      ║
║  -p, --profile <name>       Load config profile               ║
║  -s, --sandbox <mode>       Sandbox mode                      ║
║  -C, --cd <dir>             Working directory                 ║
║  -i, --image <file>         Attach image(s)                   ║
║  -c, --config <key=value>   Override config                   ║
║  --ask-for-approval <p>     Approval policy                   ║
║  --oss                      Use local models (Ollama)         ║
║  --search                   Enable live web search            ║
║                                                               ║
║  SLASH COMMANDS (in TUI)                                      ║
║  /compact      Free tokens   /diff        Git diff            ║
║  /review       Code review   /plan        Plan mode           ║
║  /model        Switch model  /status      Session info        ║
║  /fork         Fork thread   /goal        Persisted goal      ║
║  /vim          Modal Vim     /hooks       Browse/toggle hooks ║
║  /init         AGENTS.md scaffold                             ║
║  /mcp          MCP tools     /skills      Invoke skills       ║
║  /ps           Background    /personality Style               ║
║  /permissions  Approval mode /statusline  Footer config       ║
║  /fast         Toggle fast mode (default: on)                ║
║  /copy         Copy last response to clipboard                ║
║  /clear        Clear screen  /theme       Syntax highlighting ║
║                                                               ║
║  TUI SHORTCUTS                                                ║
║  @              Fuzzy file search                             ║
║  !command       Run shell command                             ║
║  Ctrl+G         External editor                               ║
║  Ctrl+L         Clear screen                                  ║
║  Enter          Inject instructions (while running)           ║
║  Esc Esc        Edit previous messages                        ║
║                                                               ║
║  EXEC MODE (CI/CD)                                            ║
║  codex exec --sandbox workspace-write "task" Sandboxed auto   ║
║  codex exec --json -o out.txt "task"    JSON + file output    ║
║  codex exec --output-schema s.json      Structured output     ║
║  codex exec resume --last "continue"    Resume session        ║
║                                                               ║
║  MCP MANAGEMENT [EXPERIMENTAL]                                ║
║  codex mcp add <name> -- <cmd>    Add STDIO server            ║
║  codex mcp add <name> --url <u>   Add HTTP server             ║
║  codex mcp list                    List servers                ║
║  codex mcp login <name>           OAuth flow                  ║
║  codex mcp remove <name>          Delete server               ║
║                                                               ║
║  PLUGINS                                                      ║
║  codex plugin marketplace add <src>     Add marketplace       ║
║  codex plugin marketplace upgrade       Upgrade marketplaces  ║
║                                                               ║
║  CLOUD [EXPERIMENTAL]                                         ║
║  codex cloud exec --env <ID> Start cloud task                 ║
║  codex cloud status <ID>     Check task progress              ║
║  codex cloud diff <ID>       View task diff                   ║
║  codex cloud list            List tasks                       ║
║  codex apply <TASK_ID>       Apply cloud diff locally         ║
║                                                               ║
║  CONFIG FILES                                                 ║
║  ~/.codex/config.toml        User config                      ║
║  .codex/config.toml          Project config                   ║
║  ~/.codex/AGENTS.md          Global instructions              ║
║  AGENTS.md                   Project instructions             ║
║  requirements.toml           Enterprise policy constraints    ║
║                                                               ║
║  SANDBOX MODES                                                ║
║  read-only          Read files only, no mutations             ║
║  workspace-write    Read/write in workspace + /tmp            ║
║  danger-full-access Full machine access                       ║
║                                                               ║
║  APPROVAL POLICIES                                            ║
║  untrusted     Prompt for all mutations                       ║
║  on-request    Prompt for boundary violations                 ║
║  never         No prompts                                     ║
║                                                               ║
║  MODELS (April 2026)                                          ║
║  gpt-5.5               Recommended default (400K in Codex)   ║
║  gpt-5.5-pro           Highest-effort GPT-5.5 tier            ║
║  gpt-5.4               Prior flagship / fallback              ║
║  gpt-5.4-mini          Subagent work, 2x faster (400K)        ║
║  gpt-5.3-codex         Legacy coding specialist               ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Änderungsprotokoll

Referenzen

Hinweis zu OpenAI-Blog-URLs: Die Referenzen ¹⁶, ²⁵–³⁰, ³³, ⁶⁴, ⁶⁶, ⁶⁷, ⁷⁶ und ⁷⁷ verlinken auf Blogbeiträge unter openai.com/index/, die wegen Cloudflare bot protection automatisierten Zugriff mit HTTP 403 beantworten. Diese URLs sind gültig, wenn Sie sie über einen normalen Webbrowser aufrufen.