Codex CLI: Die maßgebliche technische Referenz

Kurzfassung: Codex ist ein Coding Agent für mehrere Oberflächen, der Ihre Codebasis liest, Befehle in einer Sandbox auf Betriebssystemebene ausführt, Dateien patcht und Aufgaben an die Cloud delegiert. Wenn Sie fünf Kernsysteme beherrschen (config.toml, Sandbox-/Approval-Modell, AGENTS.md, MCP und skills), wird Codex zum Kraftverstärker. Nutzen Sie Profile für Kontextwechsel, /compact zur Verwaltung des Kontextbudgets, /goal für dauerhaft gespeicherte Arbeitsziele und AGENTS.md für projektübergreifende Tool-Anweisungen, die in Codex, Cursor, Amp und weiteren Tools funktionieren. GPT-5.5 (veröffentlicht 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.⁸³ Seit CLI v0.140.0 (stable, 15. Juni 2026) zeigt /usage die tägliche, wöchentliche und kumulative Konto-Token-Aktivität, Sitzungen können über codex delete / /delete dauerhaft gelöscht werden (mit Bestätigungsschutz), /import migriert Setup, Projektkonfiguration und aktuelle Chats selektiv aus Claude Code, das Tippen von @ öffnet standardmäßig ein einheitliches Mentions-Menü für Dateien, Plugins und skills, und die verwaltete Amazon Bedrock API-Key-Authentifizierung wird zusammen mit verschlüsselter lokaler Speicherung für CLI- und MCP-OAuth-Anmeldedaten ausgeliefert; die experimentellen /realtime-Sprachsteuerungen wurden aus der TUI entfernt.¹⁰² Seit CLI v0.139.0 (stable, 9. Juni 2026) kann code mode die eigenständige Websuche direkt aufrufen (auch aus verschachtelten JavaScript-Tool-Aufrufen) und Klartext-Ergebnisse erhalten, Tool-/Connector-Eingabeschemas bewahren nun oneOf/allOf-Konstrukte für bessere Kompatibilität mit großen Schemas und MCP, codex doctor ergänzt Editor- und Pager-Umgebungsdetails (mit Schwärzung sensibler Werte in JSON), und der Plugin Marketplace stellt Quellen in codex plugin marketplace list --json mit schnellerer Auflistung aus dem zwischengespeicherten Katalog bereit.¹⁰³ v0.138.0 (8. Juni) ergänzte /app, um eine CLI-Sitzung auf macOS und Windows an die Desktop-App zu übergeben, machte lokale Bildpfade für das Modell sichtbar, flexibilisierte die Auswahl des Reasoning-Aufwands und gab der Plugin-Automatisierung strukturierte JSON-Ausgaben.¹⁰⁴ v0.137.0 (4. Juni) lieferte multi-agent v2 aus (Runtime pro Thread beibehalten, sauberere Follow-ups und Metadaten-Defaults, hide_spawn_agent_metadata standardmäßig true), F13-F24-TUI-Tastenbelegungen und eine v1-skills-Erweiterung mit Katalogauflösung pro Turn.¹⁰⁵ Seit CLI v0.135.0 (28. Mai 2026) meldet codex doctor umfangreichere Umgebungs-, Git-, Terminal-, App-Server- und Thread-Bestände; /status zeigt Remote-Verbindungsdetails und Serverversion, wenn die TUI über eine Remote-Verbindung verbunden ist; der vim mode erhielt Textobjektbearbeitung, verbessertes Verhalten bei Wort-/Zeilenenden und einen konfigurierbaren Interrupt-Turn; /permissions versteht nun benannte Berechtigungsprofile und zeigt benutzerdefinierte Profile an; paketierte Codex-Builds erkennen und verwenden den gebündelten gepatchten zsh-Helper auf unterstützten macOS-Versionen; und das Python SDK stellt benutzerfreundliche Sandbox-Presets für Thread- und Turn-APIs bereit.¹⁰⁷ v0.134.0 (26. Mai 2026) führte Suche in der lokalen Unterhaltungshistorie mit nicht nach Groß-/Kleinschreibung unterscheidenden Inhalts-Treffern und Ergebnisvorschauen ein, machte --profile zum primären Profilselektor in CLI-, TUI-Berechtigungs- und Sandbox-Flows (Legacy-Profilkonfigurationen werden mit Migrationshinweisen abgelehnt), verbesserte die MCP-Einrichtung mit umgebungsbezielter Konfiguration pro Server und OAuth-Optionen für streambare HTTP-Server, machte Connector-Tool-Schemas zuverlässiger, indem lokale $ref/$defs bewahrt und übergroße Schemas komprimiert werden, ließ read-only-MCP-Tools parallel laufen, wenn sie readOnlyHint ankündigen, und ergänzte umfangreicheren Erweiterungs- und Hook-Kontext, einschließlich Unterhaltungshistorie für Erweiterungstools.¹⁰¹ v0.133.0 (21. Mai 2026) aktivierte Ziele standardmäßig mit dediziertem Speicher und Fortschrittsverfolgung; codex remote-control erhielt Foreground-Bereitschaft/-Status sowie daemonartiges Starten/Stoppen; Berechtigungsprofile bekamen Listen-APIs, Vererbung, verwaltetes requirements.toml, Runtime-Aktualisierung und stärkere Windows-Sandbox-Integration; die Plugin Discovery zeigt installierte Versionen, Marketplace-Roots und Remote Collections; und Erweiterungen können Start/Stopp von Subagents, Tool-Ausführung, Turn-Metadaten sowie asynchrone Approval-/Turn-Verarbeitung beobachten. Das Codex-App-Update vom 21. Mai ergänzte Appshots für vorderste Mac-Fenster, Goal mode GA in App/IDE/CLI, Verbesserungen bei Browser-Anmerkungen in der App und optional gesperrte Computer Use für berechtigte Mac-Benutzer.⁹⁹¹⁰⁰ v0.132.0 (20. Mai 2026) ergänzte Python SDK-Authentifizierung als First-Class-Funktion, einfachere rein textbasierte Turn-APIs, ein umfangreicheres TurnResult, codex exec resume --output-schema, schnelleren TUI-Start, auth-gestützte Remote-Executor-Registrierung und Bildtreue-Erhaltung in App-Server-Turns. Bevorzugen Sie weiterhin explizite Sandbox-/Approval-Flags oder Berechtigungsprofile gegenüber dem alten --full-auto; js_repl bleibt entfernt.^{86878991969798}

Codex arbeitet als Coding Agent für mehrere Oberflächen, nicht als Chatbot, der Code schreibt. Die CLI liest Ihre Codebasis, führt Befehle in einer Sandbox aus, patcht Dateien, verbindet sich über MCP mit externen Diensten und delegiert lang laufende Aufgaben an die Cloud. Sie läuft lokal, denkt aber global; dieselbe Intelligenz treibt je nach Arbeitsweise fünf unterschiedliche Oberflächen an, einschließlich der neuen Chrome-Erweiterung, die Codex in Ihrem Browser ausführt, ohne ihn zu übernehmen.⁹⁰

Der Unterschied zwischen beiläufiger und effektiver Codex-Nutzung hängt von fünf Kernsystemen ab. Wenn Sie diese beherrschen, wird Codex zum Kraftverstärker:

1. Konfigurationssystem: steuert das Verhalten über config.toml
2. Sandbox- und Approval-Modell: begrenzt, was Codex tun darf
3. AGENTS.md: definiert Betriebsvereinbarungen auf Projektebene
4. MCP-Protokoll: erweitert Fähigkeiten auf externe Dienste
5. Skills-System: bündelt wiederverwendbare Domänenexpertise

Ich habe Codex monatelang neben Claude Code in Produktions-Codebasen, CI/CD-Pipelines und Team-Workflows eingesetzt. Dieser Leitfaden verdichtet diese Erfahrung zu der vollständigen Referenz, die ich mir zu Beginn gewünscht hätte. Jede Funktion enthält die tatsächliche Syntax, echte Konfigurationsbeispiele und die Randfälle, über die selbst erfahrene Benutzer stolpern.

Stabilitätshinweis: Funktionen, die mit [EXPERIMENTAL] oder under development gekennzeichnet sind, können sich zwischen Releases ändern. Seit v0.133.0 (21. Mai 2026) sind Ziele standardmäßig aktiviert, Berechtigungsprofile eine verwaltete First-Class-Oberfläche, Plugin Discovery besser prüfbar und remote-control lässt sich leichter als Foreground- oder daemonisierter App-Server-Befehl ausführen. Codex Cloud und code mode bleiben experimentell oder in Entwicklung, während zentrale CLI, Sandboxing, AGENTS.md, config.toml, Skills, hooks, Multi-Agent-Tools, Plugins, Browser, Computer Use und Appshots je nach Plattform und Tarif stabile oder dokumentierte benutzerseitige Oberflächen sind. v0.132.0 ergänzt Python SDK-Authentifizierung und strukturierte Resume-Automatisierung; v0.131.0 fügte codex doctor, vereinheitlichte @-Mention-Suche, Marketplace-CLI-Befehle, versionsbewusstes Plugin-Sharing, daemonverwaltete remote-control mit Runtime-Aktivierung/-Deaktivierung, Registry-gestützte Umgebungen und zusätzliche Windows-Sandbox-Härtung hinzu.⁹⁶⁹⁷⁹⁸ Das alte --full-auto bleibt veraltet und js_repl bleibt entfernt.⁸⁶⁸⁷

Wichtigste Erkenntnisse

• Fünf Oberflächen, ein Gehirn: CLI, Desktop App, IDE extension, Cloud tasks und die neue Chrome extension nutzen alle dieselbe GPT-5.x-Codex-Intelligenz. Wählen Sie also die Oberfläche, die zu Ihrem Workflow passt.⁹⁰
• Sandboxing auf OS-Ebene: Codex erzwingt Dateisystem- und Netzwerkbeschränkungen auf Kernel-Ebene (Seatbelt unter macOS, Landlock + seccomp unter Linux), nicht innerhalb von Containern.
• AGENTS.md funktioniert werkzeugübergreifend: Ihre Projektanweisungen funktionieren in Codex, Cursor, Copilot, Amp, Jules, Gemini CLI, Windsurf, Cline, Aider, Zed und mehr als 60.000 Open-Source-Projekten. Einmal schreiben, überall nutzen.
• Profile sparen Aufwand beim Kontextwechsel: Definieren Sie benannte Config-Voreinstellungen (fast, careful, auto) und wechseln Sie mit --profile zwischen ihnen.
• Kontextverwaltung ist wichtig: GPT-5.5 bietet ein Kontextfenster von 400K in Codex und 1M im API; GPT-5.4 mini bietet ebenfalls 400K für Subagent-Arbeit mit geringerer Latenz; GPT-5.3-Codex bietet 272K Eingabe. Nutzen Sie /compact, fokussierte Prompts und @file-Referenzen, um Token-Budgets proaktiv zu verwalten.⁸³

So verwenden Sie diesen Guide

Dies ist eine Referenz mit mehr als 2.500 Zeilen — steigen Sie dort ein, wo es zu Ihrem Erfahrungsstand passt:

Die Quick Reference Card am Ende bietet eine schnell erfassbare Zusammenfassung aller wichtigen Befehle.

So funktioniert Codex: Das Mental Model

Bevor Sie in die Funktionen einsteigen, sollten Sie verstehen, wie die Architektur von Codex alles prägt, was Sie damit tun. Das System arbeitet über vier Oberflächen hinweg, die von einer gemeinsamen Intelligenzschicht getragen werden:

┌─────────────────────────────────────────────────────────┐
│                    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 im 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 erschließt Ihre Codebasis. Wenn der Kontext voll wird, komprimiert Codex die Unterhaltung, um Platz freizugeben. Diese Schicht verbraucht Tokens.

Security Layer: Jeder Befehl, den Codex ausführt, läuft durch eine Sandbox auf OS-Ebene. Unter macOS erzwingt Apples Seatbelt-Framework Beschränkungen auf Kernel-Ebene. Unter Linux filtern Landlock + seccomp den Zugriff auf Dateisystem und Systemaufrufe. Die Sandbox arbeitet auf Kernel-Ebene, nicht innerhalb von Containern. Anschließend entscheidet die Genehmigungsrichtlinie, wann eine menschliche Bestätigung angefordert wird.

Extension Layer: MCP verbindet externe Dienste (GitHub, Figma, Sentry). Skills bündeln wiederverwendbare Workflows, die Codex bei Bedarf lädt. Apps verbinden sich mit ChatGPT connectors. Websuche ergänzt Echtzeitkontext aus dem Internet.

Surface Layer: CLI für Terminal-Power-User und Automatisierung. Desktop App für mehrsträngiges Projektmanagement. IDE extension für Edit-Compile-Test-Schleifen. Cloud für asynchrone Aufgaben, die unabhängig laufen.

Die wichtigste Erkenntnis: Die meisten Benutzer verwenden nur eine Oberfläche. Power-User nutzen alle fünf: Cloud für lang laufende Aufgaben, CLI für deterministische Repo-Operationen, IDE extension für enge Coding-Schleifen, die Desktop App für Planung und Koordination und Chrome für angemeldete Browser-Workflows.

Inhaltsverzeichnis

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

Wie installiere ich Codex?

Package Manager

# 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 das passende Binary herunter und legt es in Ihrem PATH ab.

Binary-Downloads

Für Umgebungen ohne npm oder Homebrew laden Sie plattformspezifische Binaries aus den 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 aus dem experimentellen Status übernommen). 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 Account (empfohlen): Melden Sie sich mit Ihrem bestehenden Plus-, Pro-, Team-, Business-, Edu- oder Enterprise-Abonnement an. Voller Funktionszugriff einschließlich Cloud Tasks.
2. API Key: Wird über die Umgebungsvariable CODEX_API_KEY oder codex login --with-api-key gesetzt. 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 Keychain) oder auto (keyring, falls verfügbar, sonst file als Fallback).

Shell Completions

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

Schnellstart: Ihre erste Sitzung

In 5 Minuten von null zu produktiv.

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 wichtige Dateien und erklärt die Codebase. 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 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.

Wie es weitergeht: - 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)

Zentrale Interaktionsoberflächen

Codex bietet vier unterschiedliche Oberflächen, die 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: Prompts eingeben, Dateien mit @ anhängen, Shell-Befehle mit dem Präfix ! ausführen
• Ausgabebereich: Gestreamte Modellantworten, Tool-Aufrufe und Befehlsausgaben
• Statusleiste: Modell, Token-Nutzung, git-Branch, Sandbox-Modus

Wichtige TUI-Tastenkürzel:

Änderung der Statuszeile (v0.121.0): Die frühere Kontextfenster-Anzeige in der Statuszeile wurde durch einen Kontext-Prozentindikator ersetzt, der zeigt, wie voll Ihr Kontextfenster ist. Wenn Sie Skripte oder hooks haben, die die Statuszeile parsen, prüfen Sie diese Formatänderung.⁸² Codex zeigt außerdem eine CLI-Update-Ankündigung an, wenn eine neue Version verfügbar ist.

Slash commands, die in der TUI verfügbar sind:

Neugestaltung des Workflow-Pickers (v0.129.0): Resume und Fork sind über einen neu gestalteten Picker jetzt leichter erreichbar, und ein neuer Raw-Scrollback-Modus lässt Sie durch das ungerenderte Transkript scrollen, wenn Sie Befehle oder Modellausgaben wortgetreu kopieren müssen. Nützlich beim Triagieren einer langen Debugging-Sitzung oder beim Weiterleiten von Ausgaben an ein anderes Tool.⁸⁹

Einheitliches @-Mentions-Menü (v0.140.0): Wenn Sie im Composer @ eingeben, öffnet sich jetzt standardmäßig ein einheitliches Mentions-Menü für Dateien, plugins und skills. Es ersetzt den bisherigen, nur dateibasierten Anhänge-Flow — ein Tastendruck, um jede Projektressource zu referenzieren.¹⁰²

2. Codex Desktop App (macOS + Windows)

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

Die Desktop App ergänzt Funktionen, die die CLI nicht hat:

• Multitasking: Mehrere parallele Agents gleichzeitig über verschiedene Projekte hinweg ausführen
• Git-worktree-Isolation: Jeder Thread arbeitet auf einer isolierten Kopie Ihres Repos
• Inline-Diff-Review: Änderungen stagen, zurücksetzen und committen, ohne die App zu verlassen
• Integriertes Terminal: Thread-spezifisches Terminal zum Ausführen von Befehlen
• Conversation forking: Unterhaltungen verzweigen, um Alternativen zu erkunden
• Schwebende Pop-out-Fenster: Unterhaltungen in portable Fenster auskoppeln
• Automations: Wiederkehrende Aufgaben planen (Issue-Triage, CI-Monitoring, Alert-Reaktion)
• Appshots: Das vorderste Mac-App-Fenster mit Screenshot und verfügbarem Text an einen Thread anhängen
• In-App-Browser-Kommentare: Lokale oder öffentliche Seiten in der Vorschau anzeigen, Element-/Bereichskommentare hinterlassen und Codex präzises visuelles Feedback umsetzen lassen
• Computer Use: Codex erlaubte Mac-Apps für abgegrenzte GUI-Arbeit bedienen lassen; gesperrte Nutzung ist für berechtigte Remote-Mac-Computer-Use-Turns opt-in

Wann Sie die App statt der CLI verwenden sollten: Verwenden Sie die Desktop App, wenn Sie mehrere Arbeitsstränge koordinieren oder visuelle Diff-Reviews benötigen. Verwenden Sie die CLI, wenn Sie Terminal-Komponierbarkeit, Scripting oder CI/CD-Integration möchten.

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

Die Codex IDE extension integriert sich direkt in Ihren Editor:

• Agent mode standardmäßig: Liest Dateien, nimmt Änderungen vor, führt Befehle aus
• Inline-Bearbeitungen: Kontextbezogene Vorschläge in Ihren aktiven Dateien
• Geteilte Sitzungen: Sitzungen werden zwischen CLI und IDE extension synchronisiert
• Dieselbe Authentifizierung: Mit ChatGPT-Account oder API-Schlüssel anmelden

Installation über den VS Code Marketplace oder die Extension-Stores von Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Cloud-Aufgaben laufen asynchron in von OpenAI verwalteten Umgebungen:

• Fire and forget: Aufgaben in die Warteschlange stellen, die unabhängig von Ihrem lokalen Rechner laufen
• Parallele Ausführung: Mehrere Cloud-Aufgaben gleichzeitig ausführen
• PR-Erstellung: Codex erstellt Pull Requests aus abgeschlossener Arbeit
• Lokal anwenden: Cloud-Ergebnisse mit codex apply <TASK_ID> in Ihr lokales Repo ziehen

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

Cloud-Aufgaben sind auch über chatgpt.com/codex zugänglich.⁴

5. Codex for Chrome [NEW]

Codex wird als Browsererweiterung für Chrome ausgeliefert und ergänzt die CLI, Desktop App, IDE extension und Cloud um eine fünfte Oberfläche. Die Erweiterung ist dafür gedacht, Ihr normales Browsing zu begleiten, nicht es zu übernehmen: Codex arbeitet im Hintergrund parallel über Tabs hinweg, und Sie behalten die Kontrolle darüber, welche Websites es berührt.⁹⁰

• Parallele Tab-Ausführung: Codex arbeitet über mehrere Tabs gleichzeitig, ohne den Vordergrund-Tab zu blockieren.
• Website-spezifische Kontrolle: Sie setzen fest, 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 maßgebliche Quelle ist — Admin-Konsolen, interne Dashboards, Content-Management-UIs, Ticketsysteme — und ist kein Ersatz für die CLI bei lokalen Repos.
• Dasselbe Gehirn: Codex for Chrome nutzt dieselbe GPT-5.x-Codex-Intelligenz wie die anderen Oberflächen. Eine AGENTS.md- oder skills-Konfiguration, die in der CLI funktioniert, überträgt daher dieselben Konventionen auf browsergestützte Arbeit.

Installation über die Codex Chrome extension docs.⁹⁰

Tiefer Einblick in das Konfigurationssystem

Codex verwendet TOML für die Konfiguration. Die Prioritätshierarchie zu verstehen, ist entscheidend, weil sie bestimmt, welche Einstellungen bei Konflikten gelten.

Priorität (höchste bis niedrigste)

1. Session overrides (höchste): CLI Flags (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) und -c key=value Overrides
2. Projektkonfiguration (.codex/config.toml, wird von CWD aufwärts bis zum Projektstamm gesucht; 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 wirkt als Richtlinien-Constraint-Ebene, die einschränkt, welche Werte Benutzer nach dem normalen Zusammenführen der Konfiguration 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 = 400000           # Token count available to active model (override)
model_auto_compact_token_limit = 200000 # Threshold triggering automatic history compaction
model_reasoning_effort = "medium"       # minimal|low|medium|high|xhigh (model-dependent)
model_reasoning_summary = "auto"        # auto|concise|detailed|none
model_verbosity = "medium"              # low|medium|high
personality = "pragmatic"               # none|friendly|pragmatic
review_model = "gpt-5.5"               # Optional model for /review command
service_tier = "fast"                  # Preferred service tier for new turns
oss_provider = "lmstudio"              # lmstudio|ollama (used with --oss)

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

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

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

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

# ─── Shell Environment ─────────────────────────────────
allow_login_shell = false               # Allow login shell semantics (loads .profile/.zprofile)

[shell_environment_policy]
inherit = "all"                         # all|core|none
ignore_default_excludes = false         # Set true to keep KEY/SECRET/TOKEN vars
exclude = []                            # Glob patterns to exclude
set = {}                                # Explicit overrides
include_only = []                       # Whitelist patterns

# ─── Authentication ────────────────────────────────────
cli_auth_credentials_store = "file"     # file|keyring|auto
forced_login_method = "chatgpt"         # chatgpt|api
mcp_oauth_callback_port = 0            # Fixed port for MCP OAuth callback (0 = random)
mcp_oauth_credentials_store = "auto"   # auto|file|keyring

# ─── History & Storage ─────────────────────────────────
[history]
persistence = "save-all"                # save-all|none
max_bytes = 0                           # Cap size (0 = unlimited)

tool_output_token_limit = 10000         # Max tokens per tool output
log_dir = ""                            # Custom log directory
sqlite_home = ""                        # Override SQLite-backed resumable state location

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

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

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

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

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

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

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

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

# ─── Per-Project Overrides ────────────────────────────
[projects."/absolute/path/to/repo"]
trust_level = "trusted"                 # Per-project trust override

Profile

Benannte Konfigurationsvorlagen 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"

Ein Profil aktivieren:

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

Expertentipp: Legen Sie mit profile = "fast" auf oberster Ebene Ihrer Konfiguration ein Standardprofil fest. Pro Session überschreiben Sie es mit --profile.

Benutzerdefinierte Model Providers

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

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

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

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

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

Warnung: Das chat/completions Wire-API (wire_api = "chat") wurde für von OpenAI gehostete Modelle als veraltet markiert; OpenAI hat die Entfernung für Februar 2026 angekündigt.³⁴ Lokale Anbieter (Ollama, LM Studio) akzeptieren dieses Format möglicherweise weiterhin. Für OpenAI-Endpunkte verwenden Sie stattdessen wire_api = "responses".

Lokale Modelle mit dem Flag --oss verwenden:

codex --oss "explain this function"               # Uses default OSS provider
codex --oss --local-provider lmstudio "explain"   # Explicit LM Studio
codex --oss --local-provider ollama "explain"      # Explicit Ollama

Oder in der Konfiguration festlegen:

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

Inline-Konfigurations-Overrides

Beliebige Konfigurationswerte über die Befehlszeile überschreiben:

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)

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.⁸³

GPT-5.4 bleibt über alle Codex-Oberflächen hinweg verfügbar (CLI, App, IDE-Extension, Cloud).⁶⁴ 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.⁷¹

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.⁹²

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.⁷⁶

Modell-Auswahl-Flussdiagramm

Is this a quick fix or simple question?
├─ Yes → gpt-5.1-codex-mini (fastest, cheapest)
└─ No
   ├─ Do you need real-time pairing speed?
   │  ├─ Yes → gpt-5.3-codex-spark (near-instant, Pro only)
   │  └─ No
   │     ├─ 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- & Approval-System?

Codex verwendet ein zweischichtiges Sicherheitsmodell, das trennt, was technisch möglich ist, von wann Codex um menschliche Approval bittet. Der Ansatz unterscheidet sich grundlegend vom Berechtigungssystem von Claude Code — Codex setzt Einschränkungen auf Ebene des OS-Kernels durch.⁵ Siehe auch Enterprise-Bereitstellung für requirements.toml-Einschränkungen, die Administratoren organisationsweit durchsetzen.

Schicht 1: Sandbox (was möglich ist)

Die Sandbox steuert Datei- und Netzwerkzugriff über OS-native Mechanismen:

Plattformspezifische Durchsetzung:

• macOS: Apples Seatbelt-Framework über sandbox-exec mit modusspezifischen Profilen, die zur Laufzeit kompiliert und vom Kernel durchgesetzt werden⁶. Seit v0.121.0 können macOS-Sandbox-Profile bestimmte Unix sockets allowlisten (z. B. docker.sock, Editor-IPC-Sockets), und private DNS-Auflösung wird standardmäßig nicht mehr blockiert.⁸²
• Linux: Landlock für Dateisystemeinschränkungen + seccomp für Syscall-Filterung. Ein eigenständiger Hilfsprozess (codex-linux-sandbox) bietet zusätzliche Defense-in-Depth-Isolation.⁵ Bubblewrap (bwrap) wird vendored und als Teil des Linux-Builds kompiliert (in v0.100.0 von optional hochgestuft)⁷. v0.117.0 verbesserte die Sandbox-Zuverlässigkeit auf älteren Distros mit Legacy-Kernelkonfigurationen.⁷⁵ v0.129.0 härtete den Sandbox-Start unter Linux und hob das vendored Bubblewrap auf 0.11.2 mit Upstream-Sicherheitspatches an; v0.130.0 ergänzte weitere Starthärtungen.⁸⁹⁹¹
• Windows: Native Sandbox mit eingeschränkten Tokens (in v0.100.0 von experimentell hochgestuft). WSL wird ebenfalls unterstützt (erbt Linux Landlock + seccomp). v0.117.0 enthält Verbesserungen an der Restricted-Token-Sandbox für bessere Prozessisolation.⁷⁵ v0.130.0 gewährt Sandbox-Benutzern Zugriff auf den Binary-Cache der Desktop-Runtime, sodass die Windows-Sandbox Runtime-Binaries für Workspace-Sandbox-Benutzer zuverlässig auflösen kann.⁹¹

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

Sicherheitsfixes: - zsh-fork Sandbox-Bypass (v0.106.0): Eine Schwachstelle wurde behoben, bei der Shell-Ausführung über zsh-Forking Sandbox-Einschränkungen umgehen konnte.⁶⁰ Wenn Sie eine frühere Version verwenden, aktualisieren Sie sofort. - Eingabegrößenlimit (v0.106.0): Codex erzwingt jetzt ein Eingabelimit von ungefähr 1 Million Zeichen, um Hänger durch übermäßig große Payloads zu verhindern.⁶⁰ - Sicheres devcontainer-Profil (v0.121.0): Ein neues gehärtetes Kundenprofil für Docker-devcontainers verwendet Bubblewrap für 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 stören können.⁸² Wenn Sie sich für Logging oder Validierung auf hooks verlassen, beachten Sie, dass eine Guardian-Review sie ü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 Commands unter Linux erhalten jetzt ein minimales /dev-Dateisystem, was die Kompatibilität mit Tools verbessert, die Device-Nodes erwarten.⁶¹

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

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

Schicht 2: Approval Policy (wann gefragt wird)

Die Approval Policy legt fest, wann Codex pausiert, um menschliche Bestätigung einzuholen:

on-failure erscheint noch in einigen älteren Beispielen und Kompatibilitätspfaden, aber die aktuellen OpenAI-Konfigurationsdokumente markieren 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 Approval-IDs (v0.104.0+)

Codex weist jetzt jedem Command innerhalb einer mehrstufigen Shell-Ausführung eindeutige Approval-IDs zu. Dadurch sind Approvals granular — wenn Sie einen Command in einer Sequenz genehmigen, werden nachfolgende Commands in derselben Shell-Invocation nicht automatisch genehmigt.⁴⁹

Flexible Approval-Steuerung (v0.105.0+)

Der Approval-Flow unterstützt jetzt zusätzliche Sandbox-Berechtigungen und granulare Ablehnung:⁶¹

• Zusätzliche Sandbox-Berechtigungen: Wenn ein Command Zugriff über den aktuellen Sandbox-Modus hinaus benötigt, kann Codex bestimmte zusätzliche Berechtigungen anfordern, statt einen vollständigen Moduswechsel zu verlangen
• Granulare Ablehnung: Lehnen Sie einzelne Tool Calls mit Feedback ab, damit Codex seinen Ansatz anpassen kann, statt denselben Command einfach erneut zu versuchen

Runtime-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 trifft, die erhöhte Zugriffsrechte benötigt, kann es spezifische Berechtigungen (Dateisystempfade, Netzwerkzugriff usw.) formal über den TUI-Approval-Flow anfordern, statt still zu scheitern oder zu verlangen, dass der Benutzer mit anderen Flags neu startet.

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

Berechtigungsprofile teilen Dateisystem- und Netzwerk-Sandbox-Policies in benannte, wiederverwendbare Abschnitte auf. Setzen Sie default_permissions auf ein integriertes Profil wie :read-only, :workspace, oder verweisen Sie auf eine benutzerdefinierte [permissions.<name>]-Tabelle.⁸⁷ v0.133.0 hebt Profile zu einer verwalteten Oberfläche an: list APIs stellen verfügbare Profilmetadaten bereit, Profile können voneinander erben, verwaltete requirements.toml können Berechtigungsanforderungen deklarieren, aktive Profile werden zur Laufzeit aktualisiert, und das Windows-Sandbox-Setup verwendet jetzt das aufgelöste Profil statt einer separaten Ad-hoc-Policy.⁹⁸

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 selbst dann nicht lesbar sein sollen, wenn der Projekt-Root beschreibbar ist. Für einmalige Command-Ausnahmen sollten Sie Regeln bevorzugen, statt ein Profil breit auszuweiten.⁸⁷

Legacy-Hinweise zu --full-auto

Ältere Guides 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 für interaktive Läufe nicht mehr auf. Verwenden Sie stattdessen die expliziten Flags oben oder ein benanntes Berechtigungsprofil.⁸⁶

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

Empfohlene Konfigurationen

Tägliche Entwicklung (sichere Standardeinstellung):

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 Approval für jeden Command 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, statt für jede Aktion menschliche Approval zu verlangen. Die Guardian-Sitzung bleibt über Approvals hinweg bestehen, um Prompt-Cache wiederzuverwenden und Start-Overhead zu vermeiden. Jede Review erhält einen sauberen Verlauf (frühere Entscheidungen leaken nicht in spätere Reviews).⁷³

Konfigurieren Sie den Reviewer in config.toml:

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

Das ist besonders nützlich für CI/CD-Workflows, bei denen Sie automatisierte Review mit Reasoning möchten, statt pauschal approval_policy = "never" zu setzen.

Netzwerkzugriff aktivieren

Codex blockiert Netzwerkzugriff im Modus workspace-write 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-Support (v0.104.0+)

Für Unternehmensumgebungen, die WebSocket-Traffic ü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 Unterstützung für HTTPS_PROXY und SOCKS5-Proxys (v0.93.0+) und decken alle Transportschichten ab.

Die Sandbox testen

Überprüfen Sie das Sandbox-Verhalten, bevor Sie ihr 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 Commands unter einem Workspace-scoped Profil mit einem Permission-denied-Fehler fehlschlagen. Wenn einer der beiden Commands erfolgreich ist, müssen Sie Ihre Sandbox-Konfiguration untersuchen.

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 experimentell 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 Auflistungen als <server>:<tool> statt als bloße Namen erscheinen — aktualisieren Sie alle Skripte oder Prompts, die mit 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-Status-Metadaten werden jetzt über MCP-Tool-Metadaten weitergegeben, damit Server ihr Verhalten anpassen können (z. B. warnen, wenn sie in einer read-only Sandbox laufen). Die benutzerdefinierte Anfrage codex/sandbox-state wurde entfernt — verwenden Sie stattdessen den Metadatenpfad. Phase 3 des Rollouts der MCP Apps landet hier mit Unterstützung für Tool-Aufrufe; abgeflachte verzögerte Tool-Aufrufe werden jetzt für Server unterstützt, die das Deferred-Call-Muster verwenden.⁸²

MCP Servers konfigurieren

STDIO servers (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 servers (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. /mcp verbose (v0.123.0+)⁸⁴ gibt vollständige Serverdiagnosen, Ressourcen und Ressourcenvorlagen zurück — hilfreich, wenn ein Server nicht geladen wird oder Tools nicht dort erscheinen, wo Sie sie erwarten. Einfaches /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 einer der 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 Approval-Parametern 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")

Erwähnenswerte MCP Servers

Praktische Muster

Muster 1: Kontextbewusste Entwicklung — Kombinieren Sie Context7 mit der Dokumentation Ihres Frameworks, 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 ca. 25.000 Zeichen gekürzt. Verwenden Sie bei Tools, die große Payloads zurückgeben (Datenbankabfragen, Log-Erfassungen), enabled_tools, um auf bestimmte Tools zu beschränken und die Antworten fokussiert zu halten.

Muster 2a: Multimodale Tool-Ausgabe (v0.107.0) — Benutzerdefinierte Tools können jetzt neben Text auch multimodale Ausgaben (Bilder, Rich Content) 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-MCP-Governance — Sperren Sie über requirements.toml, welche MCP servers 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. Die vollständige Richtlinienkonfiguration finden Sie unter Enterprise-Bereitstellung.

Code Mode [EXPERIMENTAL]

Code mode (v0.114.0) ermöglicht stärker isolierte Coding-Workflows, indem der Umfang des Agenten auf codebezogene Operationen beschränkt wird.⁷⁰ Wenn aktiviert, konzentriert sich der Agent auf das Lesen, Schreiben und Testen von Code ohne breitere Systeminteraktionen.

Seit v0.139.0 kann code mode standalone web search direkt aufrufen — auch aus verschachtelten JavaScript-Tool-Aufrufen heraus — und erhält Klartextergebnisse, sodass ein code-mode-Ablauf Live-Informationen abrufen kann, ohne den sandboxed Coding-Kontext zu verlassen.¹⁰³

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

JavaScript REPL Runtime [REMOVED]

Codex v0.100.0 fügte eine experimentelle JavaScript REPL Runtime (js_repl) hinzu, und v0.106.0 machte sie über die /experimental-Oberfläche zugänglich.⁶⁰ Diese Anleitung ist jetzt 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 nicht features.js_repl = true hinzu. Verwenden Sie Shell-Befehle, eingecheckte Skripte, MCP-Tools oder einen Codex skill mit einem scripts/-Ordner, wenn Sie wiederholbare ausführbare Logik benötigen.

Was sind Skills?

Skills sind wiederverwendbare, aufgabenspezifische Funktionspakete, die Codex bei Bedarf lädt. Sie folgen dem offenen Standard für agent skills.¹³

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-Speicherorte

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 verknüpfte 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 Speicherort 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. Schlüsselwörter verwenden: Nehmen Sie Begriffe aus der description des skills in Ihren Prompt auf, um die implizite Zuordnung zu verbessern

Produktionsbeispiel: Deploy-Skill

Ein vollständiger mehrdateiiger 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 erstklassige Bestandteile: produktbezogene Plugins werden beim Start automatisch synchronisiert, und /plugins stellt einen Browser in der TUI für Entdeckung und Verwaltung bereit.⁷⁵ v0.128.0 erweiterte Plugin-Workflows um Marketplace-Installation, Remote-Bundle-Caching, Remote-Uninstall-APIs, in Plugins gebündelte hooks, hook-Aktivierungsstatus und den Import von external-agent-Konfigurationen.⁸⁶ v0.129.0 (7. Mai 2026) ergänzt plugin workspace sharing (ein Plugin-Set ohne erneute Veröffentlichung an Teamkollegen weitergeben), share access controls (pro Empfänger aktivieren/deaktivieren, widerrufen), source filtering (einschränken, aus welchen Marketplaces ein Workspace bezieht) und marketplace operations, die direkt aus dem /plugins-Browser statt über die CLI aufgerufen werden können.⁸⁹ v0.133.0 (21. Mai 2026) macht die Plugin-Entdeckung leichter prüfbar: Listenausgaben sind Marketplace-bewusst, installierte Versionen sind sichtbar, Marketplace-Roots werden aufgeführt, und Remote-Plugin-Sammlungen können angezeigt werden, ohne raten zu müssen, aus welcher Registry ein Ergebnis stammt.⁹⁸ v0.130.0 (8. Mai 2026) macht Plugin-Paketierung transparenter und den Freigabe-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-Nebenwirkungen mehr durch ein Plugin, dem Sie nur wegen seiner Tools vertrauen.
• Plugin-Freigabemetadaten in shareContext. Wenn ein Plugin aus einem Workspace geteilt wird, legt die Share-Link-Nutzlast jetzt Linkmetadaten offen (Ersteller, Geltungsbereich, Aktualität), sodass empfangende Sitzungen die Herkunft anzeigen und entscheiden können, ob sie akzeptieren.
• Auffindbarkeitssteuerung in Freigabeeinstellungen. Freigabeeinstellungen bieten einen Auffindbarkeits-Schalter, sodass Teams Plugins für bestimmte Workspaces oder Empfängerlisten veröffentlichen können, ohne sie organisationsweit allgemein auflistbar zu machen.

Plugin-Quellen

Plugin-Entdeckung

Codex teilt dem Modell beim Sitzungsstart mit, welche Plugins aktiviert sind (v0.111.0), wodurch installierte MCPs, Apps und skills leichter gefunden werden.⁶⁵ Das Modell kann während einer Sitzung auf Basis des Aufgabenkontexts passende Plugins vorschlagen. In v0.117.0 werden produktbezogene Plugins beim Start synchronisiert, sodass der neueste 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 umfassendere Entdeckung mit Metadaten, Kategorien und Bewertungen.⁶⁹ Authentifizierungsprüfungen zur Installationszeit verifizieren, dass Plugins, die API-Schlüssel oder OAuth benötigen, vor der Installation gültige Zugangsdaten haben. Ein Uninstall endpoint 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 Plugin-Verteilung durch Drittanbieter über OpenAIs eigenen Marketplace hinaus und unterstützt GitHub-Repo-Kurzschreibweisen, HTTP(S)-Git-URLs, SSH-URLs und lokale Marketplace-Root-Verzeichnisse; verwenden Sie --ref, um eine Git-ref festzuschreiben, 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) haben einen parallelen endpoint, um Marketplaces programmatisch zu registrieren.⁸²

Sicherheitshinweis: 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 Läufen 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

Verwenden Sie in der TUI /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 zuvor separate MCP-Konfiguration, skill-Installation und app connector-Einrichtung nötig waren. Ein einzelnes Plugin kann alle drei bündeln - dadurch wird das Team-Onboarding schneller und die Konfiguration portabler.

Plan Mode & Zusammenarbeit

Plan mode lässt Codex einen Ansatz entwerfen, bevor Änderungen ausgeführt werden. Er ist standardmäßig aktiviert (seit v0.94.0).¹⁴ Siehe Entscheidungsframeworks für den Entscheidungsbaum „Plan Mode vs Direct Execution“.

Plan Mode aufrufen

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

Im plan mode: - liest Codex Dateien und analysiert die Codebasis - schlägt Codex einen Implementierungsplan vor - nimmt Codex keine Änderungen vor, bis Sie zustimmen - streamt Codex den Plan in einer eigenen TUI-Ansicht

Steer Mode

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

Es gibt zwei Methoden zum Einbringen:

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

Steer mode ist in der TUI immer aktiv. Wenn Sie lieber warten möchten, bis Codex fertig ist, bevor Sie Anweisungen geben, tippen Sie nach Abschluss des Turns einfach normal weiter - ein besonderer Modus ist nicht nötig.

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

Syntax-Highlighting (v0.105.0): Die TUI hebt jetzt fenced code blocks 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.⁶¹ Seit v0.107.0 unterstützen Echtzeit-Sprachsitzungen die Auswahl von Mikrofon- und Lautsprechergerät, sodass Sie bestimmte Audio-Ein-/Ausgabehardware auswählen können.⁶² Entfernt in v0.140.0: Die experimentellen /realtime-Sprachsteuerungen und ihre Audioabhängigkeiten wurden aus der TUI entfernt; die Sprachtranskription per Leertaste ist davon nicht betroffen.¹⁰²

Weitere Verbesserungen: - Lange Links bleiben jetzt auch dann anklickbar, wenn sie über TUI-Zeilen umbrochen werden (v0.105.0)⁶¹ - Lokale Dateilinks werden mit verbesserter Formatierung gerendert (v0.106.0)⁶⁰ - TUI-Markdown hält Weblinks über OSC 8-Metadaten anklickbar, und gedrängte Tabellen fallen auf lesbare Schlüssel/Wert-Einträge zurück, ohne Linkziele zu verlieren (v0.136.0)¹⁰⁶ - Ctrl+C-Handling für sub-agents wurde korrigiert, sodass untergeordnete Prozesse ordnungsgemäß beendet werden (v0.106.0)⁶⁰

Memory System

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

Memory Commands

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

Was Sie speichern sollten

Memories funktionieren am besten für dauerhafte Präferenzen und Projektfakten:

• Projektkonventionen: “This project uses tabs, not spaces” oder “API responses always include a meta field”
• Tool-Präferenzen: “Use pnpm instead of npm” oder “Run tests with pytest -x --tb=short“
• Architekturentscheidungen: “The auth module is in src/core/auth/, not src/middleware/“
• Workflow-Präferenzen: “Always run the linter before showing me a diff”

Memory in Pipelines

Wenn Sie codex exec ausführen, werden Memories automatisch geladen. Das bedeutet, dass CI/CD-Pipelines und Skripte vom gleichen Kontext profitieren wie interaktive Sitzungen — Sie müssen Anweisungen nicht bei jedem Aufruf wiederholen.

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

• Secret-Bereinigung: Memories werden automatisch auf Secrets geprüft, bevor sie auf die Festplatte geschrieben werden
• CWD-Bewusstsein: Memory-Dateien enthalten jetzt den Arbeitsverzeichniskontext für projektspezifischen Abruf
• Ausschluss von Developer Messages: Developer/System Messages werden aus der Phase-1-Memory-Eingabe ausgeschlossen, wodurch sich die Memory-Qualität verbessert, weil der Fokus auf Benutzerinteraktionen liegt
• Diff-basiertes Vergessen (v0.106.0): Memory nutzt jetzt Diff-basiertes Vergessen, um veraltete Fakten zu entfernen und den Memory-Speicher langfristig schlank und relevant zu halten⁶⁰
• Nutzungsbewusste Auswahl (v0.106.0): Der Memory-Abruf ist jetzt nutzungsbewusst und priorisiert häufig genutzte sowie zuletzt relevante Memories⁶⁰
• Konfigurierbare Memories (v0.107.0): Memories sind jetzt vollständig konfigurierbar. Verwenden Sie codex debug clear-memories, um alle gespeicherten Memories zurückzusetzen und mit einem sauberen Zustand zu starten — nützlich, wenn Sie zwischen unabhängigen Projekten wechseln oder der Memory-Zustand abgedriftet ist⁶²
• Phase-2-Modellupgrade (v0.121.0): Das Phase-2-Modell zur Memory-Konsolidierung ist jetzt gpt-5.4 (statt des bisherigen Standards). Die Phase-2-Pipeline läuft zwischen Sitzungen, um Phase-1-Transkripte in dauerhafte Fakten zu verdichten; der Modellwechsel verbessert die Abrufqualität bei gleichen Token-Kosten.⁸²
• TUI-Memories-Menü (v0.121.0): Eine neue In-Session-UI stellt Memory-Modus, Löschung einzelner Memories und eine Reset-Schaltfläche bereit. Der Memory-Reset bewahrt vergangene Rollouts jetzt, statt sie ungültig zu machen, sodass ein Reset die zukünftige Abruffläche bereinigt, ohne die Sitzungswiedergabe zu beschädigen.⁸²

Memory vs. AGENTS.md

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

Sitzungsverwaltung

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

Fortsetzen

Machen Sie dort weiter, 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 Command /resume innerhalb der TUI öffnet denselben interaktiven Picker mit Suche.

Fork

Verzweigen Sie eine Unterhaltung, 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 bis zum Fork-Punkt dieselbe Historie teilen. Änderungen in einem Fork wirken sich nicht auf den anderen aus. Das ist nützlich, um Ansätze zu vergleichen (z. B. “fork and try Redis instead of Memcached”) oder riskante Änderungen sicher zu erkunden.

Thread-Forking in Sub-Agents (v0.107.0): Threads können jetzt in unabhängige Sub-Agents geforkt werden, sodass eine Unterhaltung parallele Arbeitsströme starten kann, die autonom ausgeführt werden. Das erweitert das bestehende Fork-Modell — statt nur die Unterhaltung zu verzweigen, wird der geforkte Thread zu einem Sub-Agent mit eigenem Ausführungskontext.⁶² Seit v0.117.0 verwenden Sub-Agents pfadbasierte Adressen (z. B. /root/agent_a) mit strukturierter Inter-Agent-Kommunikation, wodurch Multi-Agent-Koordination expliziter und besser debuggbar wird.⁷⁵

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ändiger Historie und Diff-Vorschauen sichtbar.

Sitzungslebenszyklus

Sitzungen werden zwischen CLI und Desktop App synchronisiert — starten Sie in einer Oberfläche und fahren Sie in der anderen fort.

Nichtinteraktiver Modus (codex exec)

codex exec führt Codex nichtinteraktiv für Scripting, 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 Agent-Nachricht nach stdout. Das Design macht es mit standardmäßigen Unix-Pipelines kombinierbar.

Sitzungsarchivierung (v0.136.0)

Sitzungen können archiviert werden, damit die Resume/Fork-Liste fokussiert bleibt, ohne den Verlauf zu löschen. Archivieren Sie aus der TUI mit /archive oder aus der Shell:¹⁰⁶

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

Eine archivierte Sitzung ist vor Resume- oder Fork-Vorgängen geschützt, bis Sie die Archivierung aufheben — eine Schutzvorkehrung, damit Sie nicht versehentlich eine Sitzung fortsetzen, die Sie eigentlich außer Betrieb nehmen wollten. In derselben Version startet codex app-server --stdio den app-server im stdio-Modus für Editor-/Host-Integrationen, und /diff wird jetzt daran gehindert, vom Repository bereitgestellte Git-Helfer auszuführen (eine Korrektur für Befehlssicherheit). Unter Windows ergänzt ein Alpha-Provisionierungspfad codex sandbox setup --elevated für Administratoren.¹⁰⁶

JSON-Zeilenausgabe

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

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

Ereignistypen: thread.started, turn.started/completed/failed, item.started/completed, error

{"type":"thread.started","thread_id":"019c5c94-..."}
{"type":"turn.started"}
{"type":"item.started","item":{"id":"item_1","type":"command_execution","status":"in_progress"}}
{"type":"item.completed","item":{"id":"item_3","type":"agent_message","text":"..."}}
{"type":"turn.completed","usage":{"input_tokens":24763,"cached_input_tokens":24448,"output_tokens":122}}

Strukturierte Ausgabe

Erzwingen Sie die Antwortform 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.

Sitzungsfortsetzung und Review

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 nichtinteraktive Authentifizierung in Automatisierungsumgebungen.

codex exec-Startbanner (v0.130.0). Das codex exec-Startbanner gibt die alte Formulierung “research preview” nicht mehr aus. Wenn Ihre CI die Startausgabe ausliest, ist der Bannertext 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 von codex app-server, den viele Integratoren von Hand zusammengesetzt haben, und gibt Drittanbieter-Tools einen einzigen, stabilen Einstiegspunkt in dieselbe app-server-Laufzeit, die unter den Desktop- und IDE-Oberflächen ausgeliefert wird.⁹¹ v0.133.0 verbessert die Laufzeitform des Befehls: Er kann wie ein Vordergrundbefehl laufen, auf Bereitschaft warten, den Maschinenstatus melden und dennoch explizite Daemon-artige start- / stop-Befehle für langlebige Controller-Setups bereitstellen.⁹⁸

# 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-Verläufe auflisten müssen, ohne jeden Turn auf einmal in den Arbeitsspeicher zu laden.

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

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

Kombinieren Sie die Paginierung mit dem in v0.121.0 eingeführten ThreadStore-Interface, um langlebige Threads effizient zu durchlaufen, besonders in remote-control-Deployments, bei denen sich der Orchestrator möglicherweise auf einer anderen Maschine befindet als die Rollout-Dateien.⁸²

Live-Aktualisierung der App-Server-Konfiguration (v0.130.0+)

Live-app-server-Threads übernehmen Änderungen an config.toml jetzt ohne Neustart — bearbeiten Sie die Konfiguration, speichern Sie sie, und der laufende Thread spiegelt die neuen Werte in seinem nächsten Turn wider. Dies ist das Bugfix-Gegenstück zu codex remote-control: Ein langlebiger headless Server kann direkt neu konfiguriert werden, statt heruntergefahren zu werden.⁹¹

Codex Cloud & Hintergrundaufgaben [EXPERIMENTAL]

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

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

Funktionsweise

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

Internetzugang in Cloud

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

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

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

Setup-Skripte können weiterhin das Internet verwenden, um Abhängigkeiten zu installieren, selbst wenn 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 die Ergebnisse nach Abschluss.

Cloud-CLI

codex cloud exec --env <ENV_ID> "Fix failing tests"  # Start a cloud task
codex cloud status <TASK_ID>                          # Check task progress
codex cloud diff <TASK_ID>                            # View task diff
codex cloud list                                      # List recent tasks
codex cloud list --json                               # JSON output
codex cloud apply <TASK_ID>                           # Apply from cloud subcommand
codex apply <TASK_ID>                                 # Apply diff (top-level shortcut)

Die Codex Desktop App

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

Installation

codex app                      # Auto-downloads and installs on first run

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

Wichtige Funktionen

Appshots, Browser-Kommentare und Computer Use

Die App-Updates vom 21. Mai machen die Desktop App zu einer stärkeren Kontextoberfläche statt nur zu einem Thread-Manager. Verwenden Sie Appshots, wenn Codex den Zustand einer anderen Mac-App benötigt, bevor es handeln kann: Codex erfasst das vorderste Fenster, verfügbaren sichtbaren/nicht sichtbaren Text, den die App bereitstellt, und speichert den Anhang lokal im Sitzungsverlauf.⁹⁹

Für Web- und Frontend-Arbeit sollten Sie zuerst den In-App-Browser verwenden, wenn die Seite nicht authentifiziert ist: Er bietet Codex und Ihnen eine gemeinsame gerenderte Vorschau, unterstützt Browser-Use-Aktionen wie Klicken, Screenshots, Asset-Downloads und schreibgeschützte Inspektion JavaScript, und ermöglicht Ihnen, Seitenbereiche mit Kommentaren zu markieren, die Codex im nächsten Turn bearbeiten kann.⁹⁹ Für angemeldete Websites verwenden Sie weiterhin die Chrome-Erweiterung.

Verwenden Sie Computer Use nur, wenn eine strukturierte Integration oder Browser-Vorschau die Aufgabe nicht verifizieren kann. Es kann zugelassene Mac-Apps prüfen und bedienen, übernimmt jedoch Codex-Genehmigungen und Sandbox-Regeln für Dateibearbeitungen und Shell-Befehle. Die Nutzung im gesperrten Zustand bleibt eng begrenzt: Codex kann während aktiver vertrauenswürdiger Computer-Use-Turns nach dem Sperren des Mac vorübergehend auf zugelassene Apps zugreifen, mit Schutzmaßnahmen zum erneuten Sperren und Erkennung lokaler Eingaben.⁹⁹

Thread-Modi

Jeder Thread läuft in einem von drei Modi, die Sie beim Erstellen auswählen:

Mechanik der Worktree-Isolation:

Wenn Sie einen Worktree-Thread starten, führt die Desktop App Folgendes aus: 1. Erstellt einen neuen git worktree (git worktree add) in einem temporären Verzeichnis 2. Checkt einen frischen Branch von Ihrem aktuellen HEAD aus 3. Führt den Agent innerhalb des Worktree aus — alle Dateiänderungen sind isoliert 4. Zeigt nach Abschluss eine Diff-Prüfung an — Sie wählen aus, welche Änderungen zurückgeführt werden

Das bedeutet, dass mehrere Worktree-Threads gleichzeitig konfliktfrei im selben Repo laufen können. Jeder erhält einen eigenen Branch und ein eigenes Arbeitsverzeichnis.

Automatisierungen

Automatisierungen laufen lokal in der App, daher muss die App ausgeführt werden und das Projekt auf dem Datenträger 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 in der Seitenleiste auf den Tab Automatisierungen 3. Definieren Sie einen Trigger (Zeitplan, Webhook oder manuell) 4. Schreiben Sie den Prompt und wählen Sie den Ausführungsmodus aus (local oder worktree) 5. Legen Sie das Reasoning-Level für den Automatisierungslauf fest (App v26.312)⁷² 6. Automatisierungen laufen nach Zeitplan und stellen Ergebnisse zur Prüfung in eine Warteschlange

Beispielanwendungsfälle: - Issue-Triage: Neue Issues automatisch kategorisieren und priorisieren - CI-Überwachung: Build-Fehler beobachten und Korrekturen vorschlagen - Alarmreaktion: Auf Monitoring-Alarme mit diagnostischer Analyse reagieren - Abhängigkeitsupdates: Sicherheits-Patches prüfen und anwenden

Ergebnisse erscheinen in einer Prüfwarteschlange zur menschlichen Genehmigung.

Windows-Unterstützung

Die Codex Desktop App wurde am 4. März 2026 unter Windows veröffentlicht (App v26.304), mit nativer PowerShell-Unterstützung, nativer Windows-Sandbox und vollständiger 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 Agentenfunktionen 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 Ereignisstream für Zwischenaktualisierungen
• Python SDK auth (v0.132.0+): Anmeldung per API-Schlüssel, ChatGPT-Browser-/Device-Code-Flows, Kontoprüfung und Abmeldung sind vollwertige SDK-Pfade.⁹⁷
• Komfortfunktion für reine Text-Turns (v0.132.0+): Python-Turn-APIs akzeptieren einfache Strings und geben umfangreichere TurnResult-Metadaten mit gesammelten Elementen, Timing und Nutzung zurück.⁹⁷
• outputSchema: Erzwingt eine finale Ausgabe in JSON-Form
• Multimodale Eingabe: Übergeben Sie Text + lokale Bilder ({ type: "local_image", path: "..." })
• Bild-Workflows (v0.117.0): view_image gibt URLs zurück, generierte Bilder lassen sich erneut öffnen, und der Bildverlauf bleibt beim Fortsetzen einer Sitzung erhalten⁷⁵
• Multi-Environment-view_image (v0.130.0): Für Sitzungen, die sich über mehrere Environments erstrecken (eingeführt in v0.124.0 mit Environment- und Arbeitsverzeichnisauswahl pro Turn, verfeinert in v0.125.0 mit Sticky Environments), löst view_image Dateipfade nun über das ausgewählte Environment auf statt über das lokale Dateisystem des Orchestrators. Ein aus einem Remote-Environment angehängtes Bild wird relativ zum Arbeitsverzeichnis dieses Environments abgerufen, 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 bleiben unter ~/.codex/sessions erhalten.

Runtime: Node.js 18+.

Performance-Optimierung

Kontextverwaltung

Kontextfenster 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 (API-äquivalent in Codex). Die GPT-5.3-Codex- / GPT-5.2-Codex-Familie läuft mit 272K Eingabe + 128K Ausgabe (400K Gesamtbudget). Alle füllen sich schneller, als Sie erwarten würden — verwalten Sie sie proaktiv:

1. Verwenden Sie /compact regelmäßig: Fasst den Gesprächsverlauf zusammen, um Tokens freizugeben
2. Stellen Sie lokale Dokumentation bereit: Hochwertige AGENTS.md und lokale Dokumentation reduzieren den Explorationsaufwand (der Kontext verbraucht)
3. Verwenden Sie @, um bestimmte Dateien anzuhängen: Referenzieren Sie Dateien direkt, statt Codex zu bitten, sie zu finden
4. Halten Sie Prompts fokussiert: Eingegrenzte Prompts mit exakten Dateien verbrauchen weniger Kontext 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 geringem Reasoning
3. Parallele Tool-Ausführung: Codex führt unabhängige Lese- und Prüfvorgänge gleichzeitig aus; strukturieren Sie Prompts daher so, dass dies möglich ist
4. Ergebnisorientierte Schleifen: Bitten Sie um „implementieren, testen, beheben, stoppen, wenn grün“ statt um Schritt-für-Schritt-Anweisungen

Wie debugge 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 die Debug-Unterbefehle und TUI-Diagnosen oben.

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 melden Sie Probleme unter github.com/openai/codex/issues.¹

Codex Security [PREVIEW]

Codex Security ging am 6. März 2026 in die Research Preview und bringt kontextbewusste Anwendungssicherheitsprüfungen 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 Bedrohungsmodell zu erstellen, erkennt Schwachstellen nach realen Auswirkungen und prüft Findings in einer Sandbox-Umgebung unter Belastung, um sie zu validieren. Der Agent zeigt Findings mit höherer Sicherheit samt Fixes an und reduziert dadurch Rauschen durch unbedeutende Bugs.

Performance: Während der Research Preview scannte Codex Security 1,2 Millionen Commits und identifizierte 10.561 Schwachstellen mit hohem Schweregrad. Die Präzision verbesserte sich im Laufe der Zeit — das Rauschen wurde um 84 % gesenkt, überhöht gemeldete Schweregrade um mehr als 90 % reduziert und False-Positive-Raten halbiert. Das System hat reale Schwachstellen in OpenSSH, GnuTLS und Chromium gefunden; 14 CVEs wurden zugewiesen.⁷⁷

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

Enterprise-Bereitstellung

Admin-Steuerung (requirements.toml)

Administratoren setzen Enterprise-Richtlinien über requirements.toml durch, eine administrativ 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"

Anders als config.toml auf Benutzerebene, das Präferenzen festlegt, ist requirements.toml eine harte Einschränkungsschicht, die begrenzt, welche Werte Benutzer auswählen können; Benutzer können sie nicht überschreiben. Admin-Anforderungsregeln können nur auffordern oder verbieten (niemals stillschweigend erlauben).

macOS-MDM-Konfiguration

Verteilen Sie die Konfiguration per MDM über die Preference-Domain com.openai.codex.²¹ Codex berücksichtigt standardmäßige macOS-MDM-Payloads (Jamf Pro, Fleet, Kandji usw.). Kodieren Sie TOML als base64 ohne Zeilenumbruch:

Priorität (höchste bis niedrigste):

1. Von macOS verwaltete Einstellungen (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 aus, sodass verwaltete Schichten mit höherer Priorität immer Vorrang haben. Cloud-Anforderungen sind best effort; wenn der Abruf fehlschlägt oder ein Timeout auftritt, fährt Codex ohne die Cloud-Schicht fort.

OpenTelemetry-Integration

Codex unterstützt die Weitergabe von OpenTelemetry-Trace-Context aus 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 (Endpunkt, Dienstname, Ressourcenattribute)
• Trace-Context wird durch Codex bis zu API-Aufrufen weitergegeben und ermöglicht End-to-End-Beobachtbarkeit
• Verwenden Sie Ressourcenattribute, um Traces nach Team, Umgebung oder Projekt zu kennzeichnen
• Behalten Sie Datenschutzanforderungen im Blick, wenn Sie Prompt-/Tool-Logging aktivieren — Traces können Codeausschnitte enthalten
• Konfigurierbare OpenTelemetry-Trace-Metadaten (v0.130.0+). Über den standardmäßigen OTEL_RESOURCE_ATTRIBUTES-Rahmen hinaus stellt die codex-otel-Crate jetzt konfigurierbare Trace-Metadaten bereit, sodass Administratoren Traces mit organisationsspezifischen Dimensionen (Kostenstelle, Projekt-ID, Ticket-Referenz) kennzeichnen können, ohne OTEL_RESOURCE_ATTRIBUTES bei jedem Aufruf von Grund auf neu aufzubauen. Kombinieren Sie dies mit den in derselben Version ausgelieferten umfangreicheren Review-/Feedback-Analysen für einheitliches Debugging und Triage über CLI, app-server und remote-control sessions hinweg.⁹¹

Enterprise-Zugriff

• ChatGPT Business / Enterprise / Edu: Durch Org-Administratoren gesteuerter Zugriff, bei dem aus der Cloud abgerufene Anforderungen automatisch angewendet werden. Unterstützt SSO über SAML/OIDC über Ihren Identity Provider (Okta, Entra ID usw.)
• API: Standardmäßige API-Authentifizierung, Abrechnung sowie Org-/Projektsteuerung. OpenAI veröffentlicht SOC 2 Type II- und SOC 3-Berichte; HIPAA BAA ist für den Enterprise-Tarif verfügbar
• Codex SDK: Einbettung in interne Tools und Workflows
• Richtliniendurchsetzung im großen Maßstab: Verwenden Sie per MDM verteiltes requirements_toml_base64 oder /etc/codex/requirements.toml auf Dateisystemebene

Datenverarbeitung und Compliance: - API-Eingaben/-Ausgaben werden gemäß den Business-/Enterprise-/API-Bedingungen von OpenAI nicht für Training verwendet - Für Data Residency wird OpenAI API-Traffic standardmäßig über US-basierte Infrastruktur geleitet; bei Anforderungen an EU Data Residency wenden Sie sich an das Enterprise-Vertriebsteam von OpenAI - Sitzungsprotokolle werden lokal gespeichert; nur API-Aufrufe verlassen den Rechner - ChatGPT Enterprise unterstützt Compliance-Frameworks einschließlich SOC 2, DSGVO und CCPA

Rollout-Strategie

Empfohlener stufenweiser Rollout für Organisationen:

1. Pilotphase (Woche 1-2): Stellen Sie Codex für 3-5 Senior Engineers bereit, wobei requirements.toml den Sandbox-Modus untrusted und cached Websuche erzwingt. Sammeln Sie Feedback zu AGENTS.md-Mustern und MCP-Serveranforderungen.
2. Teamerweiterung (Woche 3-4): Rollen Sie Codex für das gesamte Team aus. Verteilen Sie das teamstandardisierte config.toml per MDM oder Repo. Aktivieren Sie die workspace-write-Sandbox für vertrauenswürdige Repositories.
3. CI-Integration (Woche 5-6): Fügen Sie codex-action zu CI/CD-Pipelines für automatisierte PR-Reviews und Testgenerierung hinzu. Verwenden Sie --ephemeral, um Kosten planbar zu halten.
4. Organisationsweit (Monat 2+): Stellen Sie Codex per MDM bereit, wobei requirements.toml genehmigte MCP-Server, Sandbox-Richtlinien und Model-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: Prüfen Sie ~/.codex/sessions/ für Compliance-Reviews (in sensiblen Kontexten mit --ephemeral deaktivieren)
• MCP-Identitätsdurchsetzung: requirements.toml protokolliert blockierte Serverversuche — prüfen Sie diese auf nicht autorisierte Tool-Nutzung
• Git-Audit-Trail: Alle Codex-Dateiänderungen laufen über Standard-git — prüfen Sie sie über Branch-Historie und PR-Diffs

Best Practices & Anti-Patterns

Prompting-Muster

1. Constraint-getriebene Prompts: Beginnen Sie mit Grenzen. “Do NOT change the API contracts. Only refactor internal implementation.”
2. Strukturierte Reproduktionsschritte: Nummerierte Schritte führen zu besseren Bugfixes als vage Beschreibungen
3. Verifizierungsanfragen: Schließen Sie mit “Run lint + the smallest relevant test suite. Report commands and results.”
4. Dateireferenzen: Verwenden Sie @filename, um bestimmte Dateien an den Kontext anzuhängen
5. Outcome-getriebene Schleifen: “Implement, run tests, fix failures, stop only when all tests pass.” Codex iteriert, bis die Aufgabe erledigt ist

Testphilosophie

Die Community einigt sich zunehmend auf testgetriebene AI-Zusammenarbeit:²²

• Definieren Sie Tests vorab als Abschlusssignale
• Lassen Sie Codex iterieren, bis die Tests bestehen (red → green → refactor)
• Übernehmen Sie Tiger Style-Programmiermuster
• Geben Sie exakten Dateitext an, wenn Sie Patches anfordern. Codex nutzt striktes Matching, kein unscharfes AST-basiertes Patching

Best Practices für Kontextmanagement

• Stellen Sie hochwertige lokale Dokumentation bereit, statt sich auf Websuche zu verlassen
• Pflegen Sie strukturiertes Markdown mit Inhaltsverzeichnissen und Fortschrittsdateien (“progressive disclosure”)
• Vereinheitlichen Sie Zeilenenden (LF vs CRLF) über getrackte Dateien hinweg, um Patchfehler zu vermeiden
• Halten Sie AGENTS.md knapp, 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
• Nutzen Sie patchbasierte Workflows (git diff / git apply) statt direkter Edits
• 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: Erkenntnisse aus Entwicklungssitzungen extrahieren - github-issue-fixer [issue-number]: Systematische Buganalyse und PR-Erstellung - github-pr-reviewer [pr-number]: Code-Review-Workflows - ui-engineer [requirements]: Frontend-Entwicklung auf Produktionsniveau

Community-Skills: - claude-skill: Aufgaben mit Berechtigungsmodi an Claude Code übergeben - autonomous-skill: Multi-Session-Aufgabenautomatisierung mit Fortschrittstracking - deep-research: Parallele Subtask-Orchestrierung - kiro-skill: Requirements → Design → Tasks → Ausführungspipeline

Anti-Patterns

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

Kosten-Anti-Patterns

Kontext-Anti-Patterns

Workflow-Anti-Patterns

Prompt-Anti-Patterns

Workflow-Rezepte

End-to-End-Muster für häufige Entwicklungsszenarien.

Rezept 1: Neues Projekt einrichten

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 das generierte AGENTS.md, bearbeiten Sie es passend zu Ihren Konventionen und führen Sie dann aus:

> Run the health endpoint test and confirm it passes

Rezept 2: Täglicher Entwicklungsflow

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.

Prüfen Sie mit /diff und committen Sie anschließend.

Rezept 3: Komplexes Refactoring mit Plan Mode

codex

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

Prüfen Sie den Plan. Genehmigen oder lenken Sie nach:

[Tab] Also add a migration script using Alembic

Nachdem Codex ausgeführt hat, verifizieren Sie:

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

Rezept 4: PR-Review mit codex exec

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

Rezept 5: Debugging mit Cloud Tasks [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."

Prüfen Sie später den Fortschritt:

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

Wenden Sie den Fix lokal an, sobald er fertig ist:

codex apply <TASK_ID>

Migrationsleitfaden

Von Claude Code

Wichtige Unterschiede, die Sie kennen sollten:

• Die Sandbox arbeitet auf Betriebssystemebene: Codex verwendet Seatbelt/Landlock, keine Container. Einschränkungen greifen auf Kernel-Ebene, unterhalb der Anwendungsschicht.
• Hooks werden ausgebaut: Codex unterstützt jetzt 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 Sitzungslebenszyklus, Prompt-Interception und Tool-Level-Automatisierung ab, auch wenn die 12+ Lebenszyklusereignisse von Claude Code weiterhin breiter sind. Für Automatisierungsmuster, die noch nicht abgedeckt sind, verwenden Sie AGENTS.md-Anweisungen oder skills.
• Sub-agents v2 (v0.117.0): Sub-agents verwenden jetzt pfadbasierte Adressen (z. B. /root/agent_a) mit strukturierter Inter-Agent-Kommunikation und Agent-Auflistung.⁷⁵ Das erweitert die bestehende Mechanik (max. 6 parallel, reduziert von 12 in v0.91.0). Multi-Agent-Rollen bleiben über die Konfiguration anpassbar (v0.104.0+).⁴⁷ v0.105.0 fügte spawn_agents_on_csv für Fanout über Zeilen hinweg mit Fortschrittsverfolgung und ETA hinzu.⁶¹ 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 über 60.000 Open-Source-Projekten. CLAUDE.md ist nur für Claude.
• Profile ersetzen manuelles Wechseln: Statt Flags pro Ausführung zu ändern, definieren Sie Profile in config.toml.

Von GitHub Copilot

Was Sie gewinnen: - Sandbox-Ausführung auf Betriebssystemebene (Seatbelt/Landlock — Kernel-erzwungen statt containerbasiert) - Delegation von cloud tasks mit codex apply - Konfigurationsprofile für Workflow-Wechsel - Desktop-App mit worktree-Isolation

Von Cursor

Kurzreferenzkarte

╔═══════════════════════════════════════════════════════════════╗
║                    CODEX CLI QUICK REFERENCE                  ║
╠═══════════════════════════════════════════════════════════════╣
║                                                               ║
║  LAUNCH                                                       ║
║  codex                      Interactive TUI                   ║
║  codex "prompt"             TUI with initial prompt           ║
║  codex exec "prompt"        Non-interactive mode              ║
║  codex app                  Desktop app                       ║
║  codex resume               Resume previous session           ║
║  codex fork                 Fork a session                    ║
║                                                               ║
║  FLAGS                                                        ║
║  -m, --model <model>        Select model                      ║
║  -p, --profile <name>       Load config profile               ║
║  -s, --sandbox <mode>       Sandbox mode                      ║
║  -C, --cd <dir>             Working directory                 ║
║  -i, --image <file>         Attach image(s)                   ║
║  -c, --config <key=value>   Override config                   ║
║  --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

Quellen

Hinweis zu OpenAI-Blog-URLs: Die Referenzen ¹⁶, ²⁵–³⁰, ³³, ⁶⁴, ⁶⁶, ⁶⁷, ⁷⁶ und ⁷⁷ verlinken auf openai.com/index/-Blogbeiträge, die wegen Cloudflare-Bot-Schutz bei automatisiertem Zugriff HTTP 403 zurückgeben. Diese URLs sind gültig, wenn Sie über einen normalen Webbrowser darauf zugreifen.