Codex CLI: Die maßgebliche technische Referenz

Kurz gesagt: Codex ist ein Coding-Agent für mehrere Oberflächen: Er liest Ihre Codebasis, führt Befehle in einer Sandbox auf Betriebssystemebene aus, patcht Dateien und delegiert Aufgaben an die Cloud. Beherrschen Sie fünf Systeme – config.toml, das Sandbox-/Freigabemodell, AGENTS.md, MCP und Skills – wird Codex zum Kraftmultiplikator. GPT-5.6 Sol ist die empfohlene Standardeinstellung (die Einstellung „Power“, mittlerer Reasoning-Aufwand); GPT-5.5, das Flaggschiff der vorherigen Generation, bietet 400K Kontext in Codex und 1M im API.⁸³¹¹⁷ Neu hier? Wechseln Sie direkt zu Installation und Schnellstart. Sie verfolgen Releases? Die neueste stabile Version ist v0.147.0 (7. August 2026) – die aktuelle Versionsübersicht finden Sie unter Release-Highlights, alle Updates im Changelog.[^^200]

Codex arbeitet als Coding-Agent für mehrere Oberflächen, nicht als Chatbot, der Code schreibt. Der 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. Er läuft lokal, denkt aber global; je nach Arbeitsweise unterstützt dieselbe Intelligenz fünf unterschiedliche Oberflächen, einschließlich der neuen Chrome-Erweiterung, mit der Codex in Ihrem Browser ausgeführt wird, ohne ihn zu übernehmen.⁹⁰

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

1. Konfigurationssystem: Steuert das Verhalten über config.toml
2. Sandbox- und Freigabemodell: Legt fest, was Codex tun darf
3. AGENTS.md: Definiert Betriebsvereinbarungen auf Projektebene
4. MCP-Protokoll: Erweitert Funktionen auf externe Dienste
5. Skills-System: Bündelt wiederverwendbares Fachwissen

Ich habe Codex monatelang zusammen mit Claude Code in Produktionscodebasen, 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, reale Konfigurationsbeispiele und die Sonderfälle, über die selbst erfahrene Benutzer stolpern.

Wichtigste Erkenntnisse

• Fünf Oberflächen, ein Gehirn: CLI, Desktop-App, IDE-Erweiterung, Cloud-Aufgaben und die neue Chrome-Erweiterung nutzen alle dieselbe GPT-5.x-Codex-Intelligenz. Wählen Sie daher die Oberfläche, die zu Ihrem Workflow passt.⁹⁰
• Sandboxing auf Betriebssystemebene: Codex setzt Dateisystem- und Netzwerkeinschränkungen auf Kernel-Ebene durch (Seatbelt unter macOS, Landlock + seccomp unter Linux), nicht innerhalb von Containern.
• AGENTS.md ist toolübergreifend: Ihre Projektanweisungen funktionieren in Codex, Cursor, Copilot, Amp, Jules, Gemini CLI, Windsurf, Cline, Aider, Zed und mehr als 60.000 Open-Source-Projekten. Einmal schreiben, überall verwenden.
• Profile reduzieren den Kontextwechselaufwand: Definieren Sie benannte Konfigurationsvoreinstellungen (fast, careful, auto) und wechseln Sie mit --profile zwischen ihnen.
• Kontextmanagement ist wichtig: Die GPT-5.6-Familie (Sol, Terra, Luna) nutzt ein Kontextfenster von 272K; GPT-5.5, das Flaggschiff der vorherigen Generation, bietet 400K in Codex und 1M im API. Verwenden Sie /compact, fokussierte Prompts und @file-Referenzen, um Tokenbudgets vorausschauend zu verwalten.⁸³¹¹²

So verwenden Sie diesen Leitfaden

Dies ist eine Referenz mit mehr als 3.300 Zeilen — beginnen Sie dort, wo Ihr Erfahrungsstand liegt:

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

Release-Highlights: Was sich kürzlich geändert hat

Die versionsweise Darstellung für Leser, die den Release-Zyklus von Codex verfolgen. Neu hier? Überspringen Sie diesen Abschnitt und kehren Sie nach dem Schnellstart zurück – nichts darin ist erforderlich, um produktiv zu werden.

GPT-5.6 Sol ist die empfohlene Standardeinstellung in Codex — die Standardoption „Power“ mit mittlerem Reasoning, die in Richtung Smarter oder Faster angepasst werden kann; GPT-5.5 (23. April 2026: 400K Kontext in Codex, 1M im API, $5/$30 pro MTok, 82,7 % Terminal-Bench 2.0 SOTA) ist das Flaggschiff der vorherigen Generation.⁸³¹¹⁷ Seit CLI v0.147.0 (stabil, 7. August 2026) wurde codex exec --full-auto entfernt (seit v0.128 veraltet) — Skripte, die es weiterhin übergeben, erzeugen nun einen Fehler; ersetzen Sie es durch --sandbox workspace-write zusammen mit einem Freigabe-Flag oder Profil. v0.147.0 enthält außerdem --approve-for-me (Freigabeaufforderungen werden durch einen automatischen Review-Durchlauf beurteilt), portable Agent Plugins mit Suche in lokalen, persönlichen, Workspace- und Remote-Katalogen, das Opt-in-MCP-Protokoll vom 2026-07-28 (paginierte Erkennung, mehrstufige Anfragen, nicht blockierender Serverstart) sowie Unterhaltungsabschnitte zum Organisieren langer Transkripte.¹¹⁶ v0.146.0 (stabil, 29. Juli) sorgte dafür, dass konfigurierte Proxys alle Transportebenen abdecken, fügte Agent-Plugins-Manifeste sowie die Marktplätze Amazon Bedrock und Claude Code hinzu, führte Sitzungsbenennung mit Thread-Anheftung ein und ergänzte vom Executor bereitgestellte Skills; v0.146.1 (5. Aug.) härtete die Standardwerte der automatischen Prüfung für cyberfähige Modelle.¹¹⁴¹¹⁵ Seit CLI v0.145.0 (stabil, 21. Juli 2026) migriert /import sowohl aus Cursor als auch aus Claude Code — Einstellungen, MCP-Server, Plugins, Sitzungen, Befehle und projektspezifische Erinnerungen — Voice kehrt als Streaming-Realtime-V3-Unterhaltungen mit Audioeingaben und Audio-Tool-Ausgaben in gängigen lokalen Formaten zurück, das Opt-in-Multi-Agent-v2-Erlebnis ist stabilisiert mit konfigurierbaren Sub-Agent-Modellen, Reasoning-Stufen und Parallelität, ein experimenteller paginierten Threadverlauf ermöglicht effizientes Fortsetzen, Suchen, persistierte Namen, Sub-Agent-Unterstützung und Erinnerungen, der experimentelle Amazon-Bedrock-Login bietet Unterstützung für benutzerdefinierte Endpunkte und Authentifizierung (GPT-5.6 Sol als Standard-Bedrock-Modell), und gebündelte GPT-5.4-Modellauswahlen werden auf die Varianten GPT-5.6 Terra und Luna migriert; v0.144.6 (18. Juli) korrigierte die Kontextfenster von GPT-5.6 Sol/Terra/Luna auf 272.000 Token.¹¹¹¹¹² Seit CLI v0.140.0 (stabil, 15. Juni 2026) zeigt /usage die tägliche/wöchentliche/kumulative Tokenaktivität des Kontos, Sitzungen können über codex delete / /delete dauerhaft gelöscht werden (mit Bestätigungsschutz), /import migriert selektiv Einrichtung, Projektkonfiguration und aktuelle Chats aus Claude Code, die Eingabe von @ öffnet standardmäßig ein einheitliches Erwähnungsmenü für Dateien, Plugins und Skills, und verwaltete Amazon-Bedrock-API-Key-Authentifizierung wird zusammen mit verschlüsseltem lokalem Speicher für CLI- und MCP-OAuth-Anmeldedaten ausgeliefert; die experimentellen /realtime-Sprachsteuerungen wurden aus der TUI entfernt (Voice kehrte später in v0.145.0 als Streaming Realtime V3 zurück).¹⁰²¹¹² Seit CLI v0.139.0 (stabil, 9. Juni 2026) kann der Code-Modus 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-Marktplatz stellt Quellen in codex plugin marketplace list --json mit schnellerer Auflistung zwischengespeicherter Kataloge bereit.¹²² v0.138.0 (8. Juni) fügte /app hinzu, um eine CLI-Sitzung unter macOS und Windows an die Desktop-App zu übergeben, machte lokale Bildpfade für das Modell zugänglich, gestaltete die Auswahl des Reasoning-Aufwands flexibler und gab der Plugin-Automatisierung strukturierte JSON-Ausgaben; außerdem begann diese Version mit der Verschlüsselung von Parent-zu-Sub-Agent-Aufgabentext in Multi-Agent v2, sodass Delegierungsanweisungen nicht mehr als Klartext in lokalen Sitzungsprotokollen erscheinen (siehe Multi-Agent).¹²³¹⁰⁸ v0.137.0 (4. Juni) lieferte Multi-Agent v2 aus (Runtime pro Thread beibehalten, sauberere Follow-up- und Metadaten-Standardwerte, hide_spawn_agent_metadata standardmäßig true), F13–F24-TUI-Tastenkürzel und eine Skills-Erweiterung v1 mit Katalogauflösung pro Turn.¹²⁴ Seit CLI v0.135.0 (28. Mai 2026) meldet codex doctor umfassendere Umgebungs-, Git-, Terminal-, App-Server- und Thread-Inventare; /status zeigt Remote-Verbindungsdetails und die Serverversion, wenn die TUI über eine Remote-Verbindung verbunden ist; der Vim-Modus erhielt Textobjekt-Bearbeitung, verbessertes Verhalten bei Wort-/Zeilenenden und eine konfigurierbare Turn-Unterbrechung; /permissions versteht nun benannte Berechtigungsprofile und zeigt benutzerdefinierte an; paketierte Codex-Builds erkennen und verwenden den gebündelten gepatchten zsh-Helfer in unterstützten macOS-Umgebungen; und das Python SDK bietet benutzerfreundliche Sandbox-Voreinstellungen für Thread- und Turn-APIs.¹²⁶ v0.134.0 (26. Mai 2026) führte die Suche im lokalen Unterhaltungsverlauf mit Groß-/Kleinschreibungs-unabhängigen Inhaltsübereinstimmungen und Ergebnisvorschauen ein, machte --profile zum primären Profilauswähler in CLI, TUI-Berechtigungs- und Sandbox-Flows (Legacy-Profilkonfigurationen werden mit Migrationshinweisen abgelehnt), verbesserte die MCP-Einrichtung durch Umgebungszielsteuerung pro Server und OAuth-Optionen für streambare HTTP-Server, machte Connector-Tool-Schemas zuverlässiger durch Beibehaltung lokaler $ref/$defs und Komprimierung übergroßer Schemas, erlaubte schreibgeschützten MCP-Tools die gleichzeitige Ausführung, wenn sie readOnlyHint angeben, und ergänzte umfangreicheren Erweiterungs- und Hook-Kontext einschließlich Unterhaltungsverlauf für Erweiterungstools.¹⁰¹ v0.133.0 (21. Mai 2026) aktivierte Ziele standardmäßig mit dediziertem Speicher und Fortschrittsverfolgung; codex remote-control erhielt Bereitschafts-/Statusanzeigen im Vordergrund sowie Start/Stopp im Daemon-Stil; Berechtigungsprofile erhielten Listen-APIs, Vererbung, verwaltete requirements.toml, Laufzeitaktualisierung und eine stärkere Windows-Sandbox-Integration; die Plugin-Erkennung zeigt installierte Versionen, Marktplatzwurzeln und Remote-Sammlungen; und Erweiterungen können Sub-Agent-Start/Stopp, Tool-Ausführung, Turn-Metadaten sowie asynchrone Freigabe-/Turn-Verarbeitung beobachten. Das Codex-App-Update vom 21. Mai ergänzte Appshots für vorderste Mac-Fenster, Goal-Modus-GA in App/IDE/CLI, Verbesserungen bei In-App-Browser-Anmerkungen und optional gesperrtes Computer Use für berechtigte Mac-Benutzer.⁹⁹¹⁰⁰ v0.132.0 (20. Mai 2026) fügte Python SDK-First-Class-Authentifizierung, einfachere reine Text-Turn-APIs, umfangreichere TurnResult, codex exec resume --output-schema, einen schnelleren TUI-Start, auth-gestützte Remote-Executor-Registrierung und die Beibehaltung der Bildtreue in App-Server-Turns hinzu. Verwenden Sie explizite Sandbox-/Freigabe-Flags oder Berechtigungsprofile — das Legacy---full-auto wurde mit v0.147.0 entfernt; js_repl bleibt entfernt.^{86878991969798116}

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 erstklassige verwaltete Oberfläche, die Plugin-Erkennung besser prüfbar und remote-control lässt sich leichter als Vordergrund- oder daemonisierter App-Server-Befehl ausführen. Codex Cloud und Code-Modus bleiben experimentell oder in Entwicklung, während das zentrale CLI, Sandboxing, AGENTS.md, config.toml, Skills, hooks, Multi-Agent-Tools, Plugins, Browser, Computer Use und Appshots je nach Plattform und Plan stabile oder dokumentierte benutzerorientierte Oberflächen sind. v0.132.0 vervollständigt die Python SDK-Authentifizierung und strukturierte Automatisierung zum Fortsetzen; v0.131.0 fügte codex doctor, die einheitliche @-Erwähnungssuche, Marktplatz-CLI-Befehle, versionsbewusstes Plugin-Sharing, daemonverwaltetes remote-control mit Laufzeit-Aktivierung/-Deaktivierung, registrierungsgestützte Umgebungen und zusätzliche Windows-Sandbox-Härtung hinzu.⁹⁶⁹⁷⁹⁸ Das Legacy---full-auto wurde in v0.147.0 entfernt (seit v0.128 veraltet), und js_repl bleibt entfernt.^8687116

Wie Codex funktioniert: Das mentale Modell

Bevor Sie sich mit den Funktionen befassen, sollten Sie verstehen, wie die Architektur von Codex alles prägt, was Sie damit tun. Das System arbeitet über fünf Oberflächen hinweg, die von einer gemeinsamen Intelligenzebene getragen werden:

┌─────────────────────────────────────────────────────────┐
│                    CODEX SURFACES                       │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐   │
│  │   CLI    │  │ Desktop  │  │   IDE    │  │ Cloud  │   │
│  │ Terminal │  │   App    │  │Extension │  │  Tasks │   │
│  └──────────┘  └──────────┘  └──────────┘  └────────┘   │
│  Local exec     Multi-task    Editor-native  Async      │
│  + scripting    + worktrees   + inline edits detached   │
│  ┌──────────┐                                           │
│  │  Chrome  │  Signed-in browser workflows              │
│  │Extension │  (launched May 2026)                      │
│  └──────────┘                                           │
├─────────────────────────────────────────────────────────┤
│  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         │
└─────────────────────────────────────────────────────────┘

Kernebene: Die GPT-5.x-Modellfamilie bildet die Grundlage für alles. Stand August 2026 ist gpt-5.6-sol der empfohlene Standard — die Einstellung „Power“ mit mittlerem Reasoning — ergänzt durch Terra (für den Alltag) und Luna (schnell, kostengünstig); gpt-5.5 ist das Flaggschiff der vorherigen Generation (400K Kontext in Codex, 1M im API), und gpt-5.4 wird am 31. August 2026 aus Codex entfernt.⁸³¹¹⁷ Es liest Dateien, schreibt Patches, führt Shell-Befehle aus und analysiert Ihre Codebasis. Wenn sich der Kontext füllt, komprimiert Codex die Unterhaltung, um Platz freizugeben. Diese Ebene verbraucht Tokens.

Sicherheitsebene: Jeder Befehl, den Codex ausführt, durchläuft eine Sandbox auf Betriebssystemebene. Unter macOS erzwingt Apples Seatbelt-Framework Einschränkungen auf Kernelebene. Unter Linux filtern Landlock + seccomp den Zugriff auf Dateisystem und Systemaufrufe. Die Sandbox arbeitet auf Kernelebene, nicht innerhalb von Containern. Die approval_policy entscheidet anschließend, wann eine menschliche Bestätigung erforderlich ist.

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

Oberflächenebene: CLI für Terminal-Power-User und Automatisierung. Die Desktop-App für mehrsträngiges Projektmanagement. Die IDE-Erweiterung für Edit-Compile-Test-Schleifen. Cloud für asynchrone Aufgaben, die unabhängig ausgeführt werden.

Die zentrale 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 Repository-Operationen, die IDE-Erweiterung für enge Coding-Schleifen, die Desktop-App für Planung und Koordination sowie Chrome für Browser-Workflows mit Anmeldung.

Inhaltsverzeichnis

1. Wie installiere ich Codex?
2. Schnellstart: Ihre erste Sitzung
3. Zentrale Interaktionsoberflächen
4. Detaillierter Einblick in das Konfigurationssystem
5. Welches Modell sollte ich wählen?
6. Was kostet Codex?
7. Entscheidungsrahmen
8. Wie funktionieren das Sandbox- und Approval-System?
9. Wie funktioniert AGENTS.md?
10. Hooks
11. Was ist MCP (Model Context Protocol)?
12. Code Mode
13. JavaScript REPL-Laufzeit
14. Was sind Skills?
15. Plugins
16. Plan Mode & Collaboration
17. Speichersystem
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. Leistungsoptimierung
25. Wie debugge ich Probleme? – einschließlich codex doctor
26. Unternehmensbereitstellung
27. Best Practices & Anti-Patterns
28. Workflow-Rezepte
29. Migrationsleitfaden
30. Schnellreferenzkarte
31. Änderungsprotokoll
32. Referenzen

Wie installiere ich Codex?

Paketmanager

# npm (recommended)
npm install -g @openai/codex

# Homebrew (macOS)
brew install --cask codex

# winget (Windows)
winget install OpenAI.Codex

# Upgrade to latest
npm install -g @openai/codex@latest

Wie aktualisiere, downgrade oder deinstalliere ich die Codex CLI?

Seit v0.128.0 bietet Codex einen Selbstaktualisierungsbefehl; alles andere läuft über den Paketmanager, mit dem es installiert wurde.⁸⁶ Seit v0.146.0 werden Release-Artefakte, Kanalmetadaten und Installer-Aliasse über die von OpenAI gehostete Release-Infrastruktur bereitgestellt, wobei GitHub als Fallback dient.¹¹⁴ Wenn Ihre Netzwerk-Allowlist GitHub für Codex-Installationen und -Updates erlaubt, fügen Sie auch den OpenAI-Release-Host hinzu — durch den Fallback verschlechtert sich ein nicht passender Allowlist-Eintrag unauffällig, statt mit einem deutlichen Fehler abzubrechen.

# Check what you are running
codex --version                          # -> codex-cli 0.147.0
npm view @openai/codex version           # Latest published version

# Update
codex update                             # Built-in self-update (v0.128.0+)
npm install -g @openai/codex@latest      # Or update via npm
brew upgrade --cask codex                # Or via Homebrew

# Pin or downgrade to an exact version
npm install -g @openai/codex@0.144.6

# Uninstall
npm uninstall -g @openai/codex
brew uninstall --cask codex
winget uninstall OpenAI.Codex

Das Anheften einer Version ist der richtige Schritt, wenn ein Release bei Ihnen Probleme verursacht. Codex folgt einer schnelllebigen stabilen Linie, daher ist die Installation einer exakten Version der schnellste Rollback — melden Sie das Problem, heften Sie die Version an und machen Sie weiter. Prüfen Sie mit codex --version, ob der Rollback tatsächlich erfolgt ist, da eine zweite, von PATH überdeckte Installation weiterhin unbemerkt die alte Binärdatei bereitstellen kann (codex doctor kennzeichnet genau dies unter Environment).

Das Deinstallieren des Pakets entfernt Ihren Status nicht. Authentifizierung, Konfiguration und Sitzungsverlauf liegen in ~/.codex/. Lassen Sie den Ordner bestehen, um Logins und Verlauf bei einer Neuinstallation beizubehalten; löschen Sie ihn nur, wenn Sie wirklich ganz von vorn beginnen möchten — rm -rf ~/.codex entfernt außerdem config.toml, auth.json und jede gespeicherte Sitzung.

Direktinstallationsskript (v0.106.0+)

Für macOS und Linux ist ein einzeiliges Installationsskript als GitHub-Release-Artefakt verfügbar:⁶⁰

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

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

Binärdownloads

Für Umgebungen ohne npm oder Homebrew laden Sie plattformspezifische Binärdateien 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 von experimentell hochgestuft). WSL wird ebenfalls unterstützt²

Authentifizierung

codex login                  # Interactive OAuth (recommended)
codex login --device-auth    # OAuth device code flow (headless)
codex login --with-api-key   # API key from stdin
codex login status           # Check auth state (exit 0 = logged in)
codex logout                 # Clear stored credentials

Zwei Authentifizierungswege:

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

Expertentipp: Die Anmeldedatenspeicherung lässt sich über cli_auth_credentials_store in config.toml konfigurieren. Optionen: file (Standard), keyring (OS-Schlüsselbund) oder auto (Schlüsselbund, falls verfügbar; ansonsten Datei).

Amazon-Bedrock-Login (v0.145.0, experimentell): Teams, deren Modellzugriff über Amazon Bedrock erfolgt, erhalten einen experimentellen Login-Pfad mit Unterstützung für benutzerdefinierte Endpunkte und Authentifizierung, zusätzlich zur bestehenden verwalteten API-Key-Authentifizierung (v0.140.0+) und der AWS-Anmeldeinformationskette (siehe Custom Model Providers). GPT-5.6 Sol ist das standardmäßige Bedrock-Modell.¹¹²

Shell-Vervollständigungen

# Generate completions for your shell
codex completion bash > /etc/bash_completion.d/codex
codex completion zsh > ~/.zsh/completions/_codex
codex completion fish > ~/.config/fish/completions/codex.fish

Installation überprüfen

codex --version
# codex-cli 0.147.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 navigieren:

cd ~/my-project                  # Any git repo works

3. Codex starten:

codex

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

4. Eine Frage stellen:

> What does this project do? Summarize the architecture.

Codex liest wichtige Dateien und erklärt die Codebasis. Eine solche Frage nimmt keine Änderungen vor — Codex bearbeitet Dateien nur, wenn Sie um eine Änderung bitten, und Sandbox sowie Genehmigungsrichtlinie bestimmen, wann Codex zuvor nachfragen muss.

5. Eine Änderung vornehmen:

> Add input validation to the login endpoint

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

6. Einen Slash-Befehl verwenden:

> /plan Refactor the database layer to use connection pooling

Codex erstellt einen Plan, ohne ihn auszuführen. Prüfen Sie den Plan und bestätigen Sie ihn anschließend, um die Ausführung zu beginnen.

7. Ihre Arbeit prüfen:

> /diff

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

Wie geht es weiter: - 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 fünf unterschiedliche Oberflächen, die auf derselben Intelligenz basieren. Jede Oberfläche ist für ein anderes Arbeitsmuster optimiert.

1. Interaktive CLI (Terminal UI)

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

Die Terminal UI ist eine Vollbildanwendung mit:

• Composer: Geben Sie Prompts ein, hängen Sie Dateien mit @ an und führen Sie Shell-Befehle mit dem Präfix ! aus.
• Ausgabebereich: Gestreamte Modellantworten, Tool-Aufrufe und Befehlsausgaben
• Statusleiste: Modell, Tokennutzung, Git-Branch, Sandbox-Modus

Wichtige TUI-Tastenkürzel:

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

Slash-Befehle in der TUI:

Neugestaltung der Workflow-Auswahl (v0.129.0): Resume und Fork sind jetzt über eine neu gestaltete Auswahl leichter erreichbar, und ein neuer Raw-Scrollback-Modus ermöglicht es Ihnen, durch das nicht gerenderte Transkript zu scrollen, wenn Sie Befehle oder Modellausgaben wortgetreu kopieren müssen. Das ist nützlich, wenn Sie eine lange Debugging-Sitzung triagieren oder Ausgaben an ein anderes Tool weiterleiten.⁸⁹

Einheitliches @-Erwähnungsmenü (v0.140.0): Wenn Sie im Composer @ eingeben, öffnet sich nun standardmäßig ein einzelnes Erwähnungsmenü für Dateien, Plugins und skills und ersetzt damit den reinen Dateianhangsablauf — ein Tastendruck genügt, um auf jede Projektressource zu verweisen.¹⁰²

2. Codex Desktop App (macOS + Windows)

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

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

• Multitasking: Mehrere parallele Agents gleichzeitig in unterschiedlichen Projekten ausführen
• Git-worktree-Isolierung: Jeder Thread arbeitet an einer isolierten Kopie Ihres Repos.
• Inline-Diff-Review: Änderungen stagen, zurücksetzen und committen, ohne die App zu verlassen
• Integriertes Terminal: Terminal pro Thread zum Ausführen von Befehlen
• Unterhaltungen forken: Unterhaltungen verzweigen, um Alternativen zu erkunden
• Schwebende Pop-out-Fenster: Unterhaltungen in portable Fenster auslagern
• Automatisierungen: Wiederkehrende Aufgaben planen (Issue-Triage, CI-Überwachung, Alarmreaktion)
• Appshots: Das vorderste Mac-App-Fenster mit einem Screenshot und verfügbarem Text an einen Thread anhängen
• Browser-Kommentare in der App: Lokale oder öffentliche Seiten in der Vorschau anzeigen, Kommentare zu Elementen oder Bereichen hinterlassen und Codex präzises visuelles Feedback bearbeiten lassen
• Computer Use: Codex darf zugelassene Mac-Apps für abgegrenzte GUI-Arbeit bedienen; gesperrte Nutzung ist für berechtigte Remote-Mac-Computer-Use-Turns optional aktivierbar

ChatGPT Voice, unterstützt von GPT-Live (Desktop 26.715, 23. Juli 2026): Die Desktop-App kann nun per Sprache gesteuert werden — besprechen Sie Arbeit und koordinieren Sie Aufgaben in Chat, Work und Codex, ohne zu tippen. Wenn Sie auf macOS Screen context aktivieren, wird ein Appshot Ihres vordersten Fensters mit der Unterhaltung geteilt, sodass Sie nach dem fragen können, was Sie gerade sehen, anstatt es zu beschreiben. Verfügbar für Plus, Pro, Business, Edu und Enterprise in der Desktop-App sowie über Remote auf iOS. Dies ist Voice für die Desktop-Oberfläche; die eigene Leertasten-Sprachtranskription von CLI ist eine separate, experimentelle Funktion.¹¹³

Wann Sie die App oder CLI verwenden sollten: Nutzen Sie die Desktop-App, wenn Sie mehrere Arbeitsströme koordinieren oder visuelle Diff-Reviews benötigen. Verwenden Sie CLI, wenn Sie terminalbasierte Kombinierbarkeit, Skripting oder CI/CD-Integration wünschen.

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

Die Codex IDE extension integriert sich direkt in Ihren Editor:

• Standardmäßig Agent-Modus: Liest Dateien, nimmt Änderungen vor und führt Befehle aus
• Inline-Bearbeitungen: Kontextbezogene Vorschläge in Ihren aktiven Dateien
• Gemeinsame Sitzungen: Sitzungen werden zwischen CLI und der IDE extension synchronisiert.
• Gleiche Authentifizierung: Melden Sie sich mit einem ChatGPT-Konto oder API key an.

Installieren Sie die Erweiterung über den VS Code Marketplace oder die Extension Stores von Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Cloud tasks werden asynchron in von OpenAI verwalteten Umgebungen ausgeführt:

• Auslösen und vergessen: Aufgaben in die Warteschlange stellen, die unabhängig von Ihrem lokalen Rechner ausgeführt werden
• Parallele Ausführung: Mehrere Cloud tasks gleichzeitig ausführen
• PR-Erstellung: Codex erstellt Pull Requests aus abgeschlossener Arbeit
• Lokale Übernahme: Cloud-Ergebnisse mit codex apply <TASK_ID> in Ihr lokales Repo übernehmen

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

Cloud tasks sind auch über chatgpt.com/codex verfügbar.⁴

5. Codex für Chrome [NEW]

Codex ist als Browser-Erweiterung für Chrome verfügbar und ergänzt als fünfte Oberfläche CLI, die Desktop-App, die IDE extension und die Cloud. Die Erweiterung ist dafür ausgelegt, Ihr normales Browsing zu begleiten, statt es zu übernehmen: Codex arbeitet parallel im Hintergrund über Tabs hinweg, und Sie behalten die Kontrolle darüber, welche Websites es berührt.⁹⁰

• Parallele Tab-Ausführung: Codex arbeitet gleichzeitig über mehrere Tabs hinweg, ohne den Vordergrund-Tab zu sperren.
• Kontrolle pro Website: Sie setzen Websites auf eine Allowlist, mit denen Codex interagieren darf; standardmäßig besteht kein Zugriff.
• Browser als Werkbank: Die Erweiterung eignet sich besonders für App- und Website-Arbeit, bei der die Seite die Quelle der Wahrheit ist — Admin-Konsolen, interne Dashboards, Content-Management-UIs, Ticketsysteme — und nicht als Ersatz für CLI bei lokalen Repos.
• Dasselbe Gehirn: Codex für Chrome nutzt dieselbe GPT-5.x-Codex-Intelligenz wie die anderen Oberflächen. Daher übernehmen eine AGENTS.md- oder skills-Konfiguration, die in CLI funktioniert, dieselben Konventionen auch für browsergesteuerte Arbeit.

Installieren Sie die Erweiterung über die Dokumentation zur Codex Chrome extension.[^^167]

Detaillierter Einblick in das Konfigurationssystem

Codex verwendet TOML für die Konfiguration. Die Prioritätshierarchie zu verstehen, ist entscheidend, da sie festlegt, welche Einstellungen bei Konflikten Vorrang haben.

Priorität (von hoch nach niedrig)

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

requirements.toml fungiert als Richtlinienbeschränkungsebene, die einschränkt, welche Werte Benutzer nach dem normalen Zusammenführen der Konfiguration auswählen können. Siehe Unternehmensbereitstellung.

Speicherorte der Konfigurationsdateien

Expertentipp: Die Umgebungsvariable CODEX_HOME überschreibt das Standardverzeichnis ~/.codex. Das ist für CI/CD oder Setups mit mehreren Konten nützlich.

Desktop-Projekte mit mehreren Ordnern (26.715, 23. Juli 2026): Ein lokales Projekt in der ChatGPT-Desktop-App kann nun mehrere zusammengehörige Ordner umfassen, von denen einer als primärer Ordner festgelegt wird (Projektmenü → Projekt bearbeiten). Die automatische Suche nach config.toml erfolgt ausschließlich im primären Ordner; sekundäre Ordner bleiben für Dateisuche, Lesen und Bearbeiten verfügbar, tragen jedoch keine Konfiguration bei. Eine .codex/config.toml in einem sekundären Ordner ist eine Datei, die Codex lesen kann, jedoch keine Konfiguration, die es lädt. Dies betrifft den Projektumfang der Desktop-App und ist keine Änderung an den oben genannten Prioritätsregeln — CLI löst die Projektkonfiguration weiterhin auf, indem es vom aktuellen Arbeitsverzeichnis aus aufwärts sucht.¹¹³

Vollständige Konfigurationsreferenz

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.6-sol"                  # Recommended default (the "Power" setting)
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_context_window = 272000           # Token count available to active model (override)
model_auto_compact_token_limit = 200000 # Threshold triggering automatic history compaction
model_reasoning_effort = "medium"       # minimal|low|medium|high|xhigh (model-dependent)
model_reasoning_summary = "auto"        # auto|concise|detailed|none
model_verbosity = "medium"              # low|medium|high
personality = "pragmatic"               # none|friendly|pragmatic
review_model = "gpt-5.5"               # Optional model for /review command
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 Konfigurationsvorgaben für unterschiedliche Arbeitsmodi:

# Define profiles in ~/.codex/config.toml

[profiles.fast]
model = "gpt-5.6-luna"
model_reasoning_effort = "low"
approval_policy = "on-request"
sandbox_mode = "workspace-write"
personality = "pragmatic"

[profiles.careful]
model = "gpt-5.5"
model_reasoning_effort = "xhigh"
approval_policy = "untrusted"
sandbox_mode = "read-only"

[profiles.auto]
model = "gpt-5.6-sol"
model_reasoning_effort = "medium"
approval_policy = "never"
sandbox_mode = "workspace-write"

Aktivieren Sie ein Profil:

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

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

Benutzerdefinierte Modellanbieter

Stellen Sie eine Verbindung zu Azure, AWS Bedrock, lokalen Modellen oder Proxy-Diensten her:

[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: Die Wire-API chat/completions (wire_api = "chat") wurde für von OpenAI gehostete Modelle eingestellt; OpenAI kündigte die Entfernung für Februar 2026 an.³⁴ Lokale Anbieter (Ollama, LM Studio) akzeptieren dieses Format möglicherweise weiterhin. Verwenden Sie für OpenAI-Endpunkte stattdessen wire_api = "responses".

Verwenden Sie lokale Modelle mit dem Flag --oss:

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

Oder legen Sie dies in der Konfiguration fest:

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

Inline-Konfigurationsüberschreibungen

Überschreiben Sie jeden Konfigurationswert über die Befehlszeile:

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

Welches Modell sollte ich wählen?

Verfügbare Modelle (August 2026)

GPT-5.5 (23. April 2026) war bei der Einführung OpenAIs empfohlene Wahl für die meisten Codex-Aufgaben: komplexes Coding, Computernutzung, Wissensarbeit und Research-Workflows. Verfügbar in Codex CLI / Web / Desktop ab 23. April für ChatGPT Plus / Pro / Business / Enterprise / Edu / Go; in der OpenAI API ab 24. April. Kontextfenster: 400K in Codex, 1M in der API — Codex begrenzt das Fenster auf 400K, um Durchsatz und Kosten über die Abonnementstufen hinweg auszubalancieren; die API stellt die vollen 1M bereit. Preise (API): 5 $ Eingabe / 30 $ Ausgabe pro MTok (2× der GPT-5.4-Preis; OpenAI gibt nach Verbesserungen der Token-Effizienz eine effektive Steigerung von etwa 20 % an). Benchmarks: 82,7 % Terminal-Bench 2.0 (aktueller SOTA unter öffentlich verfügbaren Modellen), 84,9 % GDPval (44 Berufe), 78,7 % OSWorld-Verified, 98,0 % Tau2-bench Telecom (ohne Prompt-Tuning). OpenAI nutzte GPT-5.5 + Codex vor der Einführung intern, um die Serving-Infrastruktur umzuschreiben — das führte zu einer Steigerung der Token-Generierungsgeschwindigkeit um 20 %.⁸³

GPT-5.4 und GPT-5.4 mini werden am 31. August 2026 aus Codex entfernt.¹¹⁷ Bis dahin bleibt GPT-5.4 auf allen Codex-Oberflächen auswählbar.⁶⁴ 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 Unterhaltungen werden automatisch mit GPT-5.3 Instant, GPT-5.4 Thinking oder GPT-5.4 Pro fortgesetzt. GPT-5.1-Codex-Mini blieb über API und CLI bis zur Einstellung am 23. Juli 2026 verfügbar.⁷¹⁸⁸

Hinweis zur kostenlosen Stufe (5. Mai 2026): GPT-5.5 Instant wurde am 5. Mai 2026 für die kostenlose ChatGPT-Stufe eingeführt. Dadurch erweitert sich die Zielgruppe für die GPT-5.5-Familie über kostenpflichtige Pläne hinaus, auch wenn der Zugriff auf Codex CLI weiterhin ein berechtigtes Plus- / Pro- / Business- / Enterprise- / Edu- / Go-Abonnement oder einen API-Schlüssel erfordert.⁹²

GPT-5.4 mini (17. März 2026): Eine kleinere, schnellere Variante von GPT-5.4 mit 400K Kontext für 0,75 $/4,50 $ pro MTok — sie nutzt nur 30 % des GPT-5.4-Kontingents. Ideal für die Subagent-Delegation: Lassen Sie GPT-5.4 Planung und Koordination übernehmen, während GPT-5.4-mini-Subagenten engere Teilaufgaben (Codebase-Suche, Dateiprüfung, Dokumentverarbeitung) parallel bearbeiten.⁷⁶

Bedrock GPT-5.6 (Sol, Terra, Luna) (v0.143.0, 8. Juli 2026): Codex ergänzte erstklassige Unterstützung für drei auf Amazon Bedrock gehostete GPT-5.6-Modellvarianten, einschließlich Unterstützung für die Reasoning-Aufwandsstufe max. Für Teams, deren Modellzugriff über einen Bedrock-Provider erfolgt, lassen sich diese wie andere Modelle mit benutzerdefiniertem Provider auswählen (siehe Custom Model Providers); die Aufwandsstufe max richtet sich an die anspruchsvollsten Reasoning- und agentischen Workloads.¹⁰⁶ v0.144.6 (18. Juli 2026) aktualisierte die gebündelten Anweisungen für Sol, Terra und Luna und korrigierte deren Kontextfenster auf 272.000 Tokens.¹¹¹ v0.145.0 (21. Juli 2026) ergänzt experimentelles Bedrock-Login mit Unterstützung für benutzerdefinierte Endpunkte und Authentifizierung, macht GPT-5.6 Sol zum Standard-Bedrock-Modell und migriert gebündelte GPT-5.4-Modellauswahlen auf die entsprechenden Varianten Terra und Luna.¹¹²

Flussdiagramm zur Modellauswahl

Is this a quick fix or simple question?
├─ Yes → gpt-5.6-luna (fastest, most affordable)
└─ 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.6-luna (the bundled subagent pick since v0.145.0)
   │     │  └─ No
   │     │     ├─ Everyday coding task (refactor, migration, feature build)?
   │     │     │  ├─ Yes → gpt-5.6-terra (everyday model, 272K context)
   │     │     │  └─ No → gpt-5.6-sol (flagship — the default "Power" setting)
   └─ Still unsure? → gpt-5.6-sol

Reasoning-Aufwand

Steuern Sie, wie viel das Modell vor der Antwort „nachdenkt“:

Unterstützte Stufen hängen vom Modell ab. 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"

Experten-Tipp: xhigh-Reasoning kann für denselben Prompt 3- bis 5-mal mehr Tokens als medium verwenden. Reservieren Sie es für wirklich schwierige Probleme, bei denen sich das zusätzliche Nachdenken auszahlt.

Schnelle Reasoning-Steuerung in der TUI (v0.124.0+).⁸⁵ In einer interaktiven TUI-Sitzung verringert Alt+, das Reasoning um eine Stufe und Alt+. erhöht es um eine Stufe — nützlich, wenn ein schwieriges Problem während einer Sitzung vorübergehend eine Steigerung von medium → high → xhigh ohne /effort oder -c rechtfertigt. Wenn Sie während einer Sitzung ein Modell-Upgrade akzeptieren, wird das Reasoning auf den Standard des neuen Modells zurückgesetzt, statt die vorherige Stufe zu übernehmen.

Modellwechsel

Wechseln Sie Modelle während einer Sitzung mit dem Slash-Befehl /model, oder legen Sie sie pro Durchlauf über --model / -m fest:

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

Was kostet Codex?

Siehe auch Modellauswahl für Funktionen und Entscheidungsrahmen, um für jede Aufgabe das richtige Modell auszuwählen.

Zugriff über ChatGPT-Pläne

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

Preisupdate vom April 2026: Der jährliche Business-Preis sank von $25 auf $20/Lizenz/Monat. Nur Codex-Lizenzen mit nutzungsbasierter Abrechnung sind jetzt für Business- und Enterprise-Workspaces verfügbar — keine feste Lizenzgebühr, Abrechnung nach Tokenverbrauch.⁷⁹ Auf der Preisseite werden Limits nun als modellabhängige Bereiche veröffentlicht (siehe Tabelle oben), statt als Aktionsmultiplikatoren von 2x aus dem Desktop-App-Launch im Februar 2026.¹⁶¹¹⁹

Anhebung des Nutzungslimits im Mai 2026 (abgelaufen am 31. Mai 2026): Codex im Plus-Plan lief mit einem 25×-Limit über 5 Stunden (gegenüber der Standardanhebung von 20×), und die Stufe für $100/Monat wurde verdoppelt.⁸⁹

Creditkosten

Codex-Vorgänge verbrauchen Credits aus der Zuteilung Ihres Plans:

In der Praxis „liegt die GPT-5.6-Nutzung im Durchschnitt bei 5–40 Credits pro Nachricht“; der Schnellmodus verbraucht bei unterstützten Modellen Credits schneller, und die Bildgenerierung nutzt enthaltene Limits 3–5x schneller auf als vergleichbare reine Textdurchläufe.¹¹⁹

Enterprise- und Edu-Pläne skalieren Credits mit der vertraglichen Zuteilung. Prüfen Sie /status in der TUI für die aktuelle Nutzung.

Abrechnung über API

Wenn Sie Codex über das API verwenden, berechnet OpenAI die Nutzung pro Token gemäß den Standardpreisen von OpenAI API für das ausgewählte Modell (zuzüglich aller anwendbaren Rabatte für Prompt-Caching). Aktuelle Preise finden Sie auf der offiziellen Preisseite für API.²⁰

Strategien zur Kostenoptimierung

1. Profile verwenden: Erstellen Sie für Routineaufgaben ein fast-Profil mit gpt-5.6-luna und model_reasoning_effort = "low".
2. Hohe Reasoning-Stufe reservieren: Verwenden Sie xhigh nur für wirklich schwierige Probleme, da es 3–5x mehr Token kostet.
3. --ephemeral verwenden: Überspringen Sie die Sitzungsdauerhaftigkeit in CI/CD, um den Overhead zu reduzieren.
4. Reasoning-Zusammenfassungen minimieren: Setzen Sie model_reasoning_summary = "none", wenn Sie keine Erklärungen benötigen.
5. Mit dem Exec-Modus bündeln: codex exec vermeidet TUI-Overhead bei Automatisierungsworkflows.
6. Nutzung überwachen: Prüfen Sie /status in der TUI und die Abrechnungs-Dashboards Ihrer Organisation.

Kostenbeispiele aus der Praxis

Repräsentative API-Kosten für häufige Aufgaben (eine Momentaufnahme der Preise für gpt-5.3-codex aus der Mitte des Jahres 2026, mittleres Reasoning — die relativen Größenordnungen gelten modellübergreifend):

Die Kosten variieren je nach Reasoning-Aufwand, Caching und Gesprächslänge. Verwenden Sie gpt-5.6-luna für Routineaufgaben, um die Ausgaben für diese Aufgaben deutlich zu senken. Gecachte Input-Token werden vergünstigt abgerechnet.

Versteckter Token-Overhead

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

Expertentipp: Überwachen Sie Ihre tatsächliche Nutzung über /status in der TUI. Die Tokenanzahl umfasst sämtlichen Overhead, nicht nur Ihre sichtbaren Nachrichten. Falls Sie die Kosten überraschen, prüfen Sie, wie viele MCP-Server verbunden sind — jeder fügt jeder API-Anfrage Tool-Definitionen hinzu.

Verwaltung von Teamkosten

Strategien zur Kontrolle der Teamkosten:

• requirements.toml festlegen, um modell- und reasoningbezogene Limits organisationsweit durchzusetzen
• gpt-5.6-luna für CI/CD verwenden — automatisierte Pipelines benötigen selten maximales Reasoning
• Profilbasierte Budgetierung — definieren Sie ci-, review- und dev-Profile mit angemessenen Kostenobergrenzen
• Über OpenTelemetry überwachen — Enterprise-Bereitstellungen können Nutzungs-Telemetrie in bestehende Observability-Stacks exportieren

Entscheidungsrahmen

Wann welche Oberfläche verwendet werden sollte

Wann welcher Sandbox-Modus verwendet werden sollte

Wann welche Reasoning-Stufe verwendet werden sollte

Plan Mode 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 Mode: Enter vs. Tab

Faustregel: Enter = „Stopp, hör dir das jetzt an.“ Tab = „Wenn du fertig bist, erledige auch das.“

Desktop App vs. CLI

How do you prefer to work?
│
├── Terminal-first → Use CLI
│   │
│   ├── Single focused task → codex (interactive TUI)
│   ├── Scripted automation → codex exec (non-interactive)
│   └── Quick one-shot → codex exec "prompt" -o result.txt
│
└── Visual/multi-project → Use Desktop App
    │
    ├── Multiple parallel tasks → Multi-thread with worktree isolation
    ├── Visual diff review → Built-in Git diff viewer
    ├── Scheduled automation → Automations tab
    └── Voice-driven → Ctrl+M for voice dictation

Welches Profil?

Ordnen Sie Ihre Aufgabe einem vorkonfigurierten Profil zu:

config.toml-Einrichtung:

# Default profile
profile = "default"

[profiles.fast]
model = "gpt-5.6-luna"
model_reasoning_effort = "low"

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

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

[profiles.ci]
model = "gpt-5.6-luna"
model_reasoning_effort = "low"
sandbox_mode = "workspace-write"

Profile pro Sitzung wechseln: codex --profile careful

Wie funktionieren Sandbox und Genehmigungssystem?

Codex verwendet ein zweistufiges Sicherheitsmodell, das trennt, was technisch möglich ist und wann Codex eine menschliche Genehmigung anfordert. Dieser Ansatz unterscheidet sich grundlegend vom Berechtigungssystem von Claude Code – Codex setzt Einschränkungen auf Ebene des Betriebssystemkernels durch.⁵ Informationen zu requirements.toml-Einschränkungen, die Administratoren unternehmensweit durchsetzen, finden Sie außerdem unter Unternehmensbereitstellung.

Ebene 1: Sandbox (Was ist möglich?)

Die Sandbox steuert den Dateisystem- und Netzwerkzugriff mithilfe nativer Betriebssystemmechanismen:

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 auf eine Allowlist setzen (z. B. docker.sock, IPC-Sockets von Editoren), und die private DNS-Auflösung ist nicht mehr standardmäßig blockiert.⁸²
• Linux: Landlock für Dateisystembeschränkungen und seccomp für die Filterung von Systemaufrufen. Ein eigenständiger Hilfsprozess (codex-linux-sandbox) bietet mehrschichtige Isolation.⁵ Bubblewrap (bwrap) wird als Teil des Linux-Builds mitgeliefert und kompiliert (seit v0.100.0 nicht mehr optional)⁷. v0.117.0 verbesserte die Zuverlässigkeit der Sandbox auf älteren Distributionen mit veralteten Kernel-Konfigurationen.⁷⁵ v0.129.0 härtete den Sandbox-Start unter Linux und aktualisierte das mitgelieferte Bubblewrap auf 0.11.2 einschließlich Upstream-Sicherheitspatches; v0.130.0 ergänzte weitere Härtungsmaßnahmen beim Start.⁸⁹⁹¹
• Windows: Native Sandbox mit eingeschränkten Tokens (seit v0.100.0 nicht mehr experimentell). WSL wird ebenfalls unterstützt (mit Landlock und seccomp von Linux). v0.117.0 enthält Verbesserungen der Sandbox mit eingeschränkten Tokens für eine bessere Prozessisolierung.⁷⁵ v0.130.0 gewährt Sandbox-Benutzern Zugriff auf den Binärdatei-Cache der Desktop-Laufzeit, damit die Windows-Sandbox Laufzeitbinärdateien für Benutzer der Workspace-Sandbox zuverlässig auflösen kann.⁹¹

Warum das wichtig ist: Im Gegensatz zu containerbasierter Sandbox-Isolation (Docker) ist die Isolation auf Betriebssystemebene schneller, ressourcenschonender und schwieriger zu umgehen. Der Kernel setzt Einschränkungen durch, noch bevor Codex den Systemaufruf überhaupt sieht.

Sicherheitskorrekturen: - Umgehung der Sandbox durch zsh-fork (v0.106.0): Eine Schwachstelle wurde behoben, durch die die Shell-Ausführung mittels zsh-Forking Sandbox-Einschränkungen umgehen konnte.⁶⁰ Wenn Sie eine ältere Version verwenden, führen Sie sofort ein Upgrade durch. - Begrenzung der Eingabegröße (v0.106.0): Codex begrenzt Eingaben nun auf ungefähr 1 Million Zeichen, um ein Hängenbleiben durch übermäßig große Nutzdaten zu verhindern.⁶⁰ - Sicheres Devcontainer-Profil (v0.121.0): Ein neues gehärtetes Kundenprofil für Docker-Devcontainer verwendet Bubblewrap für die Sandbox-Isolation innerhalb des Containers. WSL2 wird unterstützt; WSL1 wird ausdrücklich abgelehnt (Bubblewrap ist mit dem Kernel-Shim von WSL1 nicht kompatibel).⁸² - Guardian-Prüfung und hooks (v0.121.0): Während Guardian-Prüfungssitzungen sind hooks deaktiviert, damit hooks vor oder nach Tool-Aufrufen die Entscheidungen des Guardian-Subagenten nicht beeinflussen können.⁸² Wenn Sie für Protokollierung oder Validierung auf hooks angewiesen sind, beachten Sie, dass sie bei einer Guardian-Prüfung übersprungen werden – greifen Sie auf die Beobachtbarkeit des App-Servers zurück, wenn Sie einen vollständigen Audit-Trail benötigen. - Linux-Dateisystem /dev (v0.105.0): Befehle in der Linux-Sandbox erhalten nun ein minimales /dev-Dateisystem. Das verbessert die Kompatibilität mit Tools, die Geräteknoten erwarten.⁶¹

ReadOnlyAccess-Richtlinie (v0.100.0+): Eine konfigurierbare Richtlinienstruktur zur granularen Steuerung des Lesezugriffs. Damit können Sie festlegen, aus welchen Verzeichnissen Codex lesen darf – selbst im Modus workspace-write:

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

Ebene 2: Genehmigungsrichtlinie (Wann wird nachgefragt?)

Die Genehmigungsrichtlinie legt fest, wann Codex pausiert und eine menschliche Bestätigung anfordert:

on-failure erscheint weiterhin in einigen älteren Beispielen und Kompatibilitätspfaden, wird in der aktuellen OpenAI-Konfigurationsdokumentation jedoch als veraltet gekennzeichnet. Verwenden Sie für interaktive Ausführungen vorzugsweise on-request und für nicht interaktive Ausführungen, die bereits über eine externe Sicherheitsgrenze verfügen, never.⁸⁷

Eindeutige Genehmigungs-IDs (v0.104.0+)

Codex weist nun jedem Befehl innerhalb einer mehrstufigen Shell-Ausführung eine eigene Genehmigungs-ID zu. Dadurch erfolgen Genehmigungen granular: Wenn Sie einen Befehl in einer Sequenz genehmigen, werden nachfolgende Befehle desselben Shell-Aufrufs nicht automatisch ebenfalls genehmigt.⁴⁹

Flexible Genehmigungssteuerung (v0.105.0+)

Der Genehmigungsablauf unterstützt nun zusätzliche Sandbox-Berechtigungen und granulare Ablehnungen:⁶¹

• Zusätzliche Sandbox-Berechtigungen: Benötigt ein Befehl Zugriff über den aktuellen Sandbox-Modus hinaus, kann Codex gezielt zusätzliche Berechtigungen anfordern, statt einen vollständigen Moduswechsel zu verlangen
• Granulare Ablehnung: Lehnen Sie einzelne Tool-Aufrufe mit einer Rückmeldung ab, damit Codex seinen Ansatz anpassen kann, anstatt lediglich denselben Befehl erneut zu versuchen

Berechtigungsanforderungen zur Laufzeit (v0.113.0+)

Codex enthält nun ein integriertes Tool namens request_permissions, mit dem das Modell zur Laufzeit zusätzliche Berechtigungen anfordern kann.⁶⁹ Wenn das Modell auf eine Aufgabe stößt, die erweiterte Zugriffsrechte erfordert, kann es über den TUI-Genehmigungsablauf gezielt bestimmte Berechtigungen anfordern – etwa für Dateisystempfade oder Netzwerkzugriff –, statt stillschweigend zu scheitern oder den Benutzer zu einem Neustart mit anderen Flags zu zwingen.

App-Genehmigungsmodus writes (v0.144.0+)

Apps und Konnektoren erhalten eine mittlere Genehmigungsstufe: Im App-Genehmigungsmodus writes können die von einer App als schreibgeschützt deklarierten Aktionen ohne Rückfrage ausgeführt werden, während bei sämtlichen Schreibvorgängen weiterhin pausiert wird.¹⁰⁷ Zuvor waren App-Genehmigungen eher eine Alles-oder-nichts-Entscheidung; writes entspricht dem Vertrauensmodell, das die meisten Betreiber tatsächlich für Integrationen wünschen – Nachsehen ist erlaubt, Änderungen erfordern eine Nachfrage.

Automatisch geprüfte Genehmigungen: --approve-for-me (v0.147.0+)

Das neue CLI-Flag --approve-for-me macht aus Genehmigungsaufforderungen automatisch geprüfte Genehmigungen: Statt Sie zu unterbrechen, wird jede Anfrage in einem Prüfungsdurchlauf bewertet und in Ihrem Namen genehmigt oder abgelehnt.¹¹⁶ Dieser Ansatz liegt zwischen „alles genehmigen“ (der Haltung, zu der --full-auto früher ermutigte; inzwischen entfernt) und „bei allem unterbrechen“ – die Aufforderungen bleiben als Entscheidungspunkte bestehen, werden jedoch von einer Prüfinstanz beantwortet. Kombinieren Sie dies mit den sichereren Standardeinstellungen für automatische Prüfungen von cyberfähigen Modellen aus v0.146.1, die dieses Flag übernimmt. Behandeln Sie es wie jede Übertragung von Entscheidungsbefugnissen: Es eignet sich für lange, unbeaufsichtigte Ausführungen, bei denen eine Unterbrechung zum Stillstand führt, nicht jedoch für Sitzungen mit Zugriff auf Anmeldedaten oder Produktivsysteme, bei denen Sie selbst die Prüfung übernehmen möchten.

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

Berechtigungsprofile unterteilen die Sandbox-Richtlinien für Dateisystem und Netzwerk in benannte, wiederverwendbare Abschnitte. Legen Sie für default_permissions ein integriertes Profil wie :read-only oder :workspace fest oder verweisen Sie auf eine benutzerdefinierte Tabelle [permissions.<name>].⁸⁷ v0.133.0 etabliert Profile als verwaltete Oberfläche: Listen-APIs stellen Metadaten verfügbarer Profile bereit, Profile können voneinander erben, verwaltete requirements.toml-Dateien können Berechtigungsanforderungen deklarieren, aktive Profile werden zur Laufzeit aktualisiert und die Einrichtung der Windows-Sandbox verwendet nun das aufgelöste Profil statt einer separaten Ad-hoc-Richtlinie.⁹⁸

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 vertrauliche Dateien und Globs, die selbst dann nicht lesbar sein sollen, wenn das Projektstammverzeichnis beschreibbar ist. Für einmalige Befehlsausnahmen sollten Sie Regeln vorziehen, statt ein Profil umfassend zu erweitern.⁸⁷

Frühere Empfehlungen zu --full-auto

Ältere Leitfäden beschrieben --full-auto als praktische Kurzform für:

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

In v0.128.0 kennzeichnen die Versionshinweise --full-auto als veraltet, und die aktuelle Hilfe von CLI führt es für interaktive Ausführungen nicht mehr auf. Verwenden Sie stattdessen die oben genannten expliziten Flags oder ein benanntes Berechtigungsprofil.⁸⁶

v0.147.0 schließt die Entfernung ab: codex exec --full-auto ist nicht mehr verfügbar. Ein Skript, das dieses Flag weiterhin übergibt, bricht nun mit einem Fehler ab, statt ausgeführt zu werden. Die Migration ist rein mechanisch: Ersetzen Sie es durch --sandbox workspace-write und ergänzen Sie ein Genehmigungs-Flag oder Profil, falls Ihr bisheriger Aufruf das Genehmigungsverhalten von --full-auto nutzte. Prüfen Sie vor dem Upgrade sämtliche Automatisierungen, die codex exec über die Shell aufrufen: Der Fehler zeigt sich als defekte Pipeline, nicht als Veraltungswarnung.¹¹⁶

Sandbox-Zuverlässigkeit (v0.129.0): Die Härtung des Linux-Sandbox-Starts reduziert Race Conditions auf langsamen Dateisystemen oder bei über symbolische Links eingebundenen Checkouts; Verbesserungen an der Zuverlässigkeit der Windows-Sandbox beheben mehrere Abstürze in Randfällen während lang laufender Ausführungen; außerdem wurde das mitgelieferte Bubblewrap einschließlich Upstream-Sicherheitspatches auf 0.11.2 aktualisiert. Konfigurationsänderungen sind nicht erforderlich. Führen Sie codex update aus, um diese Verbesserungen zu erhalten.⁸⁹

Empfohlene Konfigurationen

Tägliche Entwicklung (sichere Standardeinstellung):

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

Erfahrene Benutzer (vollständiger Zugriff mit menschlicher Kontrolle):

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

Diese Kombination gilt in der Community als empfohlener „Sweet Spot“: maximale Möglichkeiten, während jeder Befehl eine Genehmigung erfordert.⁸

CI/CD-Automatisierung:

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

Intelligente Genehmigungen mit Guardian-Subagent (v0.115.0+)

Intelligente Genehmigungen können Prüfungsanfragen an einen Guardian-Subagenten weiterleiten, statt für jede Aktion eine menschliche Genehmigung zu verlangen. Die Guardian-Sitzung bleibt über mehrere Genehmigungen hinweg bestehen, damit der Prompt-Cache wiederverwendet und zusätzlicher Startaufwand vermieden werden kann. Jede Prüfung erhält einen bereinigten Verlauf, sodass frühere Entscheidungen nicht in spätere Prüfungen einfließen.⁷³

Konfigurieren Sie die Prüfinstanz in config.toml:

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

Dies ist besonders nützlich für CI/CD-Workflows, in denen Sie eine automatisierte Prüfung mit Begründung wünschen, statt pauschal approval_policy = "never" festzulegen.

Strengere PowerShell-Klassifizierung (v0.142.2): PowerShell-Befehle mit ausführbaren AST-Bereichen, die der Sicherheitsklassifikator nicht untersuchen kann, erfordern nun eine Genehmigung, statt die automatische Genehmigung zu umgehen. Damit wird eine Lücke geschlossen, durch die verschleiertes oder dynamisch erzeugtes PowerShell unter Windows der Klassifizierung entgehen konnte.¹⁰⁵

Erweiterte Erkennung gefährlicher Befehle (v0.144.5): Die Erkennung berücksichtigt nun weitere erzwungene Formen von rm, und bei abgelehnten Befehlen werden klarere Ablehnungsgründe statt einer undurchsichtigen Verweigerung ausgegeben. Das ist hilfreich, wenn Sie Genehmigungsrichtlinien abstimmen und nachvollziehen müssen, warum ein Befehl blockiert wurde.¹¹⁰

Netzwerkzugriff aktivieren

Codex blockiert den 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

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

Für Unternehmensumgebungen, die WebSocket-Datenverkehr über einen Proxy leiten, unterstützt Codex nun 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+).

v0.146.0 ist die Version, mit der „alle Transportschichten“ tatsächlich Realität wurde. Konfigurierte Proxys werden nun bei Authentifizierung, Plugin-Downloads, MCP-Autorisierung, Remote-Ausführung, WebSocket-Verbindungen, HTTP-Weiterleitungen und LM-Studio-Verbindungen berücksichtigt – sieben Pfade, die dem Changelog zufolge den Proxy zuvor ignorierten.¹¹⁴ Wenn Sie Codex vor v0.146.0 hinter einem Unternehmensproxy betrieben haben und Anmeldungen oder Plugin-Installationen fehlschlugen, während gewöhnliche Modellaufrufe funktionierten, war diese Lücke wahrscheinlich die Ursache.

Systemproxy unter macOS (v0.142.2+): Ist respect_system_proxy aktiviert, berücksichtigen macOS-Authentifizierungsclients die Systemproxy-, PAC- und WPAD-Einstellungen. Unternehmens-Macs, deren Proxy-Konfiguration über Profile verteilt wird, benötigen daher für den Authentifizierungsdatenverkehr keine Proxy-Umgebungsvariablen pro Shell mehr.¹⁰⁵ Seit v0.143.0 gilt dies auch für Windows und den Datenverkehr der Responses-API: Codex leitet sowohl die Authentifizierung als auch Aufrufe der Responses-API über den macOS- oder Windows-Systemproxy, einschließlich automatischer PAC- und WPAD-Konfiguration. Damit wird die letzte Lücke für abgeschottete Unternehmensnetzwerke auf beiden Betriebssystemen geschlossen.¹⁰⁶

Sandbox testen

Überprüfen Sie das Verhalten der Sandbox, 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 ordnungsgemäß funktioniert, sollten beide Befehle unter einem auf den Workspace beschränkten Profil mit einem Fehler wegen verweigerter Berechtigung fehlschlagen. Wenn einer der Befehle erfolgreich ausgeführt wird, muss Ihre Sandbox-Konfiguration untersucht werden.

Wie funktioniert AGENTS.md?

AGENTS.md ist das Projektanweisungssystem von Codex – ein offener Standard⁹, der inzwischen von der Agentic AI Foundation der Linux Foundation verwaltet wird. Er wird von Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode und mehr als 60.000 Open-Source-Projekten unterstützt. Er legt fest, wie sich Codex innerhalb eines bestimmten Repositorys oder Verzeichnisses verhält. Unter Skills finden Sie wiederverwendbare Kompetenzpakete, die AGENTS.md ergänzen.

Ermittlungshierarchie

Zu Beginn einer Sitzung erstellt Codex eine Anweisungskette, indem es den Verzeichnisbaum durchläuft:

1. Global (~/.codex/): AGENTS.override.md > AGENTS.md
2. Projekt (vom Git-Stammverzeichnis bis zum aktuellen Verzeichnis): Auf jeder Ebene wird nach AGENTS.override.md > AGENTS.md > alternativen Dateinamen gesucht
3. Zusammenführung: Die Dateien werden vom Stammverzeichnis abwärts aneinandergefügt; näher gelegene Dateien erscheinen später im Prompt und setzen frühere Vorgaben außer Kraft

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

Desktop-Projekte mit mehreren Ordnern (26.715, 23. Juli 2026): Der oben beschriebene Durchlauf bezieht sich auf CLI, das alles relativ zum aktuellen Arbeitsverzeichnis auflöst. In der ChatGPT-Desktop-App kann sich ein lokales Projekt inzwischen über mehrere zusammengehörige Ordner erstrecken. Für die Ermittlung wird jedoch genau einer davon verwendet: „Neue Chats, Git-Vorgänge sowie die automatische Ermittlung von AGENTS.md, skills und config.toml verwenden den primären Ordner. Sekundäre Ordner stehen weiterhin für die Dateisuche sowie zum Lesen und Bearbeiten zur Verfügung.“ Über Projekt bearbeiten im Projektmenü legen Sie fest, welcher Ordner primär ist.¹¹³

Diese eine Einstellung steuert gleichzeitig drei der fünf Kernsysteme von Codex: Anweisungen, skills und Konfiguration richten sich alle nach dem primären Ordner. In der Praxis bedeutet das: Eine AGENTS.md in einem sekundären Ordner ist eine Datei, die Codex öffnen kann, aber kein verbindlicher Arbeitsrahmen, den es lädt. Wenn das Repository mit Ihren Regeln erst als zweiter Ordner hinzugefügt wurde, müssen Sie es entweder zum primären Ordner machen oder die Regeln in der AGENTS.md des primären Ordners wiederholen. Dasselbe gilt für Skill-Ordner in Repositorys, deren automatische Erkennung Sie erwartet haben. Am Verzeichnisdurchlauf von CLI hat sich nichts geändert – hier geht es um die Projektabgrenzung der Desktop-App.

Was zeichnet eine hervorragende AGENTS.md aus?

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

EMPFOHLEN: - Formulieren Sie konkret: "Use rg --files for discovery" ist besser als "search efficiently" - Definieren Sie Abschlusskriterien: Was bedeutet „fertig“? (Tests bestanden, Linting fehlerfrei usw.) - Geben Sie Befehle an: Build, Tests, Linting und Formatierung (mit den genauen Aufrufen) - Gliedern Sie nach Aufgaben: Abschnitte für Programmierung, Review, Release und Vorfälle/Debugging - Definieren Sie Eskalationswege: Was ist bei Blockaden oder einem unerwarteten Zustand zu tun?

NICHT EMPFOHLEN: - Vollständige Stilrichtlinien ohne Ausführungsregeln einfügen - Mehrdeutige Anweisungen verwenden („Vorsicht walten lassen“, „optimieren“) - Widersprüchliche Prioritäten vermischen (Geschwindigkeit + umfassende Überprüfung + kein Laufzeitbudget) - Dokumentation in Prosa verfassen (AGENTS.md ist eine operative Richtlinie, keine README)

Beispiel: AGENTS.md für den Produktionseinsatz

# 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 Geheimnissen in Agentensitzungen

Betrachten Sie den für Codex sichtbaren Verlauf als sicherheitsrelevante Angriffsfläche, nicht nur den Quellcode. Die Versionshinweise von Codex dokumentieren Arbeiten an Shell-Snapshots und der Schwärzung von Umgebungsvariablen, während das Speichersystem Schreibvorgänge auf Geheimnisse prüft. Diese Schutzmaßnahmen machen Befehlsausgaben, Sitzungstranskripte, Shell-Snapshots, lokale Protokolle oder Hilfsskripte jedoch nicht zu sicheren Orten für die Ausgabe von Zugangsdaten.³⁷⁵⁵⁹⁵

Die Betriebsregel ist einfach: Geben Sie keine Geheimnisse aus, die das Modell einsehen könnte; bewahren Sie Zugangsdaten für Hilfsprogramme in der von der Umgebung vorgesehenen Konfiguration auf; trennen Sie bei Audits ausführbaren Quellcode, Dokumentation, generierte Caches, Sitzungstranskripte, Shell-Snapshots, Protokolle und bewusst eingerichtete Geheimnisspeicher; schwärzen Sie den lokalen Verlauf, wenn darin ein mit hoher Wahrscheinlichkeit geheimes Muster auftaucht; und führen Sie präventive hooks erst ein, nachdem sich der manuelle Hygieneprozess bewährt hat. Öffentlich relevant sind die Übersicht der Angriffsflächen und die Akzeptanzkriterien – nicht private Tokenwerte, genaue Pfade oder interne Details der Erkennung.⁹⁵

Der Override-Mechanismus

AGENTS.override.md ersetzt auf jeder Verzeichnisebene die normale AGENTS.md für den jeweiligen Geltungsbereich. Verwenden Sie dies für:

• Release-Sperren: „Keine neuen Funktionen, nur Fehlerbehebungen“
• Vorfallsmodus: „Alle Änderungen müssen vom Bereitschaftsdienst geprüft werden“
• Vorübergehende Härtung: „In diesem Sprint keine Abhängigkeitsaktualisierungen“

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)

Gerüstgenerierung

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

Oder überprüfen Sie Ihre Anweisungskette:

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

Hooks

Codex führte hooks in v0.99.0 (AfterAgent) und v0.100.0 (AfterToolUse) ein und ergänzte anschließend in v0.114.0 eine experimentelle Hooks-Engine mit den Ereignissen SessionStart und Stop.⁷⁰ Seit v0.124.0 (23. April 2026) sind hooks stabil.⁸⁵ Sie können nun direkt in config.toml und requirements.toml konfiguriert werden – eine separate Datei für Hook-Skripte ist nicht mehr erforderlich – und überwachen neben apply_patch und lang laufenden Bash-Sitzungen auch MCP-Tools. Das System deckt inzwischen sowohl den Sitzungslebenszyklus als auch Automatisierungen auf Tool-Ebene ab und schließt damit die Lücke zum Hook-Modell von Claude Code.

Verfügbare Hook-Ereignisse

Hook-Konfiguration

Hooks werden in .codex/config.toml konfiguriert:

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

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

Die Standardausgabe des Hooks SessionStart wird in den Kontext des Modells eingespeist. Dadurch eignet er sich ideal, um zu Sitzungsbeginn dynamische Informationen wie Datumsangaben, Branch-Namen oder Umgebungsvariablen einzufügen.

Hook-Muster von Claude Code nachbilden

Wenn Sie von Claude Code migrieren, können Sie eine ähnliche Automatisierung folgendermaßen umsetzen:

Expertentipp: Seit v0.124.0 (23. April 2026) ist die Hooks-Engine stabil. Mit neuen Releases kommen weiterhin neue Hook-Ereignisse hinzu – prüfen Sie das Codex-Änderungsprotokoll.

Hook-Browser in der TUI (v0.129.0): Führen Sie /hooks in der TUI aus, um verfügbare hooks zu ermitteln, die derzeit aktiven hooks anzuzeigen und einzelne hooks umzuschalten, ohne config.toml zu bearbeiten. Dies ist hilfreich, wenn Sie Fehler eines von einem Plugin bereitgestellten Hooks beheben oder einen AfterToolUse-Linter für eine konzentrierte Bearbeitungssitzung vorübergehend deaktivieren möchten.⁸⁹

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

MCP erweitert die Fähigkeiten von Codex durch die Verbindung mit externen Tools und Diensten. Die Befehlsgruppe codex mcp ist derzeit als experimentell gekennzeichnet; Befehle und Konfigurationsformat können sich zwischen Releases ändern. Codex unterstützt zwei Transporttypen: STDIO (lokale Prozesse) und Streamable HTTP (Remote-Server).¹¹

Änderungen bei MCP in v0.121.0: Tools werden jetzt mit einem Namespace registriert, sodass Tool-Namen in Auflistungen als <server>:<tool> statt als einfache Namen erscheinen — aktualisieren Sie alle Skripte oder Prompts, die nach nicht qualifizierten Tool-Namen suchen. Ein neues Flag supports_parallel_tool_calls wird an eingebundene MCPs weitergegeben und ermöglicht die parallele Ausführung für Server, die diese Unterstützung deklarieren. Sandbox-Statusmetadaten werden jetzt über MCP-Toolmetadaten weitergegeben, sodass Server ihr Verhalten anpassen können (z. B. warnen, wenn sie in einer schreibgeschützten Sandbox ausgeführt werden). Die benutzerdefinierte Anfrage codex/sandbox-state wurde entfernt — verwenden Sie stattdessen den Metadatenpfad. Phase 3 des MCP-Apps-Rollouts landet hier mit Unterstützung für Tool-Aufrufe; abgeflachte verzögerte Tool-Aufrufe werden nun für Server unterstützt, die das Deferred-Call-Muster verwenden.⁸²

Änderungen bei MCP in v0.142.2 (25. Juni 2026): MCP-Tools verwenden jetzt standardmäßig die Tool-Suche, sofern unterstützt — statt jede Tool-Definition im Voraus zu laden, entdeckt Codex Tools bei Bedarf. Das verbessert die Erkennung in Setups mit vielen Tools und bleibt zugleich mit älteren Modellen und Anbietern kompatibel. Remote-STDIO-MCP-Server akzeptieren außerdem absolute Arbeitsverzeichnisse, die im Pfadformat der Remote-Plattform geschrieben sind (etwa einen Windows-Pfad von einem macOS-Client oder umgekehrt).¹⁰⁵

Änderungen bei MCP in v0.147.0 (7. August 2026): Codex ergänzt optionale Unterstützung für die MCP-Protokollrevision vom 28.07.2026 — paginierte Erkennung (große Tool-Kataloge werden seitenweise statt in einer übergroßen Auflistung übertragen), mehrstufige Anfragen (ein Server kann einen mehrschrittigen Austausch innerhalb einer logischen Anfrage abwickeln) und nicht blockierenden Serverstart. Dabei werden zwischengespeicherte MCP-Tools bereitgestellt, bevor der Server vollständig gestartet ist, sodass ein langsamer Server den Sitzungsstart nicht mehr aufhält. Die Unterstützung ist optional; Server mit der älteren Revision funktionieren unverändert weiter.¹¹⁶

MCP-Server konfigurieren

STDIO-Server (lokale Prozesse):

# In ~/.codex/config.toml or .codex/config.toml

[mcp_servers.context7]
enabled = true
required = true                         # Fail startup if unavailable
command = "npx"
args = ["-y", "@upstash/context7-mcp"]
env = { "MY_VAR" = "value" }            # Static env vars
env_vars = ["PATH", "HOME"]             # Forward host env vars
cwd = "/path/to/project"                # Optional working directory
startup_timeout_sec = 10
tool_timeout_sec = 60
enabled_tools = ["search", "summarize"]  # Tool allowlist
disabled_tools = ["slow-tool"]           # Tool denylist

HTTP-Server (Remote):

[mcp_servers.figma]
enabled = true
url = "https://mcp.figma.com/mcp"
bearer_token_env_var = "FIGMA_OAUTH_TOKEN"
http_headers = { "X-Figma-Region" = "us-east-1" }
env_http_headers = { "X-Org-Id" = "FIGMA_ORG_ID" }  # Headers from env vars
startup_timeout_sec = 10
tool_timeout_sec = 60

CLI-Verwaltung

codex mcp add context7 -- npx -y @upstash/context7-mcp
codex mcp add context7 --env API_KEY=... -- npx -y @upstash/context7-mcp   # With env vars
codex mcp add figma --url https://mcp.figma.com/mcp --bearer-token-env-var FIGMA_OAUTH_TOKEN
codex mcp list                          # List all configured servers
codex mcp list --json                   # JSON output
codex mcp get context7                  # Show server config
codex mcp get context7 --json           # JSON output
codex mcp login <server>                # OAuth flow for HTTP servers
codex mcp logout <server>               # Remove OAuth credentials
codex mcp remove <server>               # Delete server definition

Innerhalb einer Sitzung zeigt /mcp aktive Server und verfügbare Tools an. /mcp verbose (v0.123.0+)⁸⁴ gibt vollständige Serverdiagnosen, Ressourcen und Ressourcenvorlagen zurück — hilfreich, wenn ein Server nicht geladen wird oder Tools nicht wie erwartet erscheinen. Einfaches /mcp bleibt schnell. Seit v0.144.0 können MCP-Tools interaktiv und ohne experimentelles Opt-in eine Authentifizierung anfordern — ein Server, der während der Sitzung Authentifizierung benötigt, fordert sie über den normalen Ablauf an, statt fehlzuschlagen, bis Sie sich mit codex mcp login vorab authentifizieren.¹⁰⁷

Das Laden von Plugin-MCPs (v0.123.0+) akzeptiert sowohl das Standardschema mcpServers als auch Server-Maps der obersten Ebene in .mcp.json, sodass Plugins, die nach einer der beiden Konventionen erstellt wurden, problemlos geladen werden.⁸⁴

Codex ALS MCP-Server ausführen

Codex kann sich für die Multi-Agent-Orchestrierung als MCP-Server 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 Freigabeparametern. 2. codex-reply(): Setzt eine bestehende Sitzung mit threadId und Prompt fort.

Mit dem Agents SDK (Python) verwenden:

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

Bemerkenswerte MCP-Server

Praktische Muster

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

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

Muster 2: Ausgabelimits — Antworten von MCP-Tools werden standardmäßig bei etwa 25.000 Zeichen gekürzt. Beschränken Sie bei Tools, die große Nutzdaten zurückgeben (Datenbankabfragen, Log-Aufzeichnungen), mit enabled_tools die Auswahl auf bestimmte Tools und halten Sie die Antworten fokussiert.

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

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

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

Jeder Server, der keiner Identität in requirements.toml entspricht, wird beim Start blockiert. Die vollständige Richtlinienkonfiguration finden Sie unter Enterprise-Bereitstellung.

Code-Modus [EXPERIMENTAL]

Der Code-Modus (v0.114.0) bietet stärker isolierte Coding-Workflows, indem er den Umfang des Agents auf codeorientierte Operationen beschränkt.⁷⁰ Wenn er aktiviert ist, konzentriert sich der Agent auf das Lesen, Schreiben und Testen von Code, ohne umfassendere Systeminteraktionen.

Seit v0.139.0 kann der Code-Modus eigenständige Websuchen direkt aufrufen — auch aus verschachtelten JavaScript-Tool-Aufrufen — und erhält Klartext-Ergebnisse. Dadurch kann ein Code-Modus-Ablauf aktuelle Informationen abrufen, ohne den abgeschotteten Coding-Kontext zu verlassen.¹²² v0.146.0 erweitert die eigenständige Websuche auf kompatible benutzerdefinierte Modellanbieter, sodass diese Fähigkeit nicht mehr auf von OpenAI gehostete Modelle beschränkt ist.¹¹⁴

v0.146.0 ermöglicht es dem App-Server, sich über WebSocket mit Remote-Code-Modus-Hosts zu verbinden, sodass die Code-Modus-Laufzeit nicht mehr auf demselben Rechner wie der Client laufen muss.¹¹⁴

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

JavaScript-REPL-Laufzeit [REMOVED]

Codex v0.100.0 führte eine experimentelle JavaScript-REPL-Laufzeit (js_repl) ein, und v0.106.0 machte sie über die Oberfläche /experimental verfügbar.⁶⁰ Diese Anleitung ist nun historisch. In v0.128.0 enthält das Release-Changelog „Remove js_repl feature“, und die aktuelle Funktionsliste kennzeichnet 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 Verzeichnis scripts/, wenn Sie wiederverwendbare ausführbare Logik benötigen.

Was sind Skills?

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

Skill-Struktur

my-skill/
  SKILL.md           (required: instructions)
  scripts/           (optional: executable scripts)
  references/        (optional: reference docs)
  assets/            (optional: images, icons)
  agents/openai.yaml (optional: metadata, UI, dependencies)

Speicherorte für die Erkennung

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

Einen Skill erstellen

SKILL.md-Format:

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

## Security Audit Procedure

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

Metadaten (agents/openai.yaml):

interface:
  display_name: "Security Audit"
  short_description: "Full codebase security review"
  icon_small: "./assets/shield.svg"
  brand_color: "#DC2626"
  default_prompt: "Run a security audit on this repository"

policy:
  allow_implicit_invocation: false    # Require explicit $skill

dependencies:
  tools:
    - type: "mcp"
      value: "snyk"
      transport: "streamable_http"
      url: "https://mcp.snyk.io/mcp"

Skills aufrufen

• Explizit: Über das /skills-Menü oder durch Erwähnung von $skill-name im Prompt
• Implizit: Codex erkennt anhand der Aufgabenbeschreibung automatisch passende Skills (wenn allow_implicit_invocation: true festgelegt ist)
• Creator: Mit $skill-creator können Sie interaktiv einen neuen Skill erstellen
• Installer: Mit $skill-installer install <name> können Sie Community-Skills installieren
• Vom Executor bereitgestellt (v0.146.0): Codex erkennt vom Executor angebotene Skills und liest die zugehörigen Ressourcen, einschließlich der von Ihnen ausdrücklich ausgewählten Skills¹¹⁴

Kontextbudgets können Skill-Kataloge kürzen. v0.146.0 behält bei knappem Kontext mehr verfügbare Skills bei und warnt, wenn ein Katalog gekürzt werden muss.¹¹⁴ Zuvor konnte eine große Skill-Bibliothek unbemerkt gekürzt werden, sodass ein erwarteter Skill schlicht nicht angeboten wurde. Wenn Sie bei vielen Skills auf den impliziten Aufruf angewiesen sind, achten Sie auf diese Warnung.

Aktivieren/Deaktivieren

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

Skills im Vergleich zu Slash Commands

Skills debuggen

Wenn ein Skill nicht aktiviert wird:

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

Praxisbeispiel: Deploy-Skill

Ein vollständiger, aus mehreren Dateien bestehender Skill, der das Zusammenspiel von Referenzen und Skripten veranschaulicht:

deploy-skill/
  SKILL.md
  references/
    runbook.md
    rollback-checklist.md
  scripts/
    pre-deploy-check.sh
    smoke-test.sh
  agents/openai.yaml

SKILL.md:

---
name: deploy
description: Deploy the application to staging or production. Runs pre-flight checks, executes deployment, and verifies with smoke tests.
---

## Deployment Procedure

### Pre-flight
1. Run `scripts/pre-deploy-check.sh` to verify:
   - All tests pass
   - No uncommitted changes
   - Branch is up to date with remote
2. Review the runbook at `references/runbook.md` for environment-specific steps.

### Deploy
3. Execute the deployment command for the target environment.
4. Monitor logs for errors during rollout.

### Verify
5. Run `scripts/smoke-test.sh <environment-url>` to confirm critical paths.
6. If smoke tests fail, follow `references/rollback-checklist.md`.

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

Plugins

Plugins vereinen Skills, MCP-Einträge, Hooks und App-Connectoren in einem einzigen installierbaren Paket (v0.110.0+).⁶⁵ Seit v0.117.0 sind Plugins fester Bestandteil: Produktbezogene Plugins werden beim Start automatisch synchronisiert, und /plugins bietet einen Browser innerhalb der TUI zur Entdeckung und Verwaltung.⁷⁵ v0.128.0 erweitert Plugin-Workflows um die Marketplace-Installation, Remote-Bundle-Caching, Remote-Deinstallations-APIs, mit Plugins gebündelte Hooks, den Aktivierungsstatus von Hooks und den Import externer Agent-Konfigurationen.⁸⁶ v0.129.0 (7. Mai 2026) ergänzt Plugin-Workspace-Freigaben (ein Plugin-Set für Teammitglieder bereitstellen, ohne es erneut zu veröffentlichen), Zugriffssteuerungen für Freigaben (Aktivierung/Deaktivierung pro Empfänger, Widerruf), Quellenfilterung (eingrenzen, aus welchen Marketplaces ein Workspace bezieht) sowie Marketplace-Operationen, die direkt im /plugins-Browser statt über die CLI aufgerufen werden können.⁸⁹ v0.133.0 (21. Mai 2026) erleichtert die Überprüfung der Plugin-Entdeckung: Die Listenausgabe berücksichtigt den Marketplace, installierte Versionen sind sichtbar, Marketplace-Stammverzeichnisse werden aufgelistet, 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 die Plugin-Paketierung transparenter und den Freigabe-Workflow besser steuerbar:⁹¹

• Gebündelte Hooks sind in den Plugin-Details sichtbar. Die Detailansicht von /plugins listet nun jeden Lifecycle-Hook auf, den ein Plugin bündelt (SessionStart, UserPromptSubmit, Stop usw.). Vor der Installation eines Plugins sehen Sie genau, welche Hooks es für Ihre Sitzung registriert — keine überraschenden Hook-Nebeneffekte mehr von einem Plugin, dem Sie allein wegen seiner Tools vertrauen.
• Plugin-Freigabemetadaten in shareContext. Wenn ein Plugin aus einem Workspace freigegeben wird, stellt die Nutzlast des Freigabelinks nun Linkmetadaten bereit (Ersteller, Umfang, Aktualität), damit empfangende Sitzungen die Herkunft anzeigen und entscheiden können, ob sie die Freigabe annehmen.
• Auffindbarkeitssteuerungen in den Freigabeeinstellungen. Die Freigabeeinstellungen bieten einen Schalter für die Auffindbarkeit, sodass Teams Plugins für bestimmte Workspaces oder Empfängerlisten veröffentlichen können, ohne sie in einer gesamten Organisation allgemein auflisten zu lassen.

v0.143.0 (8. Juli 2026) aktiviert Remote-Plugins standardmäßig. Remote-Plugins sind nun ohne Opt-in-Flag aktiviert, der /plugins-Katalog erhält umfangreichere Zeilen (npm-Marketplace-Quellen neben Git und lokalen Quellen), und jeder Eintrag zeigt sowohl seine Remote- als auch seine lokal installierte Version, sodass Abweichungen auf einen Blick sichtbar sind.¹⁰⁶ Für Teams, die sich auf ein gemeinsames Plugin-Set standardisieren, entfällt durch Remote-by-default der Aktivierungsschritt pro Maschine, der zuvor die Einführung blockierte.

Plugin-Quellen

Seit v0.147.0 umfasst die Plugin-Suche lokale, persönliche, Workspace- und Remote-Kataloge in einer Abfrage — Sie suchen nach einer Fähigkeit, nicht nach dem Katalog, der sie zufällig enthält. Zusammen mit portablen Agent-Plugin-Paketen lässt sich ein in einer Umgebung entwickeltes Plugin sauber in einer anderen installieren, statt an die Maschine oder den Workspace gebunden zu sein, in dem es erstellt wurde.¹¹⁶

Plugin-Entdeckung

Codex teilt dem Modell beim Sitzungsstart mit, welche Plugins aktiviert sind (v0.111.0), und verbessert damit die Entdeckung installierter MCPs, Apps und Skills.⁶⁵ Das Modell kann während einer Sitzung anhand des Aufgabenkontexts relevante Plugins vorschlagen. In v0.117.0 werden produktbezogene Plugins beim Start synchronisiert, sodass der aktuelle Plugin-Katalog ohne manuelles Eingreifen verfügbar ist.⁷⁵ Seit v0.142.0 organisiert das /plugins-Menü Remote-Plugins in den Bereichen OpenAI Curated, Workspace und Shared with me, und berechtigte Turns können relevante Plugins inline empfehlen und installieren.¹⁰⁴

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

Verweisen Sie im Chat mit @plugin-name direkt auf ein beliebiges installiertes 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/

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

Plugin-Marketplace (v0.113.0+)

Der Plugin-Marketplace umfasst nun eine umfangreichere Entdeckung mit Metadaten, Kategorien und Bewertungen.⁶⁹ Authentifizierungsprüfungen bei der Installation verifizieren, dass Plugins, die API-Schlüssel oder OAuth erfordern, vor der Installation über gültige Anmeldedaten verfügen. Ein Deinstallationsendpunkt 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. Damit wird die Plugin-Verteilung durch Drittanbieter über den First-Party-Marketplace von OpenAI hinaus formalisiert und GitHub-Repo-Kurzformen, HTTP(S)-Git-URLs, SSH-URLs sowie lokale Marketplace-Stammverzeichnisse werden unterstützt; verwenden Sie --ref, um eine Git-Referenz zu fixieren, und wiederholen Sie --sparse PATH nur für Git-basierte Marketplace-Repositories.⁹³

# 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 git@example.com: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 neben den Standard-Plugins im /plugins-Browser. Aufrufer des App-Servers (IDE-/Desktop-Integrationen) verfügen über einen parallelen Endpunkt, um Marketplaces programmgesteuert zu registrieren.⁸²

Sicherheitsaspekt: Drittanbieter-Marketplaces führen beliebigen Plugin-Code mit Ihren Codex-Berechtigungen aus. Prüfen Sie Quellen vor dem Hinzufügen und bevorzugen Sie bei den ersten Ausführungen eine Sandbox-Ausführung.

Agent Plugins: der herstellerübergreifende Standard (v0.146.0–v0.147.0)

„Agent Plugins“ ist nicht nur der Name einer Codex-Funktion — es ist ein offener, herstellerneutraler Paketierungsstandard, veröffentlicht als Agent Plugins 1.0.0 am 6. August 2026, dessen offizielle Website ihn als „A portable package format for reusable components that extend AI agents.“ zusammenfasst.¹¹⁸ Ein Plugin ist ein Verzeichnis mit einem erforderlichen plugin.json-Manifest (einem geschlossenen Schema mit genau zehn zulässigen Feldern der obersten Ebene — $schema, name, version, description, author, homepage, repository, license, keywords, extensions — wobei „Clients MUST report and ignore each unknown field“ gilt), einem optionalen Ordner skills/ (jedes unmittelbare Unterverzeichnis, das eine SKILL.md enthält, ist ein Skill), einer optionalen mcp.json, die stdio-, Streamable-HTTP- oder ältere HTTP+SSE-Server deklariert, sowie optionalen Client-Namespace-Verzeichnissen mit umgekehrter Domain, die andere Clients „MUST ignore“ müssen. Sein normativer Umfang ist die Paketierung: Die Spezifikation „defines the canonical Agent Plugins Specification v1.0.0 for packaging reusable components that extend AI agents into distributable plugins“ — Agent Skills und MCP behalten darunter ihre eigenen Spezifikationen.¹¹⁸

Die Governance ist dabei entscheidend. Vercel initiierte den Vorschlag und entwickelte die 1.0-Spezifikation gemeinsam mit Amazon, Anysphere (Cursor), GitHub, Microsoft und OpenAI; die Liste der Maintainer des Spezifikations-Repositorys umfasst Amazon, Cursor, Microsoft, OpenAI und Vercel, und Google kündigte am Veröffentlichungstag an, den Kern-Maintainern beizutreten.¹¹⁸ Zu den genannten Launch-Clients gehören ChatGPT, Codex, Cursor, GitHub Copilot, Kiro und VS Code. Eine auffällige Abwesenheit: Anthropic, das das zugrunde liegende Agent-Skills-Format und MCP selbst entwickelt hat, gehört nicht zu den Maintainerinnen und Maintainern — Claude Code behält sein eigenes Plugin-Format, und Codex überbrückt die Lücke auf seiner Seite mit der Claude Code-Marketplace-Quelle (v0.146.0) und /import.¹¹⁸

In Codex-Begriffen: v0.146.0 fügt Agent-Plugin-Manifeste, Workspace-Plugin-Veröffentlichung und zwei zusätzliche Plugin-Marketplaces hinzu — Amazon Bedrock und Claude Code¹¹⁴ — und v0.147.0 schließt den Kreislauf mit der Installation portabler Agent Plugins und der Suche über lokale, persönliche, Workspace- und Remote-Kataloge hinweg.¹¹⁶ Die Workspace-Veröffentlichung ist für Teams die operativ nützliche Hälfte: Veröffentlichen Sie Plugins in Ihrem eigenen Workspace, statt einen öffentlichen Marketplace bereitzustellen oder jeden Entwickler zu bitten, manuell eine Git-Quelle hinzuzufügen.

Die Release Notes kündigen die Codex-Oberflächen an, ohne ihre Konfigurationsschlüssel oder die CLI-Syntax zu veröffentlichen. Dieser Eintrag hält fest, dass die Funktion bereitgestellt wurde und was der Standard spezifiziert, nicht wie sie über Codex gesteuert wird — betrachten Sie den Workflow zum Erstellen von Manifesten und jeden Aufruf von codex plugin publish als unbestätigt, bis die OpenAI-Dokumentation sie behandelt.

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 bündeln, was früher separate MCP-Konfiguration, Skill-Installation und App-Connector-Einrichtung erforderte. Ein einzelnes Plugin kann alle drei enthalten — das beschleunigt das Onboarding von Teams und macht Konfigurationen portabler.

Plan Mode und Zusammenarbeit

Im Plan Mode kann Codex zunächst eine Vorgehensweise entwerfen, bevor Änderungen ausgeführt werden. Er ist standardmäßig aktiviert (seit v0.94.0).¹⁴ Unter Entscheidungsframeworks finden Sie den Entscheidungsbaum „Plan Mode vs. direkte Ausführung“.

Plan Mode aufrufen

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

Im Plan Mode führt Codex Folgendes aus: - Dateien lesen und die Codebasis analysieren - Einen Implementierungsplan vorschlagen - Keine Änderungen vornehmen, bis Sie zustimmen - Den Plan in einer eigenen TUI-Ansicht streamen

Steer Mode

Im Steer Mode (seit v0.98.0 standardmäßig aktiviert) können Sie Codex während der laufenden Arbeit neue Anweisungen geben, ohne die aktuelle Aufgabe zu unterbrechen.¹⁴

Dafür stehen 2 Eingabemethoden zur Verfügung:

Praxisbeispiele:

# Codex is refactoring the auth module...

[Enter] "Use bcrypt instead of argon2 — we already have it as a dependency"
→ Codex adjusts immediately, mid-turn

[Tab] "Once auth is done, update the migration script too"
→ Codex finishes auth refactor, then starts the migration

Der Steer Mode ist in der TUI immer aktiv. Wenn Sie lieber warten möchten, bis Codex seine Arbeit abgeschlossen hat, bevor Sie Anweisungen geben, tippen Sie nach Abschluss des Durchgangs einfach wie gewohnt – ein besonderer Modus ist nicht erforderlich.

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

Syntaxhervorhebung (v0.105.0): Die TUI hebt nun die Syntax eingezäunter Codeblöcke und direkt dargestellter Diffs hervor. Mit /theme können Sie ein Farbschema auswä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 eine Mikrofonberechtigung.⁶¹ Seit v0.107.0 unterstützen Echtzeit-Sprachsitzungen die Auswahl von Mikrofon und Lautsprecher, sodass Sie bestimmte Hardware für die Audioeingabe und -ausgabe festlegen können.⁶² In v0.140.0 entfernt, in v0.145.0 zurückgekehrt: Die experimentellen /realtime-Sprachsteuerelemente und ihre Audioabhängigkeiten wurden in v0.140.0 aus der TUI entfernt (die Sprachtranskription über die Leertaste blieb davon unberührt).¹⁰² Mit v0.145.0 kehrt die Sprachfunktion in neuer Form zurück: Audioeingaben und Ausgaben von Audio-Tools in gängigen lokalen Audioformaten sowie gestreamte Echtzeitunterhaltungen mit V3.¹¹²

Weitere Verbesserungen: - Lange Links bleiben nun auch dann anklickbar, wenn sie über mehrere TUI-Zeilen umgebrochen werden (v0.105.0)⁶¹ - Links zu lokalen Dateien werden mit verbesserter Formatierung dargestellt (v0.106.0)⁶⁰ - TUI-Markdown hält Weblinks über OSC-8-Metadaten anklickbar, während zu enge Tabellen auf lesbare Schlüssel/Wert-Datensätze zurückgreifen, ohne Linkziele zu verlieren (v0.136.0)¹²⁵ - Die Verarbeitung von Ctrl+C 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-Befehle

Erinnerungen werden in Markdown-Dateien unter ~/.codex/memory/ gespeichert. Codex lädt sie zu Beginn einer Sitzung und berücksichtigt sie in allen künftigen Sitzungen bei seinem Verhalten.

Was Sie speichern sollten

Erinnerungen eignen sich am besten für dauerhafte Präferenzen und Projektfakten:

• Projektkonventionen: „Dieses Projekt verwendet Tabulatoren statt Leerzeichen“ oder „API-Antworten enthalten immer ein meta-Feld“
• Tool-Präferenzen: „Verwenden Sie pnpm statt npm“ oder „Führen Sie Tests mit pytest -x --tb=short aus“
• Architekturentscheidungen: „Das Authentifizierungsmodul befindet sich in src/core/auth/, nicht in src/middleware/“
• Workflow-Präferenzen: „Führen Sie immer den Linter aus, bevor Sie mir einen Diff zeigen“

Memory in Pipelines

Beim Ausführen von codex exec werden Erinnerungen automatisch geladen. Dadurch profitieren CI/CD-Pipelines und Skripte vom selben Kontext wie interaktive Sitzungen – Sie müssen die Anweisungen nicht bei jedem Aufruf wiederholen.

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

• Bereinigung von Geheimnissen: Erinnerungen werden automatisch auf Geheimnisse geprüft, bevor sie auf die Festplatte geschrieben werden
• Berücksichtigung des CWD: Memory-Dateien enthalten nun den Kontext des Arbeitsverzeichnisses, um projektspezifische Erinnerungen abzurufen
• Ausschluss von Entwicklernachrichten: Entwickler- und Systemnachrichten werden von der Memory-Eingabe der 1. Phase ausgeschlossen, wodurch sich die Memory-Qualität verbessert, da Benutzerinteraktionen im Mittelpunkt stehen
• Diff-basiertes Vergessen (v0.106.0): Memory entfernt nun mithilfe Diff-basierten Vergessens veraltete Fakten, sodass der Memory-Speicher im Laufe der Zeit schlank und relevant bleibt⁶⁰
• Nutzungsbasierte Auswahl (v0.106.0): Der Memory-Abruf berücksichtigt nun die Nutzung und priorisiert häufig abgerufene sowie seit Kurzem relevante Erinnerungen⁶⁰
• Konfigurierbare Erinnerungen (v0.107.0): Erinnerungen sind nun vollständig konfigurierbar. Mit codex debug clear-memories können Sie alle gespeicherten Erinnerungen löschen und neu beginnen – praktisch, wenn Sie zwischen nicht zusammenhängenden Projekten wechseln oder der Memory-Status nicht mehr dem aktuellen Kontext entspricht⁶²
• Modellupgrade für Phase 2 (v0.121.0): Das Modell für die Memory-Konsolidierung der 2. Phase ist nun gpt-5.4 (anstelle des vorherigen Standardmodells). Die Pipeline der 2. Phase wird zwischen Sitzungen ausgeführt, um Transkripte der 1. Phase zu dauerhaften Fakten zu verdichten; der Modellwechsel verbessert die Erinnerungsqualität bei gleichen Token-Kosten.⁸²
• TUI-Menü für Erinnerungen (v0.121.0): Eine neue Benutzeroberfläche innerhalb der Sitzung bietet Zugriff auf den Memory-Modus, das Löschen einzelner Erinnerungen und eine Schaltfläche zum Zurücksetzen. Beim Zurücksetzen des Memory werden nun frühere Rollouts beibehalten, statt sie ungültig zu machen. So wird die künftig abrufbare Erinnerungsbasis geleert, ohne die Sitzungswiedergabe zu beeinträchtigen.⁸²

Memory im Vergleich zu AGENTS.md

Tipp: Verwenden Sie /m_update für Fakten, die dauerhaft erhalten bleiben sollen. Sitzungsspezifischen Kontext können Sie Codex einfach direkt in der Unterhaltung mitteilen. Für gemeinsam genutzten Teamkontext verwenden Sie AGENTS.md.

Sitzungsverwaltung

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

v0.146.0 macht Threads adressierbar. /new und /clear akzeptieren nun einen Sitzungsnamen, wichtige Threads können angeheftet werden, und Nebenunterhaltungen bleiben geöffnet, statt Sie dazu zu zwingen, eine Unterhaltung zu schließen, um eine andere zu erreichen.¹¹⁴ Praktisch bedeutet das, dass ein langfristiges Projekt nicht mehr aus einer Liste von Zeitstempeln besteht, die Sie am Datum erkennen müssen. v0.147.0 ergänzt Gesprächsabschnitte: Unterhaltungen werden in persistenten, manuell sortierten Abschnitten organisiert, und lange Transkripte werden schrittweise durchsucht, statt vollständig geladen zu werden.¹¹⁶

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-Befehl /resume innerhalb der TUI öffnet denselben interaktiven Auswahlassistenten mit Suche.

Paginierter Thread-Verlauf (v0.145.0) [EXPERIMENTAL]: Ein experimenteller, paginierter Thread-Verlauf ermöglicht effizientes Fortsetzen, die Suche im Verlauf, gespeicherte Thread-Namen, Sub-Agent-Unterstützung und Erinnerungen in der Sitzungsverwaltung — der Verlauf wird Seite für Seite statt vollständig auf einmal geladen, was bei langlebigen Arbeitsverzeichnissen mit Hunderten von Sitzungen wichtig ist. Experimentell: Rechnen Sie damit, dass sich die Oberfläche zwischen Releases verändert.¹¹²

Fork

Verzweigen Sie eine Unterhaltung, um Alternativen zu untersuchen, 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 denselben Verlauf teilen. Seit v0.146.0 ist der Fork-Verlauf paginiert, und Forks können temporär erstellt werden — ein temporärer Fork erscheint nicht in Thread-Listen, sodass verworfene Experimente nicht in der Thread-Liste auftauchen, in der Sie tatsächlich navigieren.¹¹⁴ Ä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-Agenten (v0.107.0): Threads können nun in unabhängige Sub-Agenten geforkt werden, sodass eine Unterhaltung parallele Arbeitsströme erzeugen kann, die autonom ausgeführt werden. Dies erweitert das bestehende Fork-Modell — statt nur die Unterhaltung zu verzweigen, wird der geforkte Thread zu einem Sub-Agenten mit eigenem Ausführungskontext.⁶² Seit v0.117.0 verwenden Sub-Agenten pfadbasierte Adressen (z. B. /root/agent_a) mit strukturierter Kommunikation zwischen Agenten, wodurch die Multi-Agent-Koordination expliziter und besser debugbar wird.⁷⁵

Verschlüsselte Nachrichten zwischen Agenten (v0.138.0+): Multi-agent v2 verschlüsselt jetzt den Aufgabentext, den ein übergeordneter Agent beim Starten oder beim Senden einer Nachricht an einen Sub-Agenten übermittelt. Die Nachrichtenparameter von spawn_agent, send_message und followup_task sind als verschlüsselt markiert: Die Responses API verschlüsselt die Nutzlast, wenn das übergeordnete Modell den Tool-Aufruf ausgibt, das lokal ausgeführte Codex transportiert nur Chiffretext (InterAgentCommunication.encrypted_content, mit leerem Klartextinhalt), und die API entschlüsselt ihn serverseitig, wenn sie ihn an das empfangende Modell übergibt.¹⁰⁸ Daraus ergeben sich drei praktische Konsequenzen:

• Ihre lokalen Sitzungsprotokolle enthalten keinen Klartext der Delegierung mehr. Sie können sehen, dass ein übergeordneter Agent einen Sub-Agenten gestartet hat und was zurückkam, aber nicht die exakte Anweisung, die er gesendet hat. Wenn Sie Multi-Agent-Ausführungen anhand des Sitzungsverlaufs prüfen oder debuggen, fehlt dieser Datensatz; das offene Regressionsticket dazu hatte Mitte Juli 2026 keinen verknüpften Fix.¹⁰⁹ Extension-Lebenszyklusereignisse (Start/Stopp von Sub-Agenten, Tool-Ausführung, Turn-Metadaten — v0.133.0+) und die App-Server-Beobachtbarkeit sind die verbleibenden Ansatzpunkte, um zu rekonstruieren, was geschehen ist.⁹⁸
• Modelle benutzerdefinierter Provider können fehlschlagen. Ein Modellendpunkt, der nicht für die Verwendung verschlüsselter Tools konfiguriert ist, weist das verschlüsselte spawn_agent-Schema mit einem 400-Fehler zurück ("declares encrypted parameters but is not configured for encrypted tool use"). Wenn die Multi-Agent-Delegierung bei einem benutzerdefinierten Provider mit diesem Fehler fehlschlägt, liegt das an der Verschlüsselungsänderung und nicht an Ihrer Konfiguration.¹⁰⁹
• Von Codex erzeugte Benachrichtigungen bleiben lesbar. Benachrichtigungen über den Abschluss von Child-Agenten werden von Codex selbst erzeugt, bleiben daher im Klartext und werden nun als typisierte agent_message-Elemente statt als serialisierte JSON-Umschläge gerendert.¹⁰⁸

OpenAI hat kein Bedrohungsmodell hinter dieser Änderung veröffentlicht; der PR beschreibt den Chiffretextfluss, ohne anzugeben, wovor er schützt.

Multi-agent v2 stabilisiert (v0.145.0, Opt-in): Die Multi-agent-v2-Erfahrung, die in v0.137.0 debütierte und in v0.138.0 verschlüsselte Delegierung erhielt, ist jetzt als Opt-in-Funktion stabilisiert. v0.145.0 ergänzt konfigurierbare Sub-Agent-Modelle, Reasoning-Stufen pro Sub-Agent, konfigurierbare Parallelität, wiederhergestellte Multi-Agent-Rollen und eine verbesserte Agentennavigation. Wenn Sie v2 während der Einführungsphase von v0.137/v0.138 zurückgestellt haben, ist dies das Release, in dem sich die Konfigurationsoberfläche stabilisiert — Modell- und Reasoning-Auswahl für Sub-Agenten befinden sich nun in der Konfiguration, statt von der Runtime festgelegt zu werden.¹¹²

Thread-Liste

Zeigen Sie aktive Sitzungen an und verwalten Sie sie:

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

In der Desktop-App sind Threads in der Seitenleiste mit vollständigem Verlauf und Diff-Vorschauen sichtbar.

Sitzungslebenszyklus

Sitzungen werden zwischen CLI und der Desktop-App synchronisiert — beginnen Sie in einer und setzen Sie in der anderen fort.

Nicht interaktiver Modus (codex exec)

codex exec führt Codex nicht interaktiv für Skripte, 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 Fortschrittsmeldungen/Ereignisse nach stderr und die abschließende Agent-Nachricht nach stdout. Dadurch lässt es sich mit standardmäßigen Unix-Pipelines kombinieren.

Sitzungsarchivierung (v0.136.0)

Sitzungen können archiviert werden, um die Liste zum Fortsetzen und Forken übersichtlich zu halten, ohne den Verlauf zu löschen. Archivieren Sie eine Sitzung in der TUI mit /archive oder über die Shell:¹²⁵

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

Eine archivierte Sitzung ist vor dem Fortsetzen oder Forken geschützt, bis Sie die Archivierung aufheben – eine Schutzmaßnahme dagegen, versehentlich eine Sitzung fortzuführen, die Sie eigentlich stilllegen wollten. Ebenfalls in dieser Version startet codex app-server --stdio den app-server im stdio-Modus für Editor-/Host-Integrationen, und /diff darf nun keine vom Repository bereitgestellten Git-Hilfsprogramme mehr ausführen (eine Verbesserung der Befehlssicherheit). Unter Windows ergänzt ein Alpha-Bereitstellungspfad für Administratoren codex sandbox setup --elevated.¹²⁵

Ausgabe im JSON-Zeilenformat

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 Antwortstruktur mit einem JSON Schema:

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

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

Sitzungen fortsetzen und überprüfen

codex exec resume --last "continue where you left off"
codex exec resume <SESSION_ID> "fix the remaining issues"
codex exec review --base main           # Code review against a branch

Wichtige Flags

CI-Authentifizierung

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

Startbanner von codex exec (v0.130.0). Das Startbanner von codex exec enthält nicht mehr die veraltete Formulierung „research preview“. Wenn Ihre CI die Startausgabe auswertet, fällt der Bannertext nun knapper aus; strukturierte --json-Ereignisse bleiben unverändert.⁹¹

codex remote-control (v0.130.0+)

codex remote-control ist ein Befehl auf oberster Ebene, der einen Headless-app-server startet, der von einem anderen Prozess gesteuert werden soll – etwa von IDE-Erweiterungen, benutzerdefinierten Orchestratoren oder Remote-Steuerungsebenen. Er ersetzt den Aufruf von codex app-server mit mehreren Flags, den viele Integratoren bislang manuell zusammensetzten, und bietet Drittanbieterwerkzeugen einen einzigen, stabilen Einstiegspunkt in dieselbe app-server-Laufzeit, die auch den Desktop- und IDE-Oberflächen zugrunde liegt.⁹¹ v0.133.0 verbessert das Laufzeitverhalten des Befehls: Er kann wie ein Vordergrundbefehl ausgeführt werden, auf die Betriebsbereitschaft warten, einen maschinenlesbaren Status melden und weiterhin explizite Daemon-Befehle vom Typ start / stop für langlebige Controller-Konfigurationen bereitstellen.⁹⁸ v0.143.0 ergänzt codex remote-control pair. Dieser Befehl erzeugt aus einem laufenden Daemon einen manuellen Kopplungscode, sodass sich ein Controller ohne den automatischen Erkennungs-Handshake verbinden kann – nützlich, wenn sich der steuernde Prozess auf einem anderen Host oder Netzwerksegment als der Daemon befindet.¹⁰⁶

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

# Generate a manual pairing code for an out-of-band controller (v0.143.0+)
codex remote-control pair

# 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 nachfolgend beschriebenen app-server-Paginierungs-APIs, wenn Sie Benutzeroberflächen entwickeln, die umfangreiche Thread-Verläufe auflisten müssen, ohne sämtliche Turns auf einmal in den Arbeitsspeicher zu laden.

app-server-Thread-Paginierung (v0.130.0+)

app-server-Clients können große Threads nun seitenweise über drei unterschiedliche Ansichten der Turn-Elemente abrufen:⁹¹

Kombinieren Sie die Paginierung mit der in v0.121.0 eingeführten ThreadStore-Schnittstelle, um langlebige Threads effizient zu durchlaufen. Das gilt insbesondere für Remote-Control-Bereitstellungen, bei denen sich der Orchestrator auf einem anderen Rechner als die Rollout-Dateien befinden kann.⁸² v0.143.0 erweitert die Inspektionsmöglichkeiten eines Controllers: app-server-Clients können nun verfügbare Umgebungen auflisten, die untergeordneten Threads eines Threads anzeigen und den Verlauf ab einem bestimmten Turn forken – genau die Grundlagen, die eine Benutzeroberfläche benötigt, um einen Lauf an einem früheren Punkt abzuzweigen, ohne ihn bis dorthin erneut abspielen zu müssen.¹⁰⁶

Live-Aktualisierung der app-server-Konfiguration (v0.130.0+)

Aktive app-server-Threads übernehmen Änderungen an config.toml nun ohne Neustart: Bearbeiten und speichern Sie die Konfiguration, damit der laufende Thread die neuen Werte bei seinem nächsten Turn verwendet. Diese Fehlerbehebung ergänzt codex remote-control: Ein langlebiger Headless-Server kann direkt im laufenden Betrieb neu konfiguriert werden, statt ihn herunterfahren und neu starten zu müssen.⁹¹

Verschlüsselte Remote-Ausführungsumgebungen (v0.141.0)

Seit v0.141.0 (stabil, 18. Juni 2026) stellen Remote-Ausführungsumgebungen Verbindungen über authentifizierte, Ende-zu-Ende-verschlüsselte Noise-Relay-Kanäle her. Die Steuerungsebene und die Ausführungsumgebung müssen dem dazwischenliegenden Relay daher nicht mehr vertrauen, was besonders relevant ist, wenn Ihr Orchestrator einen app-server über eine Netzwerkgrenze hinweg steuert. Dieselbe Version sorgt dafür, dass bei der plattformübergreifenden Remote-Ausführung das native Arbeitsverzeichnis und die native Shell der Ausführungsumgebung erhalten bleiben. Steuert ein Controller auf einem Betriebssystem eine Ausführungsumgebung auf einem anderen, werden Pfade und Shell-Semantik somit nicht mehr unbemerkt umgeschrieben. Für die Kompatibilität mit Unternehmens-Proxys akzeptiert TLS nun außerdem P-521-Zertifikatsignaturen.¹⁰³

Codex Cloud und Hintergrundaufgaben [EXPERIMENTAL]

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

Codex Cloud führt Aufgaben asynchron in von OpenAI verwalteten Umgebungen aus.⁴ Informationen zur Integration von Codex in Ihre CI-Pipeline finden Sie außerdem unter GitHub Action und CI/CD.

Funktionsweise

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

Internetzugriff in der Cloud

Der Internetzugriff des Agenten ist standardmäßig deaktiviert und wird für jede Umgebung separat konfiguriert:

• Aus: Kein Internetzugriff für den Agenten (Standard)
• Ein: Optionale Domain-Zulassungsliste und Beschränkungen für HTTP-Methoden

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

Einrichtungsskripte können weiterhin das Internet verwenden, um Abhängigkeiten zu installieren, selbst wenn der Internetzugriff des Agenten deaktiviert ist.

Slack-Integration

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

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

Codex antwortet mit einem Aufgabenlink und veröffentlicht 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 Benutzeroberflä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 laden Sie die App direkt herunter: Codex.dmg (macOS) | Im Microsoft Store erhältlich (Windows)

Hauptfunktionen

Appshots, Browserkommentare und Computer Use

Mit den App-Aktualisierungen vom 21. Mai wird die Desktop App zu einer umfassenderen Kontextoberfläche und dient nicht mehr nur der Thread-Verwaltung. Verwenden Sie Appshots, wenn Codex den Zustand einer anderen Mac-App kennen muss, bevor es handeln kann: Codex erfasst das vorderste Fenster sowie den von der App bereitgestellten sichtbaren und außerhalb des sichtbaren Bereichs liegenden Text und speichert den Anhang lokal im Sitzungsverlauf.⁹⁹

Verwenden Sie bei Web- und Frontend-Arbeiten zunächst den integrierten Browser, sofern für die Seite keine Anmeldung erforderlich ist: Er bietet Ihnen und Codex eine gemeinsame gerenderte Vorschau, unterstützt Browseraktionen wie Klicks, Screenshots, Asset-Downloads und die schreibgeschützte Prüfung von JavaScript und ermöglicht es Ihnen, Seitenbereiche mit Kommentaren zu markieren, die Codex im nächsten Vorgang bearbeiten kann.⁹⁹ Verwenden Sie für Websites mit Anmeldung weiterhin die Chrome-Erweiterung.

Verwenden Sie Computer Use nur, wenn sich die Aufgabe weder durch eine strukturierte Integration noch über die Browservorschau verifizieren lässt. Die Funktion kann zugelassene Mac-Apps prüfen und bedienen, übernimmt bei Dateiänderungen und Shell-Befehlen jedoch die Genehmigungs- und Sandbox-Regeln von Codex. Auch die Verwendung im gesperrten Zustand bleibt eng begrenzt: Während aktiver, vertrauenswürdiger Computer-Use-Vorgänge kann Codex nach dem Sperren des Mac vorübergehend auf zugelassene Apps zugreifen; dabei greifen Schutzmaßnahmen zum erneuten Sperren und zur Erkennung lokaler Eingaben.⁹⁹

Thread-Modi

Jeder Thread wird in einem von drei Modi ausgeführt, die Sie beim Erstellen auswählen:

Funktionsweise der Worktree-Isolation:

Wenn Sie einen Worktree-Thread starten, führt die Desktop App folgende Schritte aus: 1. Sie erstellt mit git worktree add einen neuen git-worktree in einem temporären Verzeichnis 2. Sie checkt auf Grundlage Ihres aktuellen HEAD einen neuen Branch aus 3. Sie führt den Agenten innerhalb des worktrees aus – sämtliche Dateiänderungen bleiben isoliert 4. Nach Abschluss zeigt sie eine Diff-Prüfung an, in der Sie auswählen, welche Änderungen zurückgeführt werden sollen

Dadurch können mehrere Worktree-Threads gleichzeitig und konfliktfrei im selben Repository ausgeführt werden. Jeder erhält einen eigenen Branch und ein eigenes Arbeitsverzeichnis.

Automatisierungen

Automatisierungen werden lokal in der App ausgeführt. Daher muss die App laufen und das Projekt auf dem Datenträger verfügbar sein:

• In Git-Repositorys verwenden Automatisierungen eigene Hintergrund-worktrees, die von Ihrem Arbeitsverzeichnis isoliert sind
• In Projekten ohne Git werden die Ausführungen direkt im Projektverzeichnis durchgeführt
• Automatisierungen verwenden Ihre standardmäßigen Sandbox-Einstellungen

Automatisierung einrichten: 1. Öffnen Sie ein Projekt in der Desktop App 2. Klicken Sie in der Seitenleiste auf die Registerkarte „Automatisierungen“ 3. Definieren Sie einen Auslöser (Zeitplan, Webhook oder manuell) 4. Verfassen Sie den Prompt und wählen Sie den Ausführungsmodus (lokal oder worktree) 5. Legen Sie die Reasoning-Stufe für die Automatisierungsausführung fest (App v26.312)⁷² 6. Automatisierungen werden planmäßig ausgeführt und stellen die Ergebnisse zur Prüfung in eine Warteschlange

Anwendungsbeispiele: - Issue-Triage: Neue Issues automatisch kategorisieren und priorisieren - CI-Überwachung: Build-Fehler überwachen und Korrekturen vorschlagen - Reaktion auf Warnmeldungen: Mit einer Diagnoseanalyse auf Überwachungswarnmeldungen reagieren - Abhängigkeitsaktualisierungen: Sicherheitspatches suchen und anwenden

Die Ergebnisse werden zur manuellen Genehmigung in einer Prüfwarteschlange angezeigt.

Windows-Unterstützung

Die Codex Desktop App wurde am 4. März 2026 (App v26.304) für Windows veröffentlicht. Sie bietet native PowerShell-Unterstützung, eine native Windows-Sandbox und den vollständigen Funktionsumfang einschließlich skills, Automatisierungen und worktrees, ohne WSL vorauszusetzen.⁶⁶

GitHub Action und 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 Text der abschließenden Codex-Antwort für nachgelagerte Schritte und Jobs.

Sicherheitsstrategien

Zugriffskontrollen

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

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

Codex SDK

Das TypeScript SDK integriert die Agent-Funktionen von Codex in benutzerdefinierte Anwendungen.¹⁹

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 Funktionen von SDK

• runStreamed(...): Asynchroner Ereignisstream für Zwischenaktualisierungen
• Python SDK-Authentifizierung (v0.132.0+): Anmeldung mit API-Schlüssel, ChatGPT-Browser-/Device-Code-Flows, Kontoprüfung und Abmeldung sind erstklassige SDK-Pfade.⁹⁷
• Vereinfachung für rein textbasierte Turns (v0.132.0+): Python-Turn-APIs akzeptieren einfache Strings und geben umfangreichere TurnResult-Metadaten mit erfassten Elementen, Zeitangaben und Nutzung zurück.⁹⁷
• outputSchema: Erzwingt eine finale Ausgabe im JSON-Format
• Multimodale Eingabe: Text + lokale Bilder übergeben ({ type: "local_image", path: "..." })
• Bild-Workflows (v0.117.0): view_image gibt URLs zurück, generierte Bilder können erneut geöffnet werden und der Bildverlauf bleibt beim Fortsetzen einer Sitzung erhalten⁷⁵
• view_image in mehreren Umgebungen (v0.130.0): Bei Sitzungen über mehrere Umgebungen hinweg (eingeführt in v0.124.0 mit Umgebungs- und Arbeitsverzeichnisauswahl pro Turn, verfeinert in v0.125.0 mit persistierenden Umgebungen) löst view_image Dateipfade nun über die ausgewählte Umgebung statt über das lokale Dateisystem des Orchestrators auf. Ein aus einer Remote-Umgebung angehängtes Bild wird relativ zum Arbeitsverzeichnis dieser Umgebung abgerufen, nicht vom Host, auf dem SDK ausgeführt wird.⁹¹

Thread- und Client-Konfiguration

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

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

Sitzungen werden unter ~/.codex/sessions gespeichert.

Laufzeitumgebung: Node.js 18+.

Leistungsoptimierung

Kontextverwaltung

Kontextfenster unterscheiden sich je nach Modell. Die aktuelle GPT-5.6-Familie (Sol, Terra, Luna) verwendet ein Fenster von 272K; GPT-5.5, das Flaggschiff der vorherigen Generation, bietet in Codex 400K (1M im API); GPT-5.4 / GPT-5.4-mini (werden ab dem 31. August 2026 aus Codex entfernt) bieten 1M / 400K; die ältere GPT-5.3-Codex-Familie verwendete 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-Dateien und lokale Dokumentation verringern den Rechercheaufwand (der Kontext verbraucht)
3. Verwenden Sie @, um bestimmte Dateien anzuhängen: Verweisen Sie direkt auf Dateien, statt Codex zu bitten, sie zu finden
4. Halten Sie Prompts fokussiert: Eingegrenzte Prompts mit exakten Dateien verbrauchen weniger Kontext als offene Recherche

Token-Effizienz

Geschwindigkeitsoptimierung

1. gpt-5.3-codex-spark: Variante mit geringerer Latenz für interaktives Pairing
2. --profile fast: Vorkonfiguriertes gpt-5.6-luna mit niedrigem 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, bei grünem Status stoppen“ statt um Schritt-für-Schritt-Anweisungen

Wie debugge ich Probleme?

Häufige Probleme und Lösungen

Referenz für Fehlermeldungen

Was macht codex doctor?

codex doctor ist der eine Befehl, den Sie ausführen sollten, bevor Sie einen Fehler melden oder eine defekte Installation debuggen. Er erfasst lokale Laufzeit, Konfiguration, Authentifizierung, Terminal, Netzwerk und Status in einem Bericht; auch die Issue-Vorlage des Projekts fordert Sie auf, seine Ausgabe einzufügen.¹²⁰

codex doctor                           # Full human-readable report (the default)
codex doctor --summary                 # Compact view
codex doctor --json                    # Redacted structured JSON, for bug reports
codex doctor --all                     # Expand truncated lists
codex doctor --no-color                # Strip ANSI color

Der Bericht ist in stabile Abschnitte gegliedert, sodass Sie direkt zum benötigten Abschnitt springen können:¹²⁰

Jede Prüfung enthält einen Statusmarker – ✓ ok, ✗ fehlgeschlagen, ⚠ Warnung, ○ inaktiv – sowie eine Zusammenfassungszeile. --json versieht jede Prüfung mit einer stabilen Kennung, wodurch der Befehl nicht nur visuell, sondern auch in CI oder einem Supportskript nutzbar ist.¹²⁰

Der Befehl wurde über mehrere Releases hinweg erweitert: Er erschien in v0.131.0, erhielt in v0.135.0 Berichte zu Umgebung, Git, Terminal, App-Server und Thread-Inventar und ergänzte in v0.139.0 Editor- und Pager-Details (mit geschwärzten vertraulichen Werten in JSON).^96126122

Verwenden Sie ihn zuerst, nicht zuletzt. Die meisten Meldungen „Codex ist kaputt“ lassen sich auf etwas zurückführen, das doctor bereits benennt: einen veralteten Authentifizierungsmodus, eine config.toml, die nicht geparst werden konnte, oder eine zweite Installation, die die auf Ihrem PATH überschattet.

Diagnosetools

codex doctor                           # Full local diagnostic (start here)
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 Flag der obersten Ebene. Verwenden Sie die Debug-Unterbefehle und die oben genannten TUI-Diagnosen.

Saubere Neuinstallation

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

~/.codex/ (Authentifizierung, Konfiguration, Sitzungen) bleibt erhalten. Informationen zum Anheften an eine exakte Version, zum Downgrade nach einem fehlerhaften Release oder zum vollständigen Löschen des Status finden Sie unter Aktualisieren, Downgrade oder Deinstallation.

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 startete am 6. März 2026 als Research Preview und bringt kontextbewusste Anwendungssicherheitsprüfungen in den Codex-Stack.⁷⁷ Es ist über Codex web für ChatGPT Pro-, Enterprise-, Business- und Edu-Kunden verfügbar.

So funktioniert es: Codex Security analysiert Repositorys, um ein projektspezifisches Bedrohungsmodell zu erstellen, identifiziert nach realen Auswirkungen klassifizierte Schwachstellen und testet die Ergebnisse unter Druck in einer Sandbox-Umgebung, um sie zu validieren. Der Agent zeigt verlässlichere Befunde samt Korrekturen an und reduziert dadurch das Rauschen unbedeutender Fehler.

Leistung: Während der Research Preview scannte Codex Security 1,2 Millionen Commits und identifizierte 10.561 schwerwiegende Schwachstellen. Die Präzision verbesserte sich im Zeitverlauf — das Rauschen sank um 84 %, überhöhte Schweregradangaben um mehr als 90 %, und die Rate falscher Positivmeldungen halbierte sich. Das System hat reale Schwachstellen in OpenSSH, GnuTLS und Chromium gefunden; 14 CVEs wurden vergeben.⁷⁷

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

Unternehmensbereitstellung

Administratorsteuerungen (requirements.toml)

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

v0.146.0 ergänzt die Erkennung von Enterprise-Plänen und Administratorsteuerungen für In-App-Updates.¹¹⁴ In einer verwalteten Flotte entscheidet dies darüber, ob Entwickler CLI selbst aktualisieren, sobald sie eine neue Version bemerken, oder ob der Administrator festlegt, wann eine Version ausgerollt wird. Die Release Notes kündigen die Steuerung an, ohne ihren requirements.toml-Schlüssel zu veröffentlichen — behandeln Sie den exakten Namen der Einstellung als unbestätigt, bis OpenAI ihn dokumentiert.

# /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änkungsebene, die begrenzt, welche Werte Benutzer auswählen können und die sie nicht überschreiben können. Administratoranforderungsregeln können nur zur Eingabe auffordern oder verbieten (niemals stillschweigend erlauben).

macOS-MDM-Konfiguration

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

Priorität (höchste bis niedrigste):

1. Verwaltete macOS-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; verwaltete Ebenen mit höherer Priorität haben daher stets Vorrang. Cloud-Anforderungen erfolgen nach bestem Bemühen; schlägt der Abruf fehl oder läuft er in ein Timeout, setzt Codex den Betrieb ohne die Cloud-Ebene fort.

OpenTelemetry-Integration

Codex unterstützt die Weitergabe des OpenTelemetry-Trace-Kontexts aus standardmäßigen OTel-Umgebungsvariablen bis hin 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, Servicename, Ressourcenattribute).
• Der Trace-Kontext wird durch Codex an API-Aufrufe weitergegeben und ermöglicht End-to-End-Beobachtbarkeit.
• Verwenden Sie Ressourcenattribute, um Traces nach Team, Umgebung oder Projekt zu kennzeichnen.
• Berücksichtigen Sie beim Aktivieren der Prompt-/Tool-Protokollierung die Datenschutzanforderungen — Traces können Codeausschnitte enthalten.
• Konfigurierbare OpenTelemetry-Trace-Metadaten (v0.130.0+). Zusätzlich zur standardmäßigen OTEL_RESOURCE_ATTRIBUTES-Hülle stellt die codex-otel-Crate jetzt konfigurierbare Trace-Metadaten bereit, sodass Administratoren Traces mit organisationsspezifischen Dimensionen (Kostenstelle, Projekt-ID, Ticketreferenz) versehen können, ohne bei jeder Ausführung OTEL_RESOURCE_ATTRIBUTES von Grund auf neu erstellen zu müssen. Kombinieren Sie dies mit den umfassenderen Analysefunktionen für Reviews und Feedback, die in derselben Version ausgeliefert wurden, um ein einheitliches Debugging und eine einheitliche Triage für CLI, app-server- und Remote-Control-Sitzungen zu ermöglichen.⁹¹

Enterprise-Zugang

• ChatGPT Business / Enterprise / Edu: Vom Organisationsadministrator gesteuerter Zugang mit automatisch angewendeten, aus der Cloud abgerufenen Anforderungen. Unterstützt SSO über SAML/OIDC durch Ihren Identitätsanbieter (Okta, Entra ID usw.).
• API: Standardmäßige API-Authentifizierung, Abrechnung sowie Organisations-/Projektsteuerungen. OpenAI veröffentlicht SOC-2-Type-II- und SOC-3-Berichte; für die Enterprise-Stufe ist ein HIPAA BAA verfügbar.
• Codex SDK: Integrieren Sie es 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-Ein- und Ausgaben werden gemäß den Business/Enterprise/API-Bedingungen von OpenAI nicht für das Training verwendet. - Für Datenresidenz wird OpenAI-API-Datenverkehr standardmäßig über US-basierte Infrastruktur geleitet; bei Anforderungen an die EU-Datenresidenz 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, darunter SOC 2, GDPR und CCPA.

Einführungsstrategie

Empfohlene schrittweise Einführung für Organisationen:

1. Pilotphase (Woche 1–2): Stellen Sie die Lösung für 3–5 erfahrene Ingenieure bereit, wobei requirements.toml den Sandbox-Modus untrusted und die Websuche cached erzwingt. Sammeln Sie Feedback zu AGENTS.md-Mustern und Anforderungen an MCP-Server.
2. Teamerweiterung (Woche 3–4): Rollen Sie die Lösung für das gesamte Team aus. Verteilen Sie das teamweite Standard-config.toml über MDM oder das Repository. Aktivieren Sie die Sandbox workspace-write 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 die Lösung über MDM bereit, wobei requirements.toml zugelassene MCP-Server, Sandbox-Richtlinien und Modell-Allowlists erzwingt.

Audit-Muster

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

• OpenTelemetry-Traces: Überwachen Sie API-Aufrufvolumen, Tokennutzung und Latenz pro Team.
• Sitzungsspeicherung: Prüfen Sie ~/.codex/sessions/ für Compliance-Reviews (deaktivieren Sie sie in sensiblen Kontexten mit --ephemeral).
• Durchsetzung der MCP-Identität: requirements.toml protokolliert blockierte Serverversuche — prüfen Sie diese auf nicht autorisierte Tool-Nutzung.
• Git-Audit-Trail: Alle Codex-Dateiänderungen durchlaufen standardmäßiges Git — prüfen Sie sie über den Branch-Verlauf und PR-Diffs.

Best Practices & Anti-Patterns

Prompting-Muster

1. Einschränkungsorientierte Prompts: Beginnen Sie mit den Grenzen. „Ändern Sie die Verträge von API NICHT. Refaktorieren Sie ausschließlich die interne Implementierung.“
2. Strukturierte Schritte zur Reproduktion: Nummerierte Schritte führen zu besseren Fehlerbehebungen als vage Beschreibungen
3. Verifizierungsanfragen: Schließen Sie mit „Führen Sie Lint sowie die kleinste relevante Test-Suite aus. Berichten Sie Befehle und Ergebnisse.“
4. Dateiverweise: Verwenden Sie @filename, um bestimmte Dateien an den Kontext anzuhängen
5. Ergebnisorientierte Schleifen: „Implementieren, Tests ausführen, Fehler beheben, erst stoppen, wenn alle Tests bestehen.“ Codex iteriert bis zum Abschluss

Testphilosophie

Die Community ist sich bei testgetriebener AI-Zusammenarbeit weitgehend einig:²²

• Definieren Sie Tests im Voraus als Abschlusssignale
• Lassen Sie Codex iterieren, bis die Tests bestehen (red → green → refactor)
• Übernehmen Sie Programmiermuster nach Tiger Style
• Stellen Sie beim Anfordern von Patches den exakten Dateitext bereit. Codex verwendet striktes Matching, kein unscharfes AST-basiertes Patching

Best Practices für Kontextverwaltung

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

Git-Workflow

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

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 Fehleranalyse und PR-Erstellung - github-pr-reviewer [pr-number]: Code-Review-Workflows - ui-engineer [requirements]: Frontend-Entwicklung in Produktionsqualität

Community-Skills: - claude-skill: Aufgaben mit Berechtigungsmodi an Claude Code übergeben - autonomous-skill: Aufgabenautomatisierung über mehrere Sitzungen mit Fortschrittsverfolgung - deep-research: Parallele Orchestrierung von Teilaufgaben - kiro-skill: Pipeline aus Anforderungen → Design → Aufgaben → Ausführung

Anti-Patterns

Häufige Fehler, die Tokens verschwenden, schlechte Ergebnisse liefern 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: Einrichtung eines neuen Projekts

mkdir my-app && cd my-app && git init
codex

> Create a FastAPI project with: main.py, requirements.txt, Dockerfile,
  basic health endpoint, and a README. Use async throughout.

> /init

Überprüfen Sie das generierte AGENTS.md, bearbeiten Sie es entsprechend Ihren Konventionen und führen Sie anschließend Folgendes aus:

> Run the health endpoint test and confirm it passes

Rezept 2: Täglicher Entwicklungsablauf

cd ~/project && git checkout -b feature/user-auth
codex

> @src/models/user.py @src/api/auth.py
  Add password reset functionality. Requirements:
  1. POST /api/auth/reset-request (email → sends token)
  2. POST /api/auth/reset-confirm (token + new password)
  3. Tests for both endpoints
  Run tests when done.

Prüfen Sie die Änderungen mit /diff und committen Sie 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.

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

[Tab] Also add a migration script using Alembic

Nachdem Codex die Ausführung abgeschlossen hat, verifizieren Sie:

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

Rezept 4: PR-Review mit codex exec

codex exec --model gpt-5.6-luna \
  "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."

Überprüfen Sie den Fortschritt später:

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

Wenden Sie die Fehlerbehebung nach Abschluss lokal an:

codex apply <TASK_ID>

Migrationsleitfaden

Von Claude Code

Wichtige Unterschiede:

• Die Sandbox läuft auf Betriebssystemebene: Codex verwendet Seatbelt/Landlock, keine Container. Die Einschränkungen greifen auf Kernel-Ebene unterhalb der Anwendungsebene.
• Hooks werden ausgebaut: Codex unterstützt inzwischen 5 Hook-Ereignisse: SessionStart, Stop und UserPromptSubmit (v0.114.0–v0.116.0, experimentell) sowie AfterAgent (v0.99.0) und AfterToolUse (v0.100.0). Das System deckt den Sitzungslebenszyklus, die Prompt-Abfanglogik und Automatisierung auf Tool-Ebene ab, auch wenn die mehr als 12 Lebenszyklusereignisse von Claude Code weiterhin breiter aufgestellt 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 Kommunikation zwischen Agents und Agent-Auflistung.⁷⁵ Damit wird die bestehende Infrastruktur erweitert (max. 6 gleichzeitig, von 12 in v0.91.0 reduziert). Multi-Agent-Rollen bleiben über die Konfiguration anpassbar (v0.104.0+).⁴⁷ v0.105.0 ergänzte spawn_agents_on_csv für Fanout über Zeilen hinweg, einschließlich Fortschrittsverfolgung und ETA.⁶¹ Codex verfügt weiterhin nicht über die explizite Task-Tool-UX von Claude Code für nutzergesteuerte Delegierung — verwenden Sie für Delegierungsmuster Cloud-Tasks oder SDK-Orchestrierung.
• AGENTS.md funktioniert werkzeugübergreifend: Ihre AGENTS.md funktioniert in Cursor, Copilot, Amp, Jules, Gemini CLI und mehr als 60.000 Open-Source-Projekten. CLAUDE.md ist ausschließlich für Claude.
• Profile ersetzen manuelles Umschalten: Statt Flags bei jedem Durchlauf zu ändern, definieren Sie Profile in config.toml.

Von GitHub Copilot

Das gewinnen Sie: - Sandbox auf Betriebssystemebene (Seatbelt/Landlock — vom Kernel erzwungen statt containerbasiert) - Delegierung von Cloud-Tasks mit codex apply - Konfigurationsprofile für Workflow-Wechsel - Desktop-App mit Worktree-Isolation

Von Cursor

Schnellreferenzkarte

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

Änderungsprotokoll