Codex CLI: The Definitive Technical Reference

Codex arbeitet als Multi-Surface-Coding-Agent, nicht als Chatbot, der Code schreibt. Das 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 in die Cloud. Es läuft lokal, denkt aber global — dieselbe Intelligenz treibt vier unterschiedliche Oberflächen an, je nachdem wie Sie arbeiten.

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

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

Ich habe Monate damit verbracht, Codex neben Claude Code in Produktionscodebases, CI/CD-Pipelines und Team-Workflows einzusetzen. Dieser Leitfaden destilliert diese Erfahrung in die umfassende Referenz, die ich mir gewünscht hätte, als ich angefangen habe. Jede Funktion enthält die tatsächliche Syntax, echte Konfigurationsbeispiele und die Grenzfälle, an denen selbst erfahrene Benutzer scheitern.

Hinweis zur Stabilität: Funktionen, die mit [EXPERIMENTAL] gekennzeichnet sind, können sich zwischen Releases ändern. Codex Cloud und die MCP-Befehlsgruppe sind seit v0.101.0 experimentell. Core CLI, Sandbox, AGENTS.md, config.toml und Skills sind stabil.

Wie Codex funktioniert: Das mentale Modell

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

┌─────────────────────────────────────────────────────────┐
│                    CODEX SURFACES                        │
├─────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │   CLI    │  │ Desktop  │  │   IDE    │  │ Cloud  │ │
│  │ Terminal │  │   App    │  │Extension │  │  Tasks │ │
│  └──────────┘  └──────────┘  └──────────┘  └────────┘ │
│  Local exec     Multi-task    Editor-native  Async      │
│  + scripting    + worktrees   + inline edits detached   │
├─────────────────────────────────────────────────────────┤
│  EXTENSION LAYER                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐   │
│  │   MCP   │  │ Skills  │  │  Apps   │  │  Search │   │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘   │
│  External tools, reusable expertise, ChatGPT            │
│  connectors, web search (cached + live)                  │
├─────────────────────────────────────────────────────────┤
│  SECURITY LAYER                                          │
│  ┌─────────────────────────────────────────────────┐    │
│  │    Sandbox (Seatbelt / Landlock / seccomp)      │    │
│  │    + Approval Policy (untrusted → never)        │    │
│  └─────────────────────────────────────────────────┘    │
│  OS-level filesystem + network restrictions              │
├─────────────────────────────────────────────────────────┤
│  CORE LAYER                                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │         GPT-5.x-Codex Intelligence              │    │
│  │   Tools: Shell, Patch, Read, Web Search         │    │
│  └─────────────────────────────────────────────────┘    │
│  Shared model across all surfaces; costs tokens          │
└─────────────────────────────────────────────────────────┘

Core Layer: Die GPT-5.x-Codex-Modellfamilie treibt alles an. Ab v0.101.0 ist gpt-5.3-codex das Standardmodell mit einem Kontextfenster von 272K Token. Es liest Dateien, schreibt Patches, führt Shell-Befehle aus und analysiert Ihre Codebasis. Wenn der Kontext voll ist, komprimiert Codex die Konversation, um Platz freizugeben. Diese Schicht verbraucht Token.

Security Layer: Jeder Befehl, den Codex ausführt, durchläuft eine Sandbox auf Betriebssystemebene. Unter macOS erzwingt Apples Seatbelt-Framework Einschränkungen auf Kernel-Ebene. Unter Linux filtern Landlock + seccomp den Dateisystem- und Syscall-Zugriff. Dies basiert nicht auf Containern — es ist direkt in das Betriebssystem integriert. Die Approval Policy entscheidet dann, wann eine menschliche Bestätigung angefordert wird.

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

Surface Layer: CLI für Terminal-Poweruser und Automatisierung. Codex Desktop App für Multi-Thread-Projektmanagement. IDE-Erweiterung für Edit-Compile-Test-Zyklen. Cloud für asynchrone Aufgaben, die unabhängig laufen.

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

Inhaltsverzeichnis

1. Wie installiere ich Codex?
2. Zentrale Interaktionsoberflächen
3. Konfigurationssystem im Detail
4. Welches Modell sollte ich wählen?
5. Entscheidungsrahmen
6. Wie funktioniert das Sandbox- & Genehmigungssystem?
7. Wie funktioniert AGENTS.md?
8. Was ist MCP (Model Context Protocol)?
9. Was sind Skills?
10. Plan Mode & Zusammenarbeit
11. Nicht-interaktiver Modus (codex exec)
12. Codex Cloud & Hintergrundaufgaben
13. Die Codex Desktop App
14. GitHub Action & CI/CD
15. Codex SDK
16. Was kostet Codex?
17. Leistungsoptimierung
18. Wie behebe ich Probleme?
19. Enterprise-Bereitstellung
20. Community-Tipps & Techniken
21. Migrationsleitfaden
22. Kurzreferenzkarte
23. Änderungsprotokoll
24. Referenzen

Wie installiere ich Codex?

Paketmanager

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

# Homebrew (macOS)
brew install --cask codex

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

Binäre Downloads

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

Systemanforderungen

• macOS: Apple Silicon oder Intel (volle Sandbox-Unterstützung über Seatbelt)
• Linux: x86_64 oder arm64 (Sandbox über Landlock + seccomp)
• Windows: Experimentell (WSL wird für volle Sandbox-Unterstützung empfohlen)²

Authentifizierung

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

Zwei Authentifizierungswege:

1. ChatGPT-Konto (empfohlen): Melden Sie sich mit Ihrem bestehenden Plus-, Pro-, Team-, Business-, Edu- oder Enterprise-Abonnement an. Voller Funktionsumfang inklusive Cloud-Aufgaben.
2. API Key: Über die Umgebungsvariable CODEX_API_KEY oder codex login --with-api-key einstellbar. Einige Funktionen (Cloud-Threads) sind möglicherweise nicht verfügbar.

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

Shell-Vervollständigung

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

Installation überprüfen

codex --version
# Codex CLI v0.101.0

Zentrale Interaktionsoberflächen

Codex bietet vier verschiedene Schnittstellen, die von derselben Intelligenz unterstützt werden. Jede Oberfläche ist für ein bestimmtes Workflow-Muster optimiert.

1. Interaktives CLI (Terminal UI)

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

Die TUI ist eine Vollbildanwendung mit:

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

Wichtige TUI-Tastenkombinationen:

Slash commands verfügbar in der TUI:

2. Codex Desktop App (macOS)

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

Die Codex Desktop App bietet Funktionen, die das CLI nicht hat:

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

Wann die App vs. CLI verwenden: Verwenden Sie die Codex Desktop App, wenn Sie mehrere Arbeitsströme koordinieren oder eine visuelle Diff-Ansicht benötigen. Verwenden Sie das CLI, wenn Sie Terminal-Komposierbarkeit, Skripting oder CI/CD-Integration wünschen.

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

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

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

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

4. Codex Cloud [EXPERIMENTELL]

Cloud-Aufgaben laufen asynchron in von OpenAI verwalteten Umgebungen:

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

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

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

Konfigurationssystem im Detail

Codex verwendet TOML für die Konfiguration. Das Verständnis der Prioritätshierarchie ist entscheidend — sie bestimmt, welche Einstellungen bei Konflikten gewinnen.

Priorität (höchste bis niedrigste)

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

Managed admin config fungiert als Richtlinien-Einschränkungsebene und kann Werte nach dem normalen Zusammenführen erzwingen oder verbieten. Siehe Enterprise-Bereitstellung.

Speicherorte der Konfigurationsdateien

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

Vollständige Konfigurationsreferenz

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.3-codex"                # Default model (272K context)
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_reasoning_effort = "medium"       # low|medium|high|xhigh (model-dependent)
model_reasoning_summary = "auto"        # auto|concise|detailed|none
model_verbosity = "medium"              # low|medium|high
personality = "pragmatic"               # none|friendly|pragmatic
review_model = "gpt-5.2-codex"         # Model for /review command
oss_provider = "lmstudio"              # lmstudio|ollama (used with --oss)

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

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

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

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

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

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

tool_output_token_limit = 10000         # Max tokens per tool output
log_dir = ""                            # Custom log directory

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

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

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

# ─── Feature Flags ─────────────────────────────────────
# Use `codex features list` for current names/stages/defaults.
[features]
shell_tool = true                       # Shell command execution (stable)
collaboration_modes = true              # Plan mode (stable)
personality = true                      # Personality selection (stable)
request_rule = true                     # Smart approvals (stable)
unified_exec = true                     # PTY-backed exec (stable)
shell_snapshot = true                   # Shell env snapshots (stable)
remote_models = true                    # Refresh remote model list (stable)
apps = false                            # ChatGPT Apps/connectors (experimental)
child_agents_md = false                 # AGENTS.md guidance (experimental)
runtime_metrics = false                 # Runtime summary in turns

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

Profile

Benannte Konfigurationsvorlagen für verschiedene Arbeitsmodi:

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

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

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

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

Ein Profil aktivieren:

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

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

Benutzerdefinierte Modellanbieter

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

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

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

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

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

Oder in der Konfiguration festlegen:

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

Inline-Konfigurationsüberschreibungen

Überschreiben Sie jeden Konfigurationswert direkt über die Befehlszeile:

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

Welches Modell sollte ich wählen?

Verfügbare Modelle (Februar 2026)

Die genaue Modellliste variiert je nach Konto und Rollout. Prüfen Sie Ihren lokalen Cache: ~/.codex/models_cache.json.

Flussdiagramm zur Modellauswahl

Is this a quick fix or simple question?
├─ Yes → gpt-5.1-codex-mini (fastest, cheapest)
└─ No
   ├─ Do you need real-time pairing speed?
   │  ├─ Yes → gpt-5.3-codex-spark (interactive, lower latency)
   │  └─ No
   │     ├─ Is this a multi-file refactor or migration?
   │     │  ├─ Yes → gpt-5.2-codex (272K context, strong at long tasks)
   │     │  └─ No → gpt-5.3-codex (default, best overall)
   └─ Still unsure? → gpt-5.3-codex

Reasoning-Aufwand

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

Die unterstützten Stufen sind modellabhängig. Nicht alle Modelle unterstützen jede Stufe.

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

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

Modellwechsel

Wechseln Sie Modelle während einer Sitzung mit dem /model-Slash-Befehl oder legen Sie es pro Ausführung über --model / -m fest:

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

Entscheidungsrahmen

Wann welche Oberfläche verwenden

Wann welchen Sandbox-Modus verwenden

Wann welche Reasoning-Stufe verwenden

Wie funktioniert das Sandbox- und Approval-System?

Codex verwendet ein zweischichtiges Sicherheitsmodell, das trennt, was technisch möglich ist, von wann menschliche Genehmigung erforderlich ist. Dies unterscheidet sich grundlegend vom Berechtigungssystem von Claude Code — Codex erzwingt Einschränkungen auf Ebene des Betriebssystem-Kernels.⁵

Schicht 1: Sandbox (Was ist möglich)

Die Sandbox steuert den Dateisystem- und Netzwerkzugriff mithilfe betriebssystemnativer Mechanismen:

Plattformspezifische Durchsetzung:

• macOS: Apples Seatbelt-Framework über sandbox-exec mit modusspezifischen Profilen, die zur Laufzeit kompiliert und vom Kernel durchgesetzt werden⁶
• Linux: Landlock für Dateisystem-Einschränkungen + seccomp für Syscall-Filterung. Ein eigenständiger Hilfsprozess (codex-linux-sandbox) bietet Defense-in-Depth-Isolierung. Optionale Bubblewrap-(bwrap-)Pipeline als Alternative verfügbar⁷
• Windows: Experimentelle native Sandbox mit eingeschränkten Tokens. WSL wird für vollständige Sandbox-Unterstützung empfohlen (erbt Linux Landlock + seccomp)

Warum das wichtig ist: Im Gegensatz zu Container-basiertem Sandboxing (Docker) ist Sandboxing auf Betriebssystemebene schneller, leichtgewichtiger und schwerer zu umgehen. Der Kernel erzwingt Einschränkungen, bevor Codex den Systemaufruf überhaupt sieht.

Schicht 2: Approval Policy (Wann wird gefragt)

Die Approval Policy bestimmt, wann Codex pausiert, um eine menschliche Bestätigung einzuholen:

Das --full-auto-Flag

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

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

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

Empfohlene Konfigurationen

Tägliche Entwicklung (sicherer Standard):

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

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

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

Dies ist der von der Community empfohlene „Sweet Spot” — maximale Fähigkeit, aber Genehmigung für jeden Befehl erforderlich.⁹

CI/CD-Automatisierung:

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

Netzwerkzugriff aktivieren

Das Netzwerk ist im workspace-write-Modus standardmäßig blockiert. Aktivieren Sie es 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

Sandbox testen

Überprüfen Sie das Sandbox-Verhalten, bevor Sie sich darauf verlassen:

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

Wie funktioniert AGENTS.md?

AGENTS.md ist das Projektanweisungssystem von Codex — ein offener Standard¹⁰, der von Codex, Cursor, Amp, Jules (Google) und Factory unterstützt wird. Es definiert, wie sich Codex innerhalb eines bestimmten Repositories oder Verzeichnisses verhalten soll.

Erkennungshierarchie

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

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

~/.codex/AGENTS.md                     ← Global defaults
  └─ /repo/AGENTS.md                   ← Project-wide rules
      └─ /repo/services/AGENTS.md      ← Service-specific rules
          └─ /repo/services/payments/
               AGENTS.override.md      ← Overrides everything above for this dir

Was eine großartige AGENTS.md ausmacht

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

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

VERMEIDEN: - Komplette Style-Guides ohne Ausführungsregeln einfügen - Mehrdeutige Anweisungen verwenden („sei vorsichtig”, „optimiere”) - Widersprüchliche Prioritäten mischen (Geschwindigkeit + erschöpfende Überprüfung + kein Laufzeitbudget) - Prosa-Dokumentation schreiben — AGENTS.md ist operative Richtlinie, nicht README

Beispiel: Produktions-AGENTS.md

# Repository Guidelines

## Build, Test, and Development Commands
- Run API (dev): `python3 -m uvicorn main:app --reload`
- Install deps: `pip install -r requirements.txt`
- Lint: `python3 -m ruff check .` (auto-fix: `--fix`)
- Format: `python3 -m ruff format .`
- Tests: `python3 -m pytest -v`
- Coverage: `python3 -m pytest --cov=app --cov-report=term-missing`

## Coding Style & Naming Conventions
- Python 3.11+. Type hints on all functions.
- Ruff enforced: 88-char lines, double quotes, spaces for indent.
- Naming: modules `snake_case.py`, classes `PascalCase`, functions `snake_case`.

## Commit & Pull Request Guidelines
- Conventional Commits: `feat:`, `fix:`, `docs:`, `refactor:`, `chore:`, `test:`
- Commits should be small and focused.
- PRs must include: description, test plan, and screenshots for UI changes.

## Security
- Never commit secrets. Use `.env` for local config.
- Validate all external API calls with proper error handling.

Der Override-Mechanismus

AGENTS.override.md auf jeder Verzeichnisebene ersetzt die normale AGENTS.md für diesen Geltungsbereich. Verwenden Sie es für:

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

Konfiguration

# Custom fallback filenames (in addition to AGENTS.md)
project_doc_fallback_filenames = ["TEAM_GUIDE.md", ".agents.md"]

# Increase max size for large instruction files
project_doc_max_bytes = 65536    # 64 KiB (default: 32 KiB)

Scaffold-Generierung

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

Oder überprüfen Sie Ihre Anweisungskette:

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

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

MCP erweitert die Fähigkeiten von Codex durch die Anbindung an externe Tools und Dienste. 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).¹²

MCP-Server konfigurieren

STDIO-Server (lokale Prozesse):

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

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

HTTP-Server (Remote):

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

CLI-Verwaltung

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

In der Sitzung: /mcp zeigt aktive Server und verfügbare Tools an.

Codex ALS MCP-Server ausführen

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

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

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

Verwendung mit dem Agents SDK (Python):

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

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

Bemerkenswerte MCP-Server

Was sind Skills?

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

Skill-Struktur

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

Erkennungsorte

Vom Benutzer installierte Skills werden in $CODEX_HOME/skills verwaltet (Standard: ~/.codex/skills), einschließlich eingebauter System-Skills unter .system/. Codex unterstützt symbolisch verknüpfte Skill-Ordner.

Einen Skill erstellen

SKILL.md-Format:

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

## Sicherheitsaudit-Verfahren

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

Metadaten (agents/openai.yaml):

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

policy:
  allow_implicit_invocation: false    # Require explicit $skill

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

Skills aufrufen

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

Aktivieren/Deaktivieren

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

Plan Mode & Zusammenarbeit

Plan Mode ermöglicht es Codex, einen Ansatz zu entwerfen, bevor Änderungen ausgeführt werden. Er ist standardmäßig aktiviert (seit v0.94.0).¹⁵

Plan Mode aktivieren

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

Im Plan Mode führt Codex folgende Schritte aus: - Liest Dateien und analysiert die Codebasis - Schlägt einen Implementierungsplan vor - Nimmt keine Änderungen vor, bis Sie zustimmen - Streamt den Plan in einer dedizierten TUI-Ansicht

Steer Mode

Steer Mode (standardmäßig aktiviert seit v0.98.0) ermöglicht es Ihnen, neue Anweisungen einzufügen, während Codex arbeitet:

• Enter: Sendet Anweisungen sofort während eines laufenden Durchgangs
• Tab: Reiht eine Folgeanweisung ein, die nach Abschluss des aktuellen Durchgangs ausgeführt wird

Dies ermöglicht Kurskorrektur in Echtzeit, ohne den Agenten anzuhalten.

Konversationen forken

Forken Sie Konversationen, um Alternativen zu erkunden, ohne Ihren aktuellen Fortschritt zu verlieren:

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

Forks erstellen unabhängige Threads — Änderungen in einem Fork beeinflussen den anderen nicht.

Nicht-interaktiver Modus (codex exec)

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

Grundlegende Verwendung

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

Standardmäßig schreibt codex exec Fortschritt/Ereignisse nach stderr und die finale Agenten-Nachricht nach stdout. Dies macht es kompatibel mit Standard-Unix-Pipelines.

JSON Lines-Ausgabe

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

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

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

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

Strukturierte Ausgabe

Erzwingen Sie die Antwortstruktur mit JSON Schema:

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

-o / --output-last-message speichert die finale Nachricht in einer Datei.

Sitzung fortsetzen und überprüfen

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

Wichtige Flags

CI-Authentifizierung

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

Codex Cloud & Hintergrundaufgaben [EXPERIMENTELL]

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

Codex Cloud führt Aufgaben asynchron in von OpenAI verwalteten Umgebungen aus.⁴

Funktionsweise

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

Internetzugriff in der Cloud

Der Internetzugriff des Agenten ist standardmäßig deaktiviert und wird pro Umgebung konfiguriert:

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

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

Setup-Skripte können weiterhin das Internet nutzen, um Abhängigkeiten zu installieren, auch 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-Plan (Plus, Pro, Business, Enterprise oder Edu) 2. Verbundenes GitHub-Konto 3. Mindestens eine konfigurierte Cloud-Umgebung 4. Slack-App für Ihren Workspace installiert

Codex antwortet mit einem Aufgaben-Link und postet 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 (nur macOS, Apple Silicon) bietet eine grafische Oberfläche, die für die Verwaltung mehrerer Projekte optimiert ist.¹⁷

Installation

codex app                      # Auto-downloads and installs on first run

Oder direkt herunterladen: Codex.dmg

Hauptfunktionen

Automations

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

• In Git-Repos verwenden Automations dedizierte Hintergrund-Worktrees
• In Nicht-Git-Projekten werden Ausführungen direkt im Projektverzeichnis durchgeführt
• Automations verwenden Ihre Standard-Sandbox-Einstellungen

Beispiel-Anwendungsfälle: - Issue-Triage: Neue Issues automatisch kategorisieren und priorisieren - CI-Überwachung: Build-Fehler beobachten und Korrekturen vorschlagen - Alert-Reaktion: Auf Monitoring-Alerts mit diagnostischer Analyse reagieren - Abhängigkeitsaktualisierungen: Sicherheitspatches prüfen und anwenden

Ergebnisse erscheinen in einer Überprüfungswarteschlange zur menschlichen Genehmigung.

Windows-Unterstützung

Die Windows-Alpha-Testphase begann im Februar 2026. Melden Sie sich auf openai.com für einen frühen Zugang an.¹⁸

GitHub Action & CI/CD

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

Grundlegende Verwendung

# .github/workflows/codex.yml
name: Codex
on:
  pull_request:
    types: [opened]

jobs:
  codex:
    runs-on: ubuntu-latest
    outputs:
      final_message: ${{ steps.run_codex.outputs.final-message }}
    steps:
      - uses: actions/checkout@v5
      - name: Run Codex
        id: run_codex
        uses: openai/codex-action@v1
        with:
          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
          prompt-file: .github/codex/prompts/review.md
          sandbox: workspace-write
          safety-strategy: drop-sudo

Konfigurationsoptionen

Ausgabe: final-message — finaler Codex-Antworttext für nachfolgende Schritte/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 bettet die Agentenfähigkeiten von Codex in benutzerdefinierte Anwendungen ein.²⁰

Installation

npm install @openai/codex-sdk

Grundlegende Verwendung

import { Codex } from "@openai/codex-sdk";

const codex = new Codex();
const thread = codex.startThread();

// Multi-turn conversation
const turn1 = await thread.run("Diagnose CI failures and propose a fix");
console.log(turn1.finalResponse);

const turn2 = await thread.run("Implement the fix and add tests");
console.log(turn2.items);

// Resume a previous session
const resumed = codex.resumeThread("<thread-id>");
await resumed.run("Continue from previous work");

Erweiterte SDK-Funktionen

• runStreamed(...): Asynchroner Event-Stream für Zwischenmeldungen
• outputSchema: Erzwingt JSON-strukturierte Endausgabe
• Multimodale Eingabe: Übergeben Sie Text und lokale Bilder ({ type: "local_image", path: "..." })

Thread- und Client-Konfiguration

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

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

Sitzungen werden unter ~/.codex/sessions gespeichert.

Laufzeitumgebung: Node.js 18+.

Was kostet Codex?

Zugang über ChatGPT-Pläne

Die Verfügbarkeit von Codex hängt von Ihrem ChatGPT-Plan und den Organisationseinstellungen ab:

Planlimits und Durchsatz können sich ändern. Prüfen Sie die aktuellen Berechtigungen in ChatGPT und Ihren Admin-Einstellungen.

API-Abrechnung

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

Strategien zur Kostenoptimierung

1. Profile verwenden: Erstellen Sie ein fast-Profil mit gpt-5.1-codex-mini und model_reasoning_effort = "low" für Routineaufgaben
2. Hohe Reasoning-Stufen gezielt einsetzen: Verwenden Sie xhigh nur für wirklich schwierige Probleme — der Tokenverbrauch ist 3–5× höher
3. --ephemeral verwenden: Überspringen Sie die Sitzungspersistenz in CI/CD, um den Overhead zu reduzieren
4. Reasoning-Zusammenfassungen minimieren: Setzen Sie model_reasoning_summary = "none", wenn Sie keine Erklärungen benötigen
5. Batch-Verarbeitung mit exec-Modus: codex exec vermeidet den TUI-Overhead bei Automatisierungsworkflows
6. Verbrauch überwachen: Prüfen Sie /status in der TUI und die Abrechnungs-Dashboards Ihrer Organisation

Leistungsoptimierung

Kontextmanagement

Die Flaggschiff-Modelle verfügen über 272K-Kontextfenster, die sich jedoch schneller füllen, als man denkt. Verwalten Sie diese proaktiv:

1. /compact regelmäßig verwenden: Fasst den Gesprächsverlauf zusammen, um Token freizugeben
2. Lokale Dokumentation bereitstellen: Hochwertige AGENTS.md-Dateien und lokale Dokumentation reduzieren den Erkundungsaufwand (der Kontext verbraucht)
3. @ zum Anhängen bestimmter Dateien verwenden: Referenzieren Sie Dateien direkt, anstatt Codex suchen zu lassen
4. Prompts fokussiert halten: Zielgerichtete Prompts mit genauen Dateiangaben verbrauchen weniger Kontext als offene Erkundungen

Token-Effizienz

Geschwindigkeitsoptimierung

1. gpt-5.3-codex-spark: Variante mit geringerer Latenz für interaktives Pair-Programming
2. --profile fast: Vorkonfiguriertes Mini-Modell mit niedrigem Reasoning
3. Parallele Tool-Ausführung: Codex führt unabhängige Lese-/Prüfvorgänge gleichzeitig aus — strukturieren Sie Prompts entsprechend
4. Ergebnisorientierte Schleifen: Bitten Sie um „implementieren, testen, Fehler beheben, erst bei Grün stoppen” statt schrittweiser Anweisungen

Wie debugge ich Probleme?

Häufige Probleme und Lösungen

Diagnose-Tools

codex --version                        # Check CLI version
codex login status                     # Verify authentication
codex mcp list                         # Check MCP server status
codex debug app-server --help          # Debug app server issues

TUI-Diagnosebefehle innerhalb einer Sitzung:

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

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

Neuinstallation

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

Debug-Modus

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

Probleme melden

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

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

Unternehmensbereitstellung

Admin-Steuerung (Managed Admin Config)

Unternehmensrichtlinien werden über managed admin config (Systemebene) durchgesetzt, die sichere Ausführungsmodi erzwingen und Benutzereinstellungen einschränken kann:²²

# /etc/codex/managed-admin-config.toml

model_reasoning_effort = "high"
model_reasoning_summary = "auto"
model = "gpt-5.3-codex"

require_approval = "untrusted"
require_sandbox = "workspace-write"

Managed admin config fungiert als Einschränkungsebene — sie erzwingt oder verbietet Werte nach dem normalen Zusammenführen der Konfiguration, nicht nur als weitere Override-Stufe.

macOS-MDM-Konfiguration

Verteilung über MDM mit der Präferenz-Domain com.openai.codex:

OpenTelemetry-Integration

Codex unterstützt die Weitergabe von OpenTelemetry-Trace-Kontext aus Standard-OTel-Umgebungsvariablen bis hin zu OpenAI-API-Aufrufen. Konfigurieren Sie OTel in Ihrem Laufzeit-/Collector-Stack:

• Standard-OTEL_*-Umgebungsvariablen werden berücksichtigt
• Der Trace-Kontext wird durch Codex bis zu den API-Aufrufen weitergegeben
• Beachten Sie die Datenschutzanforderungen beim Aktivieren der Prompt-/Tool-Protokollierung

Unternehmenszugang

• ChatGPT Business / Enterprise / Edu: Vom Organisations-Admin gesteuerter Zugang
• API: Standard-API-Authentifizierung, Abrechnung und Organisations-/Projektsteuerung
• Codex SDK: Einbettung in interne Tools und Workflows
• Managed Config: Verwenden Sie managed config + managed admin config zur skalierten Richtliniendurchsetzung

Community-Tipps und Techniken

Prompting-Muster

1. Einschränkungsorientierte Prompts: Beginnen Sie mit Grenzen — „Ändere NICHT die API-Verträge. Refaktoriere nur die interne Implementierung.”
2. Strukturierte Reproduktionsschritte: Nummerierte Schritte führen zu besseren Fehlerbehebungen als vage Beschreibungen
3. Verifizierungsanfragen: Schließen Sie mit „Führe Lint und die kleinste relevante Test-Suite aus. Berichte Befehle und Ergebnisse.”
4. Dateireferenzen: 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 bestanden sind” — Codex iteriert, bis alles fertig ist

Testing-Philosophie

Die Community konvergiert auf testgetriebene KI-Zusammenarbeit:²³

• Tests vorab als Abschlusssignale definieren
• Codex iterieren lassen, bis die Tests bestehen (Rot → Grün → Refaktorierung)
• Tiger Style-Programmiermuster anwenden
• Exakten Dateitext bei Patch-Anfragen bereitstellen — Codex verwendet striktes Matching, kein unscharfes AST-basiertes Patching

Best Practices für Kontextmanagement

• Hochwertige lokale Dokumentation bereitstellen, statt sich auf Websuche zu verlassen
• Strukturiertes Markdown mit Inhaltsverzeichnissen und Fortschrittsdateien pflegen („Progressive Disclosure”)
• Zeilenenden (LF vs. CRLF) in versionierten Dateien normalisieren, um Patch-Fehler zu vermeiden
• AGENTS.md knapp halten — lange Anweisungen werden aus dem Kontext verdrängt

Git-Workflow

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

Community Skills und Prompts

Das Repository feiskyer/codex-settings bietet praxiserprobte Konfigurationen:²⁴

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

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

Migrationsleitfaden

Von Claude Code

Wichtige Unterschiede:

• Sandbox auf Betriebssystemebene: Codex verwendet Seatbelt/Landlock, keine Container. Einschränkungen sind schwerer zu umgehen.
• Keine Hooks: Codex hat keine direkte 1:1-Entsprechung zu Claude Code-Hooks. Verwenden Sie stattdessen AGENTS.md-Anweisungen oder skills.
• Keine Subagents: Codex hat kein direktes lokales 1:1-Subagent-Modell. Verwenden Sie Cloud-Aufgaben oder SDK-Orchestrierung für Delegierung.
• AGENTS.md ist toolübergreifend: Ihre AGENTS.md funktioniert auch in Cursor, Amp und Jules. CLAUDE.md ist ausschließlich für Claude.
• Profile ersetzen manuelles Umschalten: Anstatt Flags pro Ausführung zu ändern, definieren Sie Profile in config.toml.

Von GitHub Copilot

Was Sie gewinnen: - Volle agentische Fähigkeiten (Dateibearbeitung, Befehlsausführung, Git-Operationen) - Delegierung von Cloud-Aufgaben - Sandboxing auf Betriebssystemebene - MCP-Integrationen

Von Cursor

Kurzreferenzkarte

╔═══════════════════════════════════════════════════════════════╗
║                    CODEX CLI QUICK REFERENCE                  ║
╠═══════════════════════════════════════════════════════════════╣
║                                                               ║
║  LAUNCH                                                       ║
║  codex                      Interactive TUI                   ║
║  codex "prompt"             TUI with initial prompt           ║
║  codex exec "prompt"        Non-interactive mode              ║
║  codex app                  Desktop app                       ║
║  codex resume               Resume previous session           ║
║  codex fork                 Fork a session                    ║
║                                                               ║
║  FLAGS                                                        ║
║  -m, --model <model>        Select model                      ║
║  -p, --profile <name>       Load config profile               ║
║  -s, --sandbox <mode>       Sandbox mode                      ║
║  -C, --cd <dir>             Working directory                 ║
║  -i, --image <file>         Attach image(s)                   ║
║  -c, --config <key=value>   Override config                   ║
║  --full-auto                workspace-write + on-request      ║
║  --oss                      Use local models (Ollama)         ║
║  --search                   Enable live web search            ║
║                                                               ║
║  SLASH COMMANDS (in TUI)                                      ║
║  /compact      Free tokens   /diff        Git diff            ║
║  /review       Code review   /plan        Plan mode           ║
║  /model        Switch model  /status      Session info        ║
║  /fork         Fork thread   /init        AGENTS.md scaffold  ║
║  /mcp          MCP tools     /skills      Invoke skills       ║
║  /ps           Background    /personality Style               ║
║  /permissions  Approval mode /statusline  Footer config       ║
║                                                               ║
║  TUI SHORTCUTS                                                ║
║  @              Fuzzy file search                             ║
║  !command       Run shell command                             ║
║  Ctrl+G         External editor                               ║
║  Enter          Inject instructions (while running)           ║
║  Esc Esc        Edit previous messages                        ║
║                                                               ║
║  EXEC MODE (CI/CD)                                            ║
║  codex exec --full-auto "task"          Sandboxed auto        ║
║  codex exec --json -o out.txt "task"    JSON + file output    ║
║  codex exec --output-schema s.json      Structured output     ║
║  codex exec resume --last "continue"    Resume session        ║
║                                                               ║
║  MCP MANAGEMENT [experimental]                                ║
║  codex mcp add <name> -- <cmd>    Add STDIO server            ║
║  codex mcp add <name> --url <u>   Add HTTP server             ║
║  codex mcp list                    List servers                ║
║  codex mcp login <name>           OAuth flow                  ║
║  codex mcp remove <name>          Delete server               ║
║                                                               ║
║  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             ║
║  managed-admin-config.toml   Enterprise policy constraints    ║
║                                                               ║
║  SANDBOX MODES                                                ║
║  read-only          Read files only, no mutations             ║
║  workspace-write    Read/write in workspace + /tmp            ║
║  danger-full-access Full machine access                       ║
║                                                               ║
║  APPROVAL POLICIES                                            ║
║  untrusted     Prompt for all mutations                       ║
║  on-failure    Auto-run until failure                         ║
║  on-request    Prompt for boundary violations                 ║
║  never         No prompts                                     ║
║                                                               ║
║  MODELS (Feb 2026)                                            ║
║  gpt-5.3-codex         Default flagship (272K)               ║
║  gpt-5.3-codex-spark   Interactive, lower latency (128K)     ║
║  gpt-5.2-codex         Long-horizon refactors (272K)         ║
║  gpt-5.1-codex-mini    Quick tasks, cost-efficient (272K)    ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

Änderungsprotokoll

Referenzen