Codex CLI: kompletne kompendium techniczne

TL;DR: Codex to wielopowierzchniowy agent programistyczny, który czyta bazę kodu, uruchamia polecenia w piaskownicy na poziomie systemu operacyjnego, łata pliki i deleguje zadania do chmury. Opanowanie pięciu podstawowych systemów (config.toml, model sandbox/approval, AGENTS.md, MCP i skills) sprawia, że Codex staje się mnożnikiem efektywności. Warto używać profili do przełączania kontekstu, /compact do zarządzania budżetem kontekstu, /goal do utrwalonych celów pracy oraz AGENTS.md do między narzędziowych instrukcji projektowych działających w Codex, Cursor, Amp i innych narzędziach. GPT-5.5 (uruchomiony 23 kwietnia 2026) jest zalecanym modelem domyślnym w Codex — okno kontekstu 400K w Codex (1M w API), 5/30 USD za MTok, 82,7% Terminal-Bench 2.0 SOTA.⁸³ Od CLI v0.140.0 (stabilna wersja z 15 czerwca 2026) /usage pokazuje dzienną, tygodniową i skumulowaną aktywność tokenów na koncie, sesje można trwale usuwać przez codex delete / /delete (z zabezpieczeniami potwierdzającymi), /import selektywnie migruje konfigurację, ustawienia projektu i ostatnie czaty z Claude Code, wpisanie @ domyślnie otwiera ujednolicone menu wzmianek dla plików, pluginów i skills, a zarządzane uwierzytelnianie kluczem API Amazon Bedrock pojawia się wraz z szyfrowanym lokalnym przechowywaniem poświadczeń OAuth dla CLI i MCP; eksperymentalne sterowanie głosowe /realtime usunięto z TUI.¹⁰² Od CLI v0.139.0 (stabilna wersja z 9 czerwca 2026) tryb code może bezpośrednio wywoływać samodzielne wyszukiwanie w sieci (także z zagnieżdżonych wywołań narzędzia JavaScript) i otrzymywać wyniki jako zwykły tekst, schematy wejściowe narzędzi/connectorów zachowują teraz konstrukcje oneOf/allOf, co poprawia zgodność z dużymi schematami i MCP, codex doctor dodaje szczegóły środowiska edytora i pagera (redagując wrażliwe wartości w JSON), a marketplace pluginów ujawnia źródła w codex plugin marketplace list --json oraz szybciej listuje katalog z cache.¹⁰⁵ v0.138.0 (8 czerwca) dodała /app, aby przekazać sesję CLI do aplikacji desktopowej na macOS i Windows, udostępniła modelowi lokalne ścieżki obrazów, uelastyczniła wybór reasoning-effort i zapewniła automatyzacji pluginów strukturalne dane wyjściowe JSON.¹⁰⁶ v0.137.0 (4 czerwca) wprowadziła multi-agent v2 (runtime zachowywany per wątek, czystsze działania follow-up i domyślne metadane, hide_spawn_agent_metadata domyślnie true), skróty klawiszowe TUI F13–F24 oraz rozszerzenie skills v1 z rozwiązywaniem katalogu per turn.¹⁰⁷ Od CLI v0.135.0 (28 maja 2026) codex doctor raportuje bogatszy inwentarz środowiska, Git, terminala, app-servera i wątków; /status pokazuje szczegóły połączenia zdalnego i wersję serwera, gdy TUI jest podłączony zdalnie; tryb vim zyskał edycję text-object, poprawione zachowanie dla słów i końca linii oraz konfigurowalne interrupt-turn; /permissions rozumie teraz nazwane profile uprawnień i wyświetla profile niestandardowe; pakietowe buildy Codex wykrywają i używają dołączonego, poprawionego helpera zsh na obsługiwanych wersjach macOS; a Python SDK udostępnia przyjazne presety Sandbox dla API wątków i turn.¹⁰⁹ v0.134.0 (26 maja 2026) wprowadziła wyszukiwanie w lokalnej historii konwersacji z dopasowaniami treści bez rozróżniania wielkości liter i podglądem wyników, uczyniła --profile głównym selektorem profilu w przepływach CLI, uprawnień TUI i sandbox (starsze konfiguracje profili są odrzucane z instrukcją migracji), ulepszyła konfigurację MCP przez kierowanie środowiska per serwer oraz opcje OAuth dla streamowalnych serwerów HTTP, zwiększyła niezawodność schematów narzędzi connectorów przez zachowywanie lokalnych $ref/$defs i kompaktowanie zbyt dużych schematów, pozwoliła narzędziom MCP tylko do odczytu działać współbieżnie, gdy deklarują readOnlyHint, oraz dodała bogatszy kontekst rozszerzeń i hooków, w tym historię konwersacji dla narzędzi rozszerzeń.¹⁰¹ v0.133.0 (21 maja 2026) domyślnie włączyła cele z dedykowaną pamięcią i śledzeniem postępu; codex remote-control otrzymał gotowość/status pierwszoplanowy oraz start/stop w stylu demona; profile uprawnień zyskały listę API, dziedziczenie, zarządzane requirements.toml, odświeżanie runtime i mocniejszą integrację z sandbox Windows; odkrywanie pluginów pokazuje zainstalowane wersje, korzenie marketplace i zdalne kolekcje; a rozszerzenia mogą obserwować start/stop subagentów, wykonanie narzędzi, metadane turn oraz asynchroniczne przetwarzanie zatwierdzeń/turn. Aktualizacja aplikacji Codex z 21 maja dodała Appshots dla pierwszoplanowych okien Mac, Goal mode GA w app/IDE/CLI, ulepszenia adnotacji w przeglądarce w aplikacji oraz opcjonalne, zablokowane Computer Use dla kwalifikujących się użytkowników Mac.⁹⁹¹⁰⁰ v0.132.0 (20 maja 2026) dodała pierwszorzędne uwierzytelnianie Python SDK, prostsze tekstowe API turn, bogatszy TurnResult, codex exec resume --output-schema, szybsze uruchamianie TUI, rejestrację zdalnego executora opartą na uwierzytelnieniu oraz zachowanie wierności obrazów w turn app-servera. Nadal należy preferować jawne flagi sandbox/approval lub profile uprawnień zamiast starszego --full-auto; js_repl pozostaje usunięty.^{86878991969798}

Codex działa jako wielopowierzchniowy agent programistyczny, a nie chatbot piszący kod. CLI czyta bazę kodu, wykonuje polecenia w piaskownicy, łata pliki, łączy się z usługami zewnętrznymi przez MCP i deleguje długotrwałe zadania do chmury. Działa lokalnie, ale myśli globalnie; ta sama inteligencja zasila pięć różnych powierzchni pracy, zależnie od sposobu pracy, w tym nowe rozszerzenie Chrome uruchamiające Codex w przeglądarce bez przejmowania nad nią kontroli.⁹⁰

Różnica między okazjonalnym a skutecznym używaniem Codex sprowadza się do pięciu podstawowych systemów. Po ich opanowaniu Codex staje się mnożnikiem efektywności:

1. System konfiguracji: steruje zachowaniem przez config.toml
2. Model sandbox i approval: wyznacza granice tego, co Codex może zrobić
3. AGENTS.md: definiuje kontrakty operacyjne na poziomie projektu
4. Protokół MCP: rozszerza możliwości o usługi zewnętrzne
5. System skills: pakuje wielokrotnego użytku wiedzę domenową

Przez miesiące używałem Codex równolegle z Claude Code w produkcyjnych bazach kodu, pipeline’ach CI/CD i przepływach pracy zespołów. Ten przewodnik kondensuje to doświadczenie w kompletną dokumentację, której brakowało mi na początku. Każda funkcja zawiera rzeczywistą składnię, prawdziwe przykłady konfiguracji i przypadki brzegowe, na których potykają się doświadczeni użytkownicy.

Uwaga o stabilności: Funkcje oznaczone jako [EXPERIMENTAL] lub under development mogą zmieniać się między wydaniami. Od v0.133.0 (21 maja 2026) cele są domyślnie włączone, profile uprawnień są pierwszorzędną zarządzaną powierzchnią, odkrywanie pluginów jest łatwiejsze do inspekcji, a remote-control łatwiej uruchamiać jako pierwszoplanowe lub demonizowane polecenie app-servera. Codex Cloud i tryb code pozostają eksperymentalne albo w fazie rozwoju, podczas gdy podstawowy CLI, sandboxing, AGENTS.md, config.toml, Skills, hooks, narzędzia multi-agent, pluginy, Browser, Computer Use i Appshots są stabilnymi lub udokumentowanymi powierzchniami użytkownika, zależnie od platformy i planu. v0.132.0 uzupełnia uwierzytelnianie Python SDK i strukturalną automatyzację resume; v0.131.0 dodała codex doctor, ujednolicone wyszukiwanie wzmianek @, polecenia marketplace CLI, udostępnianie pluginów świadome wersji, zarządzane przez demona remote-control z włączaniem/wyłączaniem w runtime, środowiska oparte na rejestrze oraz dodatkowe wzmocnienia sandbox Windows.⁹⁶⁹⁷⁹⁸ Starsze --full-auto pozostaje przestarzałe, a js_repl pozostaje usunięty.⁸⁶⁸⁷

Najważniejsze wnioski

• Pięć powierzchni, jeden mózg: CLI, aplikacja desktopowa, rozszerzenie IDE, zadania w chmurze i nowe rozszerzenie Chrome korzystają z tej samej inteligencji GPT-5.x-Codex, więc warto wybrać powierzchnię dopasowaną do przepływu pracy.⁹⁰
• Sandboxing na poziomie systemu operacyjnego: Codex egzekwuje ograniczenia systemu plików i sieci na poziomie jądra (Seatbelt w macOS, Landlock + seccomp w Linux), a nie wewnątrz kontenerów.
• AGENTS.md działa między narzędziami: Instrukcje projektu działają w Codex, Cursor, Copilot, Amp, Jules, Gemini CLI, Windsurf, Cline, Aider, Zed oraz w ponad 60 000 projektów open source. Wystarczy napisać raz i używać wszędzie.
• Profile ograniczają koszt przełączania kontekstu: Można zdefiniować nazwane presety konfiguracji (fast, careful, auto) i przełączać się między nimi za pomocą --profile.
• Zarządzanie kontekstem ma znaczenie: GPT-5.5 zapewnia okno kontekstu 400K w Codex i 1M w API; GPT-5.4 mini również zapewnia 400K do pracy subagentów z mniejszymi opóźnieniami; GPT-5.3-Codex zapewnia 272K wejścia. Warto proaktywnie zarządzać budżetami tokenów za pomocą /compact, skoncentrowanych promptów i odwołań @file.⁸³

Jak korzystać z tego przewodnika

To dokument referencyjny liczący ponad 2 500 wierszy — najlepiej zacząć od miejsca odpowiadającego poziomowi doświadczenia:

Krótka karta referencyjna na końcu zawiera łatwe do przeskanowania podsumowanie wszystkich głównych poleceń.

Jak działa Codex: model mentalny

Przed przejściem do funkcji warto zrozumieć, jak architektura Codex kształtuje wszystko, co można z nim robić. System działa na czterech powierzchniach wspieranych przez współdzieloną warstwę inteligencji:

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

Warstwa rdzeniowa: Rodzina modeli GPT-5.x napędza wszystko. Od 23 kwietnia 2026 roku gpt-5.5 jest zalecanym modelem, gdy jest dostępny — kontekst 400K w Codex (1M w API), 82,7% Terminal-Bench 2.0 SOTA. gpt-5.4 pozostaje domyślną opcją awaryjną podczas wdrażania (kontekst 1M, natywne korzystanie z komputera).⁸³⁶⁴ Czyta pliki, zapisuje poprawki, wykonuje polecenia powłoki i rozumuje o bazie kodu. Gdy kontekst się zapełnia, Codex kompresuje rozmowę, aby zwolnić miejsce. Ta warstwa zużywa tokeny.

Warstwa bezpieczeństwa: Każde polecenie uruchamiane przez Codex przechodzi przez sandbox na poziomie systemu operacyjnego. W macOS framework Apple Seatbelt egzekwuje ograniczenia na poziomie jądra. W Linux Landlock + seccomp filtrują dostęp do systemu plików i wywołań systemowych. Sandbox działa na poziomie jądra, a nie wewnątrz kontenerów. Następnie approval policy decyduje, kiedy poprosić człowieka o potwierdzenie.

Warstwa rozszerzeń: MCP łączy usługi zewnętrzne (GitHub, Figma, Sentry). Skills pakują wielokrotnego użytku przepływy pracy, które Codex ładuje na żądanie. Aplikacje łączą się z connectorami ChatGPT. Wyszukiwanie w sieci dodaje bieżący kontekst z internetu.

Warstwa powierzchni: CLI dla zaawansowanych użytkowników terminala i automatyzacji. Aplikacja desktopowa do wielowątkowego zarządzania projektami. Rozszerzenie IDE do pętli edycja-kompilacja-test. Cloud do zadań asynchronicznych działających niezależnie.

Kluczowy wniosek: Większość użytkowników korzysta tylko z jednej powierzchni. Zaawansowani użytkownicy korzystają ze wszystkich pięciu: Cloud do długo działających zadań, CLI do deterministycznych operacji na repozytorium, rozszerzenia IDE do ciasnych pętli kodowania, aplikacji desktopowej do planowania i koordynacji oraz Chrome do przepływów pracy w przeglądarce po zalogowaniu.

Spis treści

1. Jak zainstalować Codex?
2. Szybki start: pierwsza sesja
3. Główne powierzchnie interakcji
4. Dogłębne omówienie systemu konfiguracji
5. Który model wybrać?
6. Ile kosztuje Codex?
7. Ramy decyzyjne
8. Jak działa system sandbox i zatwierdzeń?
9. Jak działa AGENTS.md?
10. Hooks
11. Czym jest MCP (Model Context Protocol)?
12. Code Mode
13. JavaScript REPL Runtime
14. Czym są Skills?
15. Plugins
16. Plan Mode i współpraca
17. System pamięci
18. Zarządzanie sesjami
19. Tryb nieinteraktywny (codex exec)
20. Codex Cloud i zadania w tle
21. Aplikacja Codex Desktop
22. GitHub Action i CI/CD
23. Codex SDK
24. Optymalizacja wydajności
25. Jak debugować problemy?
26. Wdrożenie enterprise
27. Najlepsze praktyki i antywzorce
28. Przepisy przepływu pracy
29. Przewodnik migracji
30. Krótka karta referencyjna
31. Changelog
32. Referencje

Jak zainstalować Codex?

Menedżery pakietów

# 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

Bezpośredni skrypt instalacyjny (v0.106.0+)

W macOS i Linux dostępny jest jednowierszowy skrypt instalacyjny jako zasób wydania GitHub:⁶⁰

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

Skrypt automatycznie wykrywa platformę i architekturę, pobiera właściwy plik binarny i umieszcza go w PATH.

Pobieranie plików binarnych

W środowiskach bez npm lub Homebrew można pobrać pliki binarne właściwe dla danej platformy z GitHub Releases¹:

Wymagania systemowe

• macOS: Apple Silicon lub Intel (pełna obsługa sandbox przez Seatbelt)
• Linux: x86_64 lub arm64 (sandbox przez Landlock + seccomp)
• Windows: natywny sandbox z ograniczonymi tokenami (awansowany z eksperymentalnego w v0.100.0). WSL również jest obsługiwany²

Uwierzytelnianie

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

Dwie ścieżki uwierzytelniania:

1. Konto ChatGPT (zalecane): należy zalogować się za pomocą istniejącej subskrypcji Plus, Pro, Team, Business, Edu lub Enterprise. Pełny dostęp do funkcji, w tym zadań w chmurze.
2. Klucz API: należy ustawić przez zmienną środowiskową CODEX_API_KEY albo codex login --with-api-key. Niektóre funkcje (wątki w chmurze) mogą być niedostępne.

Wskazówka ekspercka: przechowywanie danych logowania można skonfigurować przez cli_auth_credentials_store w config.toml. Opcje: file (domyślna), keyring (pęk kluczy systemu operacyjnego) lub auto (keyring, jeśli jest dostępny; w przeciwnym razie plik).

Uzupełnianie w powłoce

# 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

Weryfikacja instalacji

codex --version
# codex-cli 0.133.0

Szybki start: pierwsza sesja

Od zera do produktywnej pracy w 5 minut.

1. Instalacja i uwierzytelnienie:

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

2. Przejście do projektu:

cd ~/my-project                  # Any git repo works

3. Uruchomienie Codex:

codex

Zostanie wyświetlony interaktywny TUI. Codex automatycznie odczytuje strukturę projektu.

4. Zadanie pytania:

> What does this project do? Summarize the architecture.

Codex odczytuje kluczowe pliki i wyjaśnia bazę kodu. W domyślnym trybie suggest nie są wprowadzane żadne zmiany.

5. Wprowadzenie zmiany:

> Add input validation to the login endpoint

Codex proponuje edycje jako diff. Proszę je przejrzeć i zatwierdzić za pomocą y albo odrzucić za pomocą n.

6. Użycie slash command:

> /plan Refactor the database layer to use connection pooling

Codex tworzy plan bez wykonywania działań. Należy przejrzeć plan, a następnie zatwierdzić go, aby rozpocząć wykonanie.

7. Sprawdzenie pracy:

> /diff

Można zobaczyć wszystkie zmiany wprowadzone przez Codex w bieżącej sesji.

Co dalej: - Skonfigurować AGENTS.md z instrukcjami projektu (zob. Jak działa AGENTS.md?) - Skonfigurować profil dla własnego przepływu pracy (zob. Profile) - Wypróbować codex exec do automatyzacji nieinteraktywnej (zob. Tryb nieinteraktywny)

Główne powierzchnie interakcji

Codex udostępnia cztery odrębne interfejsy oparte na tej samej inteligencji. Każda powierzchnia jest zoptymalizowana pod inny wzorzec pracy.

1. Interaktywny CLI (interfejs terminala)

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

Interfejs terminala to aplikacja pełnoekranowa z następującymi elementami:

• Composer: wpisywanie promptów, dołączanie plików za pomocą @, uruchamianie poleceń powłoki z prefiksem !
• Panel wyjścia: strumieniowane odpowiedzi modelu, wywołania narzędzi i wynik poleceń
• Pasek stanu: model, użycie tokenów, gałąź git, tryb sandbox

Najważniejsze skróty TUI:

Zmiana wiersza stanu (v0.121.0): stary miernik okna kontekstu w wierszu stanu zastąpiono wskaźnikiem procentowego wykorzystania kontekstu, pokazującym stopień zapełnienia okna kontekstu. Jeśli skrypty lub hooks analizują wiersz stanu, należy sprawdzić tę zmianę formatu.⁸² Codex wyświetli także komunikat o aktualizacji CLI, gdy dostępna będzie nowa wersja.

Slash commands dostępne w TUI:

Przeprojektowanie wyboru przepływu pracy (v0.129.0): resume i fork są teraz łatwiej dostępne z przeprojektowanego selektora, a nowy raw scrollback mode pozwala przewijać niewyrenderowany transkrypt, gdy trzeba skopiować polecenia lub wynik modelu dosłownie. Przydatne podczas triage długiej sesji debugowania albo przekazywania wyniku do innego narzędzia.⁸⁹

Ujednolicone menu wzmianek @ (v0.140.0): wpisanie @ w composerze otwiera teraz jedno menu wzmianek, które domyślnie obejmuje pliki, plugins i skills, zastępując przepływ dołączania ograniczony wyłącznie do plików — jedno naciśnięcie klawisza wystarcza, aby odwołać się do dowolnego zasobu projektu.¹⁰²

2. Codex Desktop App (macOS + Windows)

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

Aplikacja desktopowa dodaje możliwości, których CLI nie ma:

• Wielozadaniowość: uruchamianie wielu równoległych agentów jednocześnie w różnych projektach
• Izolacja Git worktree: każdy wątek pracuje na izolowanej kopii repozytorium
• Wbudowany przegląd diff: stage, revert i commit zmian bez opuszczania aplikacji
• Zintegrowany terminal: terminal dla każdego wątku do uruchamiania poleceń
• Rozgałęzianie rozmów: rozgałęzianie rozmów w celu eksplorowania alternatyw
• Pływające okna pop-out: odłączanie rozmów do przenośnych okien
• Automatyzacje: planowanie zadań cyklicznych (triage zgłoszeń, monitorowanie CI, reakcja na alerty)
• Appshots: dołączanie do wątku pierwszoplanowego okna aplikacji Mac ze zrzutem ekranu i dostępnym tekstem
• Komentarze w przeglądarce w aplikacji: podgląd lokalnych lub publicznych stron, zostawianie komentarzy do elementów/obszarów i umożliwienie Codex realizacji precyzyjnych uwag wizualnych
• Computer Use: umożliwienie Codex obsługi dozwolonych aplikacji Mac w ograniczonym zakresie prac GUI; użycie z blokadą jest opcjonalne dla kwalifikujących się zdalnych tur Mac Computer Use

Kiedy używać aplikacji, a kiedy CLI: aplikacji desktopowej warto używać przy koordynowaniu wielu strumieni pracy albo gdy potrzebny jest wizualny przegląd diff. CLI sprawdzi się, gdy potrzebna jest komponowalność terminala, skryptowanie lub integracja CI/CD.

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

Rozszerzenie Codex IDE integruje się bezpośrednio z edytorem:

• Domyślny tryb agenta: odczytuje pliki, wprowadza edycje, uruchamia polecenia
• Edycje inline: sugestie świadome kontekstu w aktywnych plikach
• Współdzielone sesje: sesje synchronizują się między CLI a rozszerzeniem IDE
• To samo uwierzytelnianie: logowanie za pomocą konta ChatGPT albo klucza API

Instalacja jest dostępna z VS Code Marketplace albo sklepów rozszerzeń Cursor/Windsurf.³

4. Codex Cloud [EXPERIMENTAL]

Zadania w chmurze działają asynchronicznie w środowiskach zarządzanych przez OpenAI:

• Uruchom i zapomnij: kolejkowanie zadań działających niezależnie od lokalnego komputera
• Równoległe wykonywanie: uruchamianie wielu zadań w chmurze jednocześnie
• Tworzenie PR: Codex tworzy pull requests z ukończonej pracy
• Lokalne zastosowanie: pobieranie wyników z chmury do lokalnego repozytorium za pomocą codex apply <TASK_ID>

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

Zadania w chmurze są dostępne również z poziomu chatgpt.com/codex.⁴

5. Codex for Chrome [NEW]

Codex jest dostarczany jako rozszerzenie przeglądarki Chrome, dodając piątą powierzchnię obok CLI, aplikacji desktopowej, rozszerzenia IDE i chmury. Rozszerzenie zaprojektowano tak, aby działało równolegle do zwykłego przeglądania, a nie je przejmowało: Codex pracuje w tle równolegle na kartach, a użytkownik zachowuje kontrolę nad tym, których witryn dotyka.⁹⁰

• Równoległe wykonywanie na kartach: Codex działa jednocześnie na wielu kartach bez blokowania karty na pierwszym planie.
• Kontrola dla każdej witryny: określa się listę dozwolonych witryn, z którymi Codex może wchodzić w interakcje; domyślnie nie ma dostępu.
• Przeglądarka jako warsztat pracy: rozszerzenie najlepiej sprawdza się w pracy nad aplikacjami i witrynami, gdzie strona jest źródłem prawdy — konsole administracyjne, wewnętrzne dashboardy, interfejsy zarządzania treścią, systemy zgłoszeń — nie zastępuje CLI przy lokalnych repozytoriach.
• Ten sam mózg: Codex for Chrome uruchamia tę samą inteligencję GPT-5.x-Codex, której używają pozostałe powierzchnie, więc konfiguracja AGENTS.md lub skills działająca w CLI przenosi te same konwencje do pracy sterowanej przeglądarką.

Instalacja jest dostępna w dokumentacji rozszerzenia Codex Chrome.⁹⁰

Szczegółowy przegląd systemu konfiguracji

Codex używa TOML do konfiguracji. Zrozumienie hierarchii pierwszeństwa jest kluczowe, ponieważ decyduje o tym, które ustawienia zostaną zastosowane w razie konfliktu.

Pierwszeństwo (od najwyższego do najniższego)

1. Nadpisania sesji (najwyższe): flagi CLI (--model, --sandbox, --ask-for-approval, --search, --enable/--disable, --profile) oraz nadpisania -c key=value
2. Konfiguracja projektu (.codex/config.toml, wykrywana od CWD w górę aż do katalogu głównego projektu; wygrywa najbliższy katalog)
3. Konfiguracja użytkownika ($CODEX_HOME/config.toml, domyślnie ~/.codex/config.toml)
4. Konfiguracja systemowa (/etc/codex/config.toml w systemach Unix)
5. Wbudowane wartości domyślne (najniższe)

requirements.toml działa jako warstwa ograniczeń zasad, która ogranicza wartości możliwe do wybrania przez użytkowników po standardowym scaleniu konfiguracji. Zobacz wdrożenie Enterprise.

Lokalizacje plików konfiguracyjnych

Wskazówka ekspercka: Zmienna środowiskowa CODEX_HOME nadpisuje domyślny katalog ~/.codex. Przydatne w konfiguracjach CI/CD lub z wieloma kontami.

Pełna dokumentacja konfiguracji

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

# ─── Model Selection ───────────────────────────────────
model = "gpt-5.5"                      # Recommended model when available
model_provider = "openai"               # Provider (openai, oss, or custom provider id)
model_context_window = 400000           # Token count available to active model (override)
model_auto_compact_token_limit = 200000 # Threshold triggering automatic history compaction
model_reasoning_effort = "medium"       # minimal|low|medium|high|xhigh (model-dependent)
model_reasoning_summary = "auto"        # auto|concise|detailed|none
model_verbosity = "medium"              # low|medium|high
personality = "pragmatic"               # none|friendly|pragmatic
review_model = "gpt-5.5"               # Optional model for /review command
service_tier = "fast"                  # Preferred service tier for new turns
oss_provider = "lmstudio"              # lmstudio|ollama (used with --oss)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Profile

Nazwane presety konfiguracji dla różnych trybów pracy:

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

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

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

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

Aktywacja profilu:

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

Wskazówka ekspercka: Domyślny profil można ustawić za pomocą profile = "fast" na najwyższym poziomie konfiguracji. Dla pojedynczej sesji można go nadpisać przez --profile.

Niestandardowi dostawcy modeli

Połączenie z Azure, AWS Bedrock, modelami lokalnymi lub usługami proxy:

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

Ostrzeżenie: API przewodu chat/completions (wire_api = "chat") został wycofany dla modeli hostowanych przez OpenAI, a OpenAI zapowiedziało jego usunięcie w lutym 2026 roku.³⁴ Lokalni dostawcy (Ollama, LM Studio) mogą nadal akceptować ten format. Dla endpointów OpenAI należy zamiast tego używać wire_api = "responses".

Użycie modeli lokalnych z 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

Lub ustawienie w konfiguracji:

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

Wbudowane nadpisania konfiguracji

Nadpisanie dowolnej wartości konfiguracji z wiersza poleceń:

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"

Który model wybrać?

Dostępne modele (kwiecień 2026)

GPT-5.5 (23 kwietnia 2026) to rekomendowany przez OpenAI wybór do większości zadań Codex: złożonego programowania, obsługi komputera, pracy z wiedzą oraz przepływów badawczych. Dostępny w Codex CLI / web / desktop od 23 kwietnia dla ChatGPT Plus / Pro / Business / Enterprise / Edu / Go; w OpenAI API od 24 kwietnia. Okno kontekstu: 400K w Codex, 1M w API — Codex ogranicza okno do 400K, aby zrównoważyć przepustowość i koszt w różnych poziomach subskrypcji; API udostępnia pełny 1M. Cennik (API): 5 USD wejście / 30 USD wyjście za MTok (2× stawka GPT-5.4; OpenAI podaje ~20% efektywnego wzrostu po usprawnieniach efektywności tokenów). Benchmarki: 82,7% Terminal-Bench 2.0 (aktualny SOTA wśród publicznie dostępnych modeli), 84,9% GDPval (44 zawody), 78,7% OSWorld-Verified, 98,0% Tau2-bench Telecom (bez tuningu promptów). OpenAI wykorzystało GPT-5.5 + Codex wewnętrznie do przepisania infrastruktury serwującej przed premierą — przyniosło to 20% wzrost prędkości generowania tokenów.⁸³

GPT-5.4 pozostaje dostępny na wszystkich powierzchniach Codex (CLI, aplikacja, rozszerzenie IDE, chmura).⁶⁴ Dokładna lista modeli zależy od konta i etapu wdrożenia. Można sprawdzić lokalną pamięć podręczną: ~/.codex/models_cache.json.

Uwaga o wycofaniu (11 marca 2026): Modele GPT-5.1 nie są już dostępne w ChatGPT. Istniejące konwersacje automatycznie kontynuują pracę na GPT-5.3 Instant, GPT-5.4 Thinking lub GPT-5.4 Pro. GPT-5.1-Codex-Mini pozostaje dostępny przez API i CLI do obciążeń wrażliwych na koszty.⁷¹

Uwaga o wersji bezpłatnej (5 maja 2026): GPT-5.5 Instant został wdrożony na bezpłatnym poziomie ChatGPT 5 maja 2026. Poszerza to grono odbiorców rodziny GPT-5.5 poza plany płatne, choć dostęp do Codex CLI nadal wymaga uprawnionej subskrypcji Plus / Pro / Business / Enterprise / Edu / Go lub klucza API.⁹²

GPT-5.4 mini (17 marca 2026): Mniejszy, szybszy wariant GPT-5.4 z kontekstem 400K za 0,75 USD/4,50 USD za MTok — wykorzystuje tylko 30% limitu GPT-5.4. Idealny do delegowania do subagentów: GPT-5.4 może zająć się planowaniem i koordynacją, podczas gdy subagenci GPT-5.4 mini równolegle obsługują węższe podzadania (przeszukiwanie bazy kodu, przegląd plików, przetwarzanie dokumentów).⁷⁶

Schemat wyboru modelu

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

Wysiłek wnioskowania

Można kontrolować, ile model „myśli” przed udzieleniem odpowiedzi:

Obsługiwane poziomy zależą od modelu. minimal jest dostępny tylko dla modeli GPT-5. Nie wszystkie modele obsługują każdy poziom.

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

Wskazówka eksperta: Wnioskowanie xhigh może zużywać 3-5x więcej tokenów niż medium przy tym samym prompcie. Warto rezerwować je dla rzeczywiście trudnych problemów, w których dodatkowe myślenie się opłaca.

Szybkie sterowanie wnioskowaniem w TUI (v0.124.0+).⁸⁵ W interaktywnej sesji TUI Alt+, obniża wnioskowanie o jeden poziom, a Alt+. podnosi je o jeden poziom — przydatne, gdy trudny problem w trakcie sesji uzasadnia tymczasowe przejście medium → high → xhigh bez użycia /effort lub -c. Po zaakceptowaniu uaktualnienia modelu w trakcie sesji wnioskowanie resetuje się do domyślnej wartości nowego modelu, zamiast przenosić poprzedni poziom.

Przełączanie modeli

Można przełączać modele w trakcie sesji za pomocą polecenia slash /model lub ustawiać per-uruchomienie przez --model / -m:

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

Ile kosztuje Codex?

Zobacz także Wybór modelu, aby poznać możliwości, oraz Ramy decyzyjne — pomocne przy doborze właściwego modelu do zadania.

Dostęp poprzez plany ChatGPT

Dostępność Codex zależy od planu ChatGPT oraz ustawień organizacji:⁵¹

Aktualizacja cen z kwietnia 2026: Cena roczna Business spadła z $25 do $20 za stanowisko/mies. Stanowiska tylko-Codex z rozliczaniem pay-as-you-go są teraz dostępne dla obszarów roboczych Business i Enterprise — brak stałej opłaty za stanowisko, rozliczanie wg zużycia tokenów.⁷⁹ Promocyjne 2x limity szybkości dla planów płatnych (od premiery Desktop App w lutym 2026) pozostają aktywne.¹⁶

Zwiększenie limitów użycia w maju 2026 (do 31 maja 2026): Codex w planie Plus działa z 25× limitem 5-godzinnym (w porównaniu do standardowego boosta 20×), a poziom $100/miesiąc został podwojony w tym samym okresie. Warto wykorzystać ten czas na dłuższe partie zadań w chmurze lub przepustowe uruchomienia agentów bez uderzania w standardową ścianę 5-godzinną.⁸⁹

Koszty kredytów

Operacje Codex zużywają kredyty z alokacji planu:

Plany Enterprise i Edu skalują kredyty wraz z alokacją w umowie. Aby sprawdzić bieżące zużycie, należy użyć /status w TUI.

Rozliczanie API

W przypadku korzystania z Codex poprzez API, OpenAI rozlicza użycie wg tokenów według standardowych cen API OpenAI dla wybranego modelu (plus ewentualne zniżki za prompt-caching). Aktualne stawki znajdują się na oficjalnej stronie cennika API.²⁰

Strategie optymalizacji kosztów

1. Wykorzystanie profili: Warto utworzyć profil fast z gpt-5.1-codex-mini i model_reasoning_effort = "low" do rutynowych zadań
2. Rezerwowanie wysokiego reasoning: Tryb xhigh należy stosować tylko do naprawdę trudnych problemów, ponieważ kosztuje 3-5x więcej tokenów
3. Stosowanie --ephemeral: Pomijanie utrwalania sesji w CI/CD redukuje narzut
4. Minimalizacja podsumowań reasoning: Należy ustawić model_reasoning_summary = "none", gdy wyjaśnienia nie są potrzebne
5. Batchowanie w trybie exec: codex exec unika narzutu TUI w przepływach automatyzacji
6. Monitorowanie użycia: Należy sprawdzać /status w TUI oraz pulpity rozliczeniowe organizacji

Przykłady kosztów z praktyki

Reprezentatywne koszty API dla typowych zadań (gpt-5.3-codex w cenie standardowej, średni reasoning):

Koszty zmieniają się wraz z reasoning effort, cachowaniem i długością rozmowy. Warto używać gpt-5.1-codex-mini do rutynowych zadań, co redukuje koszty o ~40-60%. Cachowane tokeny wejściowe są rozliczane ze zniżką.

Ukryty narzut tokenów

Każde wywołanie narzędzia dodaje tokeny ponad widoczny prompt:

Wskazówka eksperta: Należy monitorować rzeczywiste użycie poprzez /status w TUI. Liczba tokenów obejmuje cały narzut, nie tylko widoczne wiadomości. Jeśli koszty zaskakują, warto sprawdzić, ile serwerów MCP jest podłączonych — każdy dodaje definicje narzędzi do każdego wywołania API.

Zarządzanie kosztami w zespole

Strategie kontroli kosztów w zespole: - Ustawienie requirements.toml w celu egzekwowania limitów modelu i reasoning effort w skali całej organizacji - Stosowanie gpt-5.1-codex-mini w CI/CD — zautomatyzowane pipeline’y rzadko wymagają maksymalnego reasoning - Budżetowanie oparte na profilach — definiowanie profili ci, review i dev z odpowiednimi pułapami kosztów - Monitorowanie poprzez OpenTelemetry — wdrożenia enterprise mogą eksportować telemetrię użycia do istniejących stosów obserwowalności

Ramy decyzyjne

Kiedy używać poszczególnych powierzchni

Kiedy używać poszczególnych trybów sandbox

Kiedy używać poszczególnych poziomów rozumowania

Plan Mode kontra wykonanie bezpośrednie

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 kontra Tab

Zasada ogólna: Enter = „zatrzymaj się, posłuchaj tego teraz.” Tab = „kiedy skończysz, zrób też to.”

Desktop App kontra 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

Który profil?

Proszę dopasować zadanie do wstępnie skonfigurowanego profilu:

Konfiguracja config.toml:

# Default profile
profile = "default"

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

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

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

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

Przełączanie profili dla każdej sesji: codex --profile careful

Jak działa system sandbox i zatwierdzania?

Codex używa dwuwarstwowego modelu zabezpieczeń, który oddziela to, co jest technicznie możliwe, od tego, kiedy Codex prosi człowieka o zatwierdzenie. To podejście zasadniczo różni się od systemu uprawnień Claude Code — Codex egzekwuje ograniczenia na poziomie jądra systemu operacyjnego.⁵ Zobacz też wdrożenie Enterprise, aby poznać ograniczenia requirements.toml, które administratorzy egzekwują w całej organizacji.

Warstwa 1: sandbox (co jest możliwe)

Sandbox kontroluje dostęp do systemu plików i sieci za pomocą natywnych mechanizmów systemu operacyjnego:

Egzekwowanie zależne od platformy:

• macOS: framework Seatbelt firmy Apple przez sandbox-exec, z profilami specyficznymi dla trybu kompilowanymi w czasie działania i egzekwowanymi przez jądro⁶. Od v0.121.0 profile sandbox na macOS mogą allowlistować konkretne Unix sockets (np. docker.sock, sockety IPC edytora), a prywatne rozpoznawanie DNS nie jest już domyślnie blokowane.⁸²
• Linux: Landlock do ograniczeń systemu plików + seccomp do filtrowania syscalli. Samodzielny proces pomocniczy (codex-linux-sandbox) zapewnia izolację defense-in-depth.⁵ Bubblewrap (bwrap) jest vendoringowany i kompilowany jako część buildu dla Linux (awansował z opcjonalnego w v0.100.0)⁷. v0.117.0 poprawiła niezawodność sandbox na starszych dystrybucjach z legacy konfiguracjami jądra.⁷⁵ v0.129.0 wzmocniła uruchamianie sandbox na Linux i podniosła vendoringowany Bubblewrap do 0.11.2 z upstreamowymi poprawkami bezpieczeństwa; v0.130.0 dodała kolejne wzmocnienia uruchamiania.⁸⁹⁹¹
• Windows: natywny sandbox z restricted tokens (awansował z eksperymentalnego w v0.100.0). WSL również jest obsługiwany (dziedziczy Linux Landlock + seccomp). v0.117.0 obejmuje ulepszenia sandbox z restricted-token dla lepszej izolacji procesów.⁷⁵ v0.130.0 przyznaje użytkownikom sandbox dostęp do cache binariów runtime aplikacji desktopowej, dzięki czemu sandbox Windows może niezawodnie rozpoznawać binaria runtime dla użytkowników workspace-sandbox.⁹¹

Dlaczego to ma znaczenie: W przeciwieństwie do sandboxingu opartego na kontenerach (Docker), sandboxing na poziomie systemu operacyjnego jest szybszy, lżejszy i trudniejszy do obejścia. Jądro egzekwuje ograniczenia, zanim Codex w ogóle zobaczy wywołanie systemowe.

Poprawki bezpieczeństwa: - Obejście sandbox przez zsh-fork (v0.106.0): Naprawiono podatność, w której wykonywanie powłoki przez forkowanie zsh mogło omijać ograniczenia sandbox.⁶⁰ Jeśli używana jest wcześniejsza wersja, należy natychmiast wykonać aktualizację. - Limit rozmiaru wejścia (v0.106.0): Codex egzekwuje teraz limit wejścia wynoszący około 1 miliona znaków, aby zapobiegać zawieszaniu się na zbyt dużych payloadach.⁶⁰ - Bezpieczny profil devcontainer (v0.121.0): Nowy wzmocniony profil klienta dla devcontainerów Docker używa Bubblewrap do sandboxingu wewnątrz kontenera. WSL2 jest obsługiwany; WSL1 jest jawnie odrzucany (Bubblewrap jest niezgodny z kernel shim WSL1).⁸² - Guardian review + hooks (v0.121.0): Hooks są wyłączone podczas sesji Guardian review, aby hooks przed/po narzędziu nie mogły ingerować w decyzje subagenta Guardian.⁸² Jeśli hooks służą do logowania lub walidacji, należy pamiętać, że Guardian review je pomija — gdy potrzebny jest pełny audit trail, warto oprzeć się na obserwowalności serwera aplikacji. - System plików /dev w Linux (v0.105.0): Polecenia uruchamiane w sandbox na Linux otrzymują teraz minimalny system plików /dev, co poprawia zgodność z narzędziami oczekującymi device nodes.⁶¹

Polityka ReadOnlyAccess (v0.100.0+): Konfigurowalny kształt polityki do szczegółowej kontroli dostępu do odczytu. Można go użyć, aby ograniczyć katalogi, z których Codex może czytać, nawet w trybie workspace-write:

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

Warstwa 2: polityka zatwierdzania (kiedy pytać)

Polityka zatwierdzania określa, kiedy Codex wstrzymuje działanie, aby poprosić człowieka o potwierdzenie:

on-failure nadal pojawia się w niektórych starszych przykładach i ścieżkach zgodności, ale obecne dokumenty konfiguracyjne OpenAI oznaczają ją jako przestarzałą. Dla uruchomień interaktywnych należy preferować on-request, a dla nieinteraktywnych, które mają już zewnętrzną granicę bezpieczeństwa, never.⁸⁷

Odrębne identyfikatory zatwierdzeń (v0.104.0+)

Codex przypisuje teraz odrębne identyfikatory zatwierdzeń do każdego polecenia w wieloetapowym wykonaniu powłoki. Oznacza to, że zatwierdzenia są granularne — zatwierdzenie jednego polecenia w sekwencji nie zatwierdza automatycznie kolejnych w tym samym wywołaniu powłoki.⁴⁹

Elastyczne kontrolki zatwierdzania (v0.105.0+)

Przepływ zatwierdzania obsługuje teraz dodatkowe uprawnienia sandbox i granularne odrzucanie:⁶¹

• Dodatkowe uprawnienia sandbox: Gdy polecenie wymaga dostępu wykraczającego poza obecny tryb sandbox, Codex może poprosić o konkretne dodatkowe uprawnienia zamiast wymagać pełnej zmiany trybu
• Granularne odrzucanie: Można odrzucać pojedyncze wywołania narzędzi z informacją zwrotną, aby Codex mógł dostosować podejście, zamiast po prostu ponawiać to samo polecenie

Żądania uprawnień w czasie działania (v0.113.0+)

Codex zawiera teraz wbudowane narzędzie request_permissions, które pozwala modelowi prosić o dodatkowe uprawnienia w czasie działania.⁶⁹ Gdy model napotka zadanie wymagające podwyższonego dostępu, może formalnie zażądać konkretnych uprawnień (ścieżek systemu plików, dostępu do sieci itd.) przez przepływ zatwierdzania TUI, zamiast po cichu kończyć niepowodzeniem lub wymagać od użytkownika ponownego uruchomienia z innymi flagami.

Profile uprawnień (v0.113.0+, rozszerzone w v0.128.0 i v0.133.0)

Profile uprawnień dzielą polityki sandbox dla systemu plików i sieci na nazwane, wielokrotnego użytku sekcje. Ustaw default_permissions na wbudowany profil, taki jak :read-only, :workspace, albo wskaż niestandardową tabelę [permissions.<name>].⁸⁷ v0.133.0 promuje profile jako zarządzaną powierzchnię: list APIs udostępniają metadane dostępnych profili, profile mogą dziedziczyć po sobie, zarządzany requirements.toml może deklarować wymagania dotyczące uprawnień, aktywne profile odświeżają się w czasie działania, a konfiguracja sandbox Windows korzysta teraz z rozwiązanego profilu zamiast z osobnej, doraźnej polityki.⁹⁸

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"

Użyj none dla poufnych plików i globów, które powinny być nieczytelne nawet wtedy, gdy katalog główny projektu jest zapisywalny. Dla jednorazowych wyjątków poleceń lepiej preferować reguły niż szerokie rozszerzanie profilu.⁸⁷

Starsze wskazówki dotyczące --full-auto

Starsze poradniki opisywały --full-auto jako wygodny alias dla:

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

W v0.128.0 release notes oznaczają --full-auto jako przestarzałe, a bieżąca pomoc CLI nie wymienia go już dla uruchomień interaktywnych. Zamiast tego należy użyć jawnych flag powyżej albo nazwanego profilu uprawnień.⁸⁶

Niezawodność sandbox (v0.129.0): Wzmocnienie uruchamiania sandbox na Linux ogranicza race conditions na wolnych systemach plików lub checkoutach z symlinkami; ulepszenia niezawodności sandbox Windows rozwiązują kilka edge-case crashy podczas długotrwałych uruchomień; a vendoringowany Bubblewrap podniesiono do 0.11.2 z upstreamowymi poprawkami bezpieczeństwa. Zmiany konfiguracji nie są wymagane. Uruchom codex update, aby je pobrać.⁸⁹

Zalecane konfiguracje

Codzienny development (bezpieczna wartość domyślna):

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

Power user (pełny dostęp, human-in-the-loop):

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

Ta kombinacja jest rekomendowanym przez społeczność „sweet spot”: maksymalne możliwości, ale z zatwierdzeniem wymaganym dla każdego polecenia.⁸

Automatyzacja CI/CD:

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

Smart Approvals z subagentem Guardian (v0.115.0+)

Smart Approvals mogą kierować żądania review przez subagenta guardian zamiast wymagać ludzkiego zatwierdzenia dla każdej akcji. Sesja guardian utrzymuje się między zatwierdzeniami, aby ponownie używać prompt cache i unikać narzutu startowego. Każde review otrzymuje czystą historię (wcześniejsze decyzje nie przeciekają do późniejszych review).⁷³

Skonfiguruj reviewera w config.toml:

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

Jest to szczególnie użyteczne w przepływach CI/CD, gdy oczekiwane jest automatyczne review z reasoningiem zamiast ogólnego approval_policy = "never".

Włączanie dostępu do sieci

Codex domyślnie blokuje dostęp do sieci w trybie workspace-write. Włącz go, gdy jest potrzebny:

# 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

Obsługa proxy WebSocket (v0.104.0+)

W środowiskach korporacyjnych, które kierują ruch WebSocket przez proxy, Codex obsługuje teraz zmienne środowiskowe WS_PROXY i WSS_PROXY:⁴⁹

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

Uzupełniają one istniejącą obsługę proxy HTTPS_PROXY i SOCKS5 (v0.93.0+), obejmując wszystkie warstwy transportowe.

Testowanie sandbox

Przed zaufaniem sandbox warto zweryfikować jego zachowanie:

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

Jeśli sandbox działa poprawnie, oba polecenia powinny zakończyć się błędem odmowy uprawnień w profilu ograniczonym do workspace. Jeśli którekolwiek polecenie się powiedzie, konfiguracja sandbox wymaga zbadania.

Jak działa AGENTS.md?

AGENTS.md to system instrukcji projektowych Codex — otwarty standard⁹, którym obecnie zarządza Agentic AI Foundation należąca do Linux Foundation. Obsługują go Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode oraz ponad 60 000 projektów open source. Określa on, jak Codex zachowuje się w konkretnym repozytorium lub katalogu. Zobacz Skills, aby poznać pakiety wiedzy eksperckiej wielokrotnego użytku, które uzupełniają AGENTS.md.

Hierarchia wykrywania

Codex buduje łańcuch instrukcji na początku sesji, przechodząc przez drzewo katalogów:

1. Globalne (~/.codex/): AGENTS.override.md > AGENTS.md
2. Projektowe (od katalogu głównego git do bieżącego katalogu): na każdym poziomie sprawdzane są AGENTS.override.md > AGENTS.md > zapasowe nazwy plików
3. Scalanie: pliki są łączone od katalogu głównego w dół; pliki bliższe bieżącemu katalogowi pojawiają się później w prompt i zastępują wcześniejsze wytyczne

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

Co wyróżnia świetny AGENTS.md

Na podstawie bezpośrednich wskazówek od samego Codex oraz wzorców społeczności¹⁰:

WARTO: - Pisać konkretnie: "Use rg --files for discovery" działa lepiej niż "search efficiently" - Zdefiniować warunki ukończenia: co oznacza „gotowe”? (testy przechodzą, lint bez błędów itd.) - Uwzględnić polecenia: budowanie, testy, lint, formatowanie (dokładne wywołania) - Organizować według zadań: sekcje dotyczące kodowania, review, release, incydentów/debugowania - Zdefiniować eskalację: co zrobić w razie blokady lub napotkania nieoczekiwanego stanu

NIE NALEŻY: - Wrzucać całych przewodników stylistycznych bez reguł wykonania - Używać niejednoznacznych dyrektyw („zachowaj ostrożność”, „optymalizuj”) - Łączyć sprzecznych priorytetów (szybkość + wyczerpująca weryfikacja + brak budżetu runtime) - Pisać dokumentacji opisowej (AGENTS.md to polityka operacyjna, nie README)

Przykład: produkcyjny 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.

Obsługa sekretów w sesjach agenta

Historię widoczną dla Codex należy traktować jako powierzchnię bezpieczeństwa, a nie tylko kod źródłowy. Release notes Codex dokumentują prace nad snapshotami shell i redakcją zmiennych środowiskowych, a system pamięci skanuje zapisy pamięci pod kątem sekretów, ale te zabezpieczenia nie sprawiają, że dane wyjściowe poleceń, transkrypty sesji, snapshoty shell, lokalne logi czy skrypty pomocnicze stają się bezpiecznymi miejscami do drukowania poświadczeń.³⁷⁵⁵⁹⁵

Zasada działania jest prosta: nie drukować sekretów do inspekcji przez model; przechowywać pomocnicze poświadczenia w konfiguracji wymaganej przez środowisko; podczas audytów oddzielać wykonywalne źródła, dokumentację, wygenerowane cache, transkrypty sesji, snapshoty shell, logi i celowe magazyny sekretów; redagować lokalną historię, gdy pojawia się kształt sekretu o wysokiej pewności; oraz promować hooks prewencyjne dopiero po udowodnieniu ręcznej pętli higieny. Publiczną lekcją jest mapa powierzchni i kryteria akceptacji, nie prywatne wartości tokenów, dokładne ścieżki ani wewnętrzne mechanizmy detektorów.⁹⁵

Mechanizm override

AGENTS.override.md na dowolnym poziomie katalogu zastępuje zwykły AGENTS.md dla danego zakresu. Stosować do:

• Zamrożeń release: „Bez nowych funkcji, tylko poprawki”
• Trybu incydentu: „Wszystkie zmiany muszą zostać sprawdzone przez osobę dyżurną”
• Tymczasowego utwardzania: „Bez aktualizacji zależności w tym sprincie”

Konfiguracja

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

Generowanie szkieletu

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

Lub zweryfikować łańcuch instrukcji:

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

Hooks

Codex wprowadził hooks w v0.99.0 (AfterAgent) i v0.100.0 (AfterToolUse), a następnie dodał eksperymentalny silnik hooks w v0.114.0 ze zdarzeniami SessionStart i Stop.⁷⁰ Od v0.124.0 (23 kwietnia 2026) hooks są stabilne.⁸⁵ Obecnie można je konfigurować inline w config.toml i requirements.toml — nie jest już wymagany osobny plik skryptów hook — i obserwują narzędzia MCP obok apply_patch oraz długotrwałych sesji Bash. System obejmuje teraz cykl życia sesji i automatyzację na poziomie narzędzi, domykając lukę względem modelu hooks w Claude Code.

Dostępne zdarzenia hook

Konfiguracja hook

Hooks konfiguruje się w .codex/config.toml:

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

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

Stdout hook SessionStart trafia do kontekstu modelu, dzięki czemu świetnie nadaje się do wstrzykiwania dynamicznych informacji (dat, nazw branch, zmiennych środowiskowych) na początku sesji.

Odtwarzanie wzorców hooks z Claude Code

W przypadku migracji z Claude Code podobną automatyzację można uzyskać tak:

Wskazówka ekspercka: Od v0.124.0 (23 kwietnia 2026) silnik hooks jest stabilny. Nowe zdarzenia hook nadal trafiają do kolejnych wydań — proszę sprawdzić Codex changelog.

Przeglądarka hooks w TUI (v0.129.0): Uruchomić /hooks w TUI, aby odkryć dostępne hooks, zobaczyć, które są obecnie aktywne, i przełączać pojedyncze hooks bez edytowania config.toml. Przydatne podczas rozwiązywania problemów ze źle działającym hook dołączonym do plugin lub tymczasowego wyłączania lintera AfterToolUse na czas skupionej sesji edycji.⁸⁹

Czym jest MCP (Model Context Protocol)? [EXPERIMENTAL]

MCP rozszerza możliwości Codex, łącząc go z zewnętrznymi narzędziami i usługami. Grupa poleceń codex mcp jest obecnie oznaczona jako experimental, a polecenia i format konfiguracji mogą zmieniać się między wydaniami. Codex obsługuje 2 typy transportu: STDIO (procesy lokalne) oraz Streamable HTTP (serwery zdalne).¹¹

Zmiany MCP w v0.121.0: Narzędzia są teraz rejestrowane z przestrzenią nazw, więc nazwy narzędzi na listach pojawiają się jako <server>:<tool>, a nie jako same nazwy — należy zaktualizować wszystkie skrypty lub prompty, które używają grep na niekwalifikowanych nazwach narzędzi. Nowa flaga supports_parallel_tool_calls jest przekazywana do dołączonych MCP, umożliwiając równoległe wykonywanie dla serwerów deklarujących takie wsparcie. Metadane stanu sandboxa przepływają teraz przez metadane narzędzi MCP, aby serwery mogły dostosować zachowanie (np. ostrzec, gdy działają w sandboxie read-only). Niestandardowe żądanie codex/sandbox-state zostało usunięte — zamiast tego należy używać ścieżki metadanych. Trafia tu faza 3 wdrożenia MCP Apps z obsługą wywołań narzędzi; spłaszczone odroczone wywołania narzędzi są teraz obsługiwane dla serwerów używających wzorca odroczonych wywołań.⁸²

Konfigurowanie serwerów MCP

Serwery STDIO (procesy lokalne):

# 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

Serwery HTTP (zdalne):

[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

Zarządzanie CLI

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

W trakcie sesji: /mcp pokazuje aktywne serwery i dostępne narzędzia. /mcp verbose (v0.123.0+)⁸⁴ zwraca pełną diagnostykę serwera, zasoby i szablony zasobów — przydatne, gdy serwer nie ładuje się poprawnie albo narzędzia nie pojawiają się tam, gdzie powinny. Zwykłe /mcp pozostaje szybkie.

Ładowanie MCP przez pluginy (v0.123.0+) akceptuje zarówno standardowy schemat mcpServers, jak i mapy serwerów najwyższego poziomu w .mcp.json, więc pluginy tworzone zgodnie z dowolną z tych konwencji ładują się poprawnie.⁸⁴

Uruchamianie Codex JAKO serwera MCP

Codex może udostępnić sam siebie jako serwer MCP do orkiestracji wielu agentów:¹²

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

Serwer udostępnia 2 narzędzia: 1. codex(): Rozpoczęcie nowej sesji z parametrami promptu, sandboxa, modelu i zatwierdzania 2. codex-reply(): Kontynuowanie istniejącej sesji z threadId i promptem

Użycie z 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")

Godne uwagi serwery MCP

Praktyczne wzorce

Wzorzec 1: Programowanie świadome kontekstu — warto połączyć Context7 z dokumentacją używanego frameworka, aby Codex zawsze miał aktualne odniesienia API:

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

Wzorzec 2: Limity danych wyjściowych — odpowiedzi narzędzi MCP są domyślnie obcinane przy około 25 tys. znaków. W przypadku narzędzi zwracających duże ładunki danych (zapytania do bazy danych, przechwycone logi) należy użyć enabled_tools, aby ograniczyć zakres do konkretnych narzędzi i utrzymać odpowiedzi w skupionej formie.

Wzorzec 2a: Multimodalne dane wyjściowe narzędzi (v0.107.0) — narzędzia niestandardowe mogą teraz zwracać multimodalne dane wyjściowe (obrazy, treści wzbogacone) obok tekstu. Umożliwia to narzędziom generującym artefakty wizualne — zrzuty ekranu, diagramy, rendery wykresów — przekazywanie ich bezpośrednio do modelu do analizy.⁶²

Wzorzec 3: Zarządzanie MCP w przedsiębiorstwie — można zablokować zestaw serwerów MCP, z których mogą korzystać deweloperzy, za pomocą requirements.toml:

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

Każdy serwer, który nie pasuje do tożsamości w requirements.toml, zostanie zablokowany przy uruchomieniu. Pełną konfigurację zasad opisuje sekcja Wdrożenie w przedsiębiorstwie.

Code Mode [EXPERIMENTAL]

Code mode (v0.114.0) zapewnia bardziej izolowane przepływy pracy programistycznej, ograniczając zakres agenta do operacji skoncentrowanych na kodzie.⁷⁰ Po włączeniu agent skupia się na czytaniu, pisaniu i testowaniu kodu bez szerszych interakcji z systemem.

Od v0.139.0 code mode może wywoływać samodzielne web search bezpośrednio — również z zagnieżdżonych wywołań narzędzi JavaScript — i otrzymuje wyniki w postaci zwykłego tekstu, dzięki czemu przepływ w code mode może pobierać aktualne informacje bez opuszczania sandboxowego kontekstu programistycznego.¹⁰⁵

Ta funkcja jest eksperymentalna. Aktualizacje należy sprawdzać w release notes.

Runtime REPL JavaScript [REMOVED]

Codex v0.100.0 dodał eksperymentalny runtime REPL JavaScript (js_repl), a v0.106.0 udostępnił go przez powierzchnię /experimental.⁶⁰ Te wskazówki mają obecnie charakter historyczny. W v0.128.0 changelog wydania zawiera wpis „Remove js_repl feature”, a bieżąca lista funkcji oznacza zarówno js_repl, jak i js_repl_tools_only jako usunięte.⁸⁶

Nie należy dodawać features.js_repl = true do nowych konfiguracji. Gdy potrzebna jest powtarzalna logika wykonywalna, należy używać poleceń shell, skryptów zapisanych w repozytorium, narzędzi MCP albo skill Codex z folderem scripts/.

Czym są skills?

Skills to wielokrotnego użytku, specyficzne dla zadań pakiety możliwości, które Codex ładuje na żądanie. Są zgodne z otwartym standardem agent skills.¹³

Struktura skill

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)

Lokalizacje wykrywania

Codex przechowuje skills zainstalowane przez użytkownika w $CODEX_HOME/skills (domyślnie: ~/.codex/skills), w tym wbudowane skills systemowe w .system/. Codex obsługuje foldery skill dowiązane symbolicznie.

Tworzenie skill

Format SKILL.md:

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

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

Wywoływanie skills

• Jawnie: menu /skills lub wzmianka $skill-name w prompt
• Niejawnie: Codex automatycznie wykrywa pasujące skills na podstawie opisu zadania (jeśli allow_implicit_invocation: true)
• Creator: użyć $skill-creator, aby interaktywnie utworzyć nowy skill
• Installer: użyć $skill-installer install <name>, aby zainstalować społecznościowe skills

Włączanie/wyłączanie

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

Skills a slash commands

Debugowanie skills

Jeśli skill się nie aktywuje:

1. Sprawdzić wykrywanie: /skills powinno wyświetlać go w TUI
2. Zweryfikować ścieżkę: upewnić się, że folder skill znajduje się w rozpoznawanej lokalizacji (~/.codex/skills/, katalog główny projektu lub /etc/codex/skills/)
3. Sprawdzić enabled: skills z enabled = false w config.toml nie zostaną załadowane
4. Sprawdzić aktywację niejawną: jeśli używane jest automatyczne wykrywanie, upewnić się, że w agents/openai.yaml ustawiono allow_implicit_invocation: true
5. Użyć słów kluczowych: uwzględnić w prompt terminy z description danego skill, aby poprawić dopasowanie niejawne

Przykład produkcyjny: deploy skill

Kompletny, wieloplikowy skill pokazujący współpracę references i scripts:

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

Wywołanie: $deploy to staging lub $deploy production with canary rollout

Plugins

Plugins łączą skills, wpisy MCP, hooks oraz app connectors w jeden instalowalny pakiet (v0.110.0+).⁶⁵ Od v0.117.0 plugins są pełnoprawnym elementem systemu: plugins ograniczone do produktu synchronizują się automatycznie przy uruchomieniu, a /plugins udostępnia przeglądarkę w TUI do odkrywania i zarządzania.⁷⁵ v0.128.0 rozszerzyło przepływy pracy z plugins o instalację z marketplace, cache zdalnych pakietów, zdalne APIs odinstalowywania, hooks dołączane do plugins, stan włączenia hook oraz import konfiguracji external-agent.⁸⁶ v0.129.0 (7 maja 2026) dodaje udostępnianie plugins w workspace (przekazanie zestawu plugins współpracownikom bez ponownej publikacji), kontrolę dostępu do udostępnień (włączanie/wyłączanie dla konkretnych odbiorców, cofanie dostępu), filtrowanie źródeł (ograniczenie marketplace, z których workspace pobiera dane) oraz operacje marketplace, które można wywoływać bezpośrednio z przeglądarki /plugins zamiast z CLI.⁸⁹ v0.133.0 (21 maja 2026) ułatwia audyt odkrywania plugins: lista wyników uwzględnia marketplace, widoczne są zainstalowane wersje, wypisywane są korzenie marketplace, a zdalne kolekcje plugins można wyświetlać bez zgadywania, z którego rejestru pochodzi wynik.⁹⁸ v0.130.0 (8 maja 2026) zwiększa przejrzystość pakowania plugins i daje większą kontrolę nad przepływem udostępniania:⁹¹

• Hooks dołączone do pakietu widoczne w szczegółach plugin. Widok szczegółów /plugins pokazuje teraz każdy lifecycle hook dołączony do plugin (SessionStart, UserPromptSubmit, Stop itd.). Przed instalacją plugin można dokładnie sprawdzić, które hooks zostaną zarejestrowane w sesji — bez zaskakujących skutków ubocznych hooks z plugin, któremu ufa się wyłącznie ze względu na jego narzędzia.
• Metadane udostępniania plugin w shareContext. Gdy plugin jest udostępniany z workspace, payload linku udostępniania ujawnia teraz metadane linku (twórcę, zakres, aktualność), dzięki czemu sesje odbierające mogą pokazać pochodzenie i zdecydować, czy zaakceptować udostępnienie.
• Kontrola wykrywalności w ustawieniach udostępniania. Ustawienia udostępniania udostępniają przełącznik wykrywalności, dzięki czemu zespoły mogą publikować plugins do konkretnych workspace lub list odbiorców bez udostępniania ich jako ogólnie listowalnych w całej organizacji.

Źródła plugins

Odkrywanie plugins

Codex informuje model, które plugins są włączone na początku sesji (v0.111.0), co ułatwia odkrywanie zainstalowanych MCPs, aplikacji i skills.⁶⁵ Model może sugerować odpowiednie plugins podczas sesji na podstawie kontekstu zadania. W v0.117.0 plugins ograniczone do produktu są synchronizowane przy uruchomieniu, dzięki czemu najnowszy katalog plugins jest dostępny bez ręcznej interwencji.⁷⁵ Od v0.142.0 menu /plugins organizuje zdalne plugins w sekcje OpenAI Curated, Workspace i Shared with me, a kwalifikujące się tury mogą polecać i instalować odpowiednie plugins inline.¹⁰⁴

Wzmianki @plugin (v0.112.0+)

Można odwołać się bezpośrednio na czacie do dowolnego zainstalowanego plugin za pomocą @plugin-name.⁶⁸ Gdy plugin zostanie wspomniany, jego kontekst (możliwości, narzędzia, konfiguracja) jest automatycznie dołączany do okna kontekstu modelu — nie trzeba opisywać, co dany plugin robi.

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

Działa to z dowolnym zainstalowanym plugin, w tym z niestandardowymi skills, serwerami MCP i app connectors.

Plugin Marketplace (v0.113.0+)

Plugin marketplace obejmuje teraz bogatsze odkrywanie z metadanymi, kategoriami i ocenami.⁶⁹ Kontrole uwierzytelniania podczas instalacji sprawdzają, czy plugins wymagające kluczy API lub OAuth mają poprawne dane uwierzytelniające przed instalacją. Endpoint odinstalowywania czysto usuwa plugins i powiązaną z nimi konfigurację.

Dodawanie marketplace innych firm (v0.121.0+)

Aktualna dokumentacja OpenAI Codex utrzymuje zarządzanie źródłami marketplace pod codex plugin marketplace. Formalizuje to dystrybucję plugins innych firm poza własnym marketplace OpenAI i obsługuje skróty repozytoriów GitHub, URL-e Git HTTP(S), URL-e SSH oraz lokalne katalogi główne marketplace; należy użyć --ref, aby przypiąć Git ref, i powtarzać --sparse PATH tylko dla repozytoriów marketplace opartych na Git.⁹³

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

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

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

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

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

Po dodaniu plugins z danego marketplace pojawiają się w przeglądarce /plugins obok domyślnych. Wywołania app-server (integracje IDE/desktop) mają równoległy endpoint do programowej rejestracji marketplace.⁸²

Kwestia bezpieczeństwa: Marketplace innych firm uruchamiają dowolny kod plugin z uprawnieniami Codex. Przed dodaniem należy zweryfikować źródła i preferować wykonywanie w sandboxie podczas pierwszych uruchomień.

Zarządzanie plugins

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

W TUI należy użyć /plugins (v0.117.0+), aby interaktywnie przeglądać, instalować i usuwać poszczególne plugins bez opuszczania sesji.⁷⁵

Wskazówka ekspercka: Plugins konsolidują to, co wcześniej wymagało osobnej konfiguracji MCP, instalacji skills i konfiguracji app connectors. Jeden plugin może zawierać wszystkie trzy elementy — przyspieszając wdrażanie zespołu i zwiększając przenośność konfiguracji.

Plan Mode i współpraca

Plan mode pozwala Codex zaprojektować podejście przed wykonaniem zmian. Jest włączony domyślnie (od v0.94.0).¹⁴ Zobacz ramy decyzyjne, aby poznać drzewo decyzyjne „Plan Mode vs Direct Execution”.

Wejście w Plan Mode

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

W plan mode Codex: - Czyta pliki i analizuje codebase - Proponuje plan implementacji - Nie wprowadza zmian bez zatwierdzenia - Strumieniuje plan w dedykowanym widoku TUI

Steer Mode

Steer mode (włączony domyślnie od v0.98.0) pozwala wstrzykiwać nowe instrukcje, gdy Codex aktywnie pracuje, bez przerywania bieżącego zadania.¹⁴

Istnieją dwie metody wstrzykiwania:

Praktyczne przykłady:

# Codex is refactoring the auth module...

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

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

Steer mode jest zawsze aktywny w TUI. Jeśli woli Pan/Pani poczekać z instrukcjami do zakończenia pracy przez Codex, wystarczy pisać normalnie po zakończeniu tury — specjalny tryb nie jest potrzebny.

Ulepszenia TUI (v0.105.0–v0.106.0)

Podświetlanie składni (v0.105.0): TUI podświetla teraz składnię bloków kodu w ogrodzeniu i diffów inline. Użyj /theme, aby wybrać schemat kolorów.⁶¹

Nowe polecenia TUI (v0.105.0+):⁶¹

Transkrypcja głosowa (v0.105.0, eksperymentalna): Naciśnięcie spacji pozwala dyktować prompty za pomocą transkrypcji głosowej. Ta funkcja jest eksperymentalna i może wymagać uprawnień do mikrofonu.⁶¹ Od v0.107.0 sesje głosowe w czasie rzeczywistym obsługują wybór mikrofonu i głośnika, co pozwala wskazać konkretne urządzenia wejścia/wyjścia audio.⁶² Usunięto w v0.140.0: eksperymentalne kontrolki głosowe /realtime i ich zależności audio zostały usunięte z TUI; nie wpływa to na transkrypcję głosową wywoływaną spacją.¹⁰²

Inne ulepszenia: - Długie linki pozostają teraz klikalne nawet po zawinięciu między wierszami TUI (v0.105.0)⁶¹ - Linki do lokalnych plików renderują się z lepszym formatowaniem (v0.106.0)⁶⁰ - Markdown w TUI zachowuje klikalność linków webowych dzięki metadanym OSC 8, a ciasne tabele przechodzą na czytelne rekordy klucz/wartość bez utraty celów linków (v0.136.0)¹⁰⁸ - Obsługa Ctrl+C dla sub-agents została naprawiona tak, aby poprawnie kończyć procesy potomne (v0.106.0)⁶⁰

System pamięci

Codex ma trwały system pamięci (v0.100.0+), który przechowuje fakty, preferencje i kontekst projektu między sesjami.²⁴

Polecenia pamięci

Wpisy pamięci są przechowywane w plikach markdown w ~/.codex/memory/. Codex ładuje je przy starcie sesji i wykorzystuje do kształtowania zachowania we wszystkich przyszłych sesjach.

Co przechowywać

Pamięć najlepiej sprawdza się przy trwałych preferencjach i faktach o projekcie:

• Konwencje projektu: „Ten projekt używa tabulatorów, a nie spacji” albo „odpowiedzi API zawsze zawierają pole meta”
• Preferencje narzędzi: „Używaj pnpm zamiast npm” albo „Uruchamiaj testy za pomocą pytest -x --tb=short”
• Decyzje architektoniczne: „Moduł auth znajduje się w src/core/auth/, a nie w src/middleware/”
• Preferencje workflow: „Zawsze uruchamiaj linter przed pokazaniem mi diff”

Pamięć w pipeline’ach

Podczas uruchamiania codex exec wpisy pamięci są ładowane automatycznie. Oznacza to, że pipeline’y CI/CD i skrypty korzystają z tego samego kontekstu co sesje interaktywne — nie trzeba powtarzać instrukcji przy każdym wywołaniu.

Ulepszenia pamięci (v0.101.0–v0.107.0)

• Sanityzacja sekretów: wpisy pamięci są automatycznie skanowane pod kątem sekretów przed zapisaniem na dysku
• Świadomość CWD: pliki pamięci zawierają teraz kontekst katalogu roboczego dla przypominania specyficznego dla projektu
• Wykluczenie wiadomości deweloperskich: wiadomości deweloperskie/systemowe są wykluczane z wejścia pamięci fazy 1, co poprawia jakość pamięci dzięki skupieniu na interakcjach użytkownika
• Zapominanie oparte na diff (v0.106.0): pamięć używa teraz zapominania opartego na diff do usuwania nieaktualnych faktów, dzięki czemu magazyn pamięci pozostaje z czasem zwięzły i istotny⁶⁰
• Wybór świadomy użycia (v0.106.0): pobieranie z pamięci uwzględnia teraz użycie, priorytetyzując często wykorzystywane i niedawno istotne wpisy pamięci⁶⁰
• Konfigurowalne wpisy pamięci (v0.107.0): pamięć jest teraz w pełni konfigurowalna. Można użyć codex debug clear-memories, aby zresetować wszystkie zapisane wpisy pamięci i zacząć od czystego stanu — przydatne przy przełączaniu kontekstu między niepowiązanymi projektami albo gdy stan pamięci się rozjechał⁶²
• Aktualizacja modelu fazy 2 (v0.121.0): model konsolidacji pamięci fazy 2 to teraz gpt-5.4 (wcześniej używano poprzedniej wartości domyślnej). Pipeline fazy 2 działa między sesjami, destylując transkrypty fazy 1 do trwałych faktów; zmiana modelu poprawia jakość przypominania przy tym samym koszcie tokenów.⁸²
• Menu pamięci w TUI (v0.121.0): nowy interfejs w trakcie sesji udostępnia tryb pamięci, usuwanie pojedynczych wpisów pamięci oraz przycisk resetowania. Reset pamięci teraz zachowuje wcześniejsze rollouts zamiast je unieważniać, więc reset czyści przyszłą powierzchnię przypominania bez psucia odtwarzania sesji.⁸²

Pamięć a AGENTS.md

Wskazówka: Warto używać /m_update dla faktów, które mają przetrwać bezterminowo. W przypadku kontekstu specyficznego dla sesji wystarczy powiedzieć o nim Codex bezpośrednio w rozmowie. Do współdzielonego kontekstu zespołu należy używać AGENTS.md.

Zarządzanie sesjami

Codex zapisuje sesje w ~/.codex/sessions/, umożliwiając wznawianie, forking oraz wielowątkowe workflow na powierzchniach CLI i desktopowych.

Wznawianie

Kontynuacja od miejsca przerwania:

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

Polecenie slash /resume wewnątrz TUI otwiera ten sam interaktywny selektor z wyszukiwaniem.

Fork

Rozgałęzienie rozmowy pozwala eksplorować alternatywy bez utraty bieżącego postępu:

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

Forki tworzą niezależne wątki, które współdzielą tę samą historię do punktu rozgałęzienia. Zmiany w jednym forku nie wpływają na drugi. Jest to przydatne przy porównywaniu podejść (np. „utwórz fork i spróbuj Redis zamiast Memcached”) albo przy bezpiecznej eksploracji ryzykownych zmian.

Forking wątków do sub-agentów (v0.107.0): Wątki można teraz forkować do niezależnych sub-agentów, co pozwala rozmowie uruchamiać równoległe strumienie pracy wykonywane autonomicznie. Rozszerza to istniejący model forków — zamiast samego rozgałęzienia rozmowy, sforkowany wątek staje się sub-agentem z własnym kontekstem wykonania.⁶² Od v0.117.0 sub-agenci używają adresów opartych na ścieżkach (np. /root/agent_a) wraz ze strukturalną komunikacją między agentami, dzięki czemu koordynacja wielu agentów jest bardziej jawna i łatwiejsza do debugowania.⁷⁵

Lista wątków

Wyświetlanie aktywnych sesji i zarządzanie nimi:

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

W aplikacji desktopowej wątki są widoczne na pasku bocznym z pełną historią i podglądami diff.

Cykl życia sesji

Sesje synchronizują się między CLI a aplikacją desktopową — można zacząć w jednym miejscu i kontynuować w drugim.

Tryb nieinteraktywny (codex exec)

codex exec uruchamia Codex nieinteraktywnie na potrzeby skryptów, CI/CD i automatyzacji.¹⁵

Podstawowe użycie

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

Domyślnie codex exec zapisuje postęp/zdarzenia do stderr, a końcowy komunikat agenta do stdout. Taka konstrukcja ułatwia łączenie ze standardowymi potokami Unix.

Archiwizowanie sesji (v0.136.0)

Sesje można archiwizować, aby lista wznawiania/forków pozostała uporządkowana bez usuwania historii. Archiwizowanie można wykonać z TUI za pomocą /archive albo z shell:¹⁰⁸

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

Zarchiwizowana sesja jest chroniona przed operacjami wznawiania lub forka, dopóki nie zostanie odarchiwizowana — to zabezpieczenie przed przypadkowym kontynuowaniem sesji, która miała zostać zakończona. W tej samej wersji: codex app-server --stdio uruchamia app-server w trybie stdio na potrzeby integracji z edytorami/hostami, a /diff nie może już uruchamiać dostarczonych przez repozytorium helperów Git (poprawka bezpieczeństwa poleceń). W Windows ścieżka provisioningu w wersji alpha dodaje codex sandbox setup --elevated dla administratorów.¹⁰⁸

Wynik w liniach JSON

Z --json strumień stdout staje się strumieniem zdarzeń JSONL:

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

Typy zdarzeń: 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}}

Wynik strukturalny

Wymuś kształt odpowiedzi za pomocą JSON Schema:

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

-o / --output-last-message zapisuje końcowy komunikat do pliku.

Wznawianie i przegląd sesji

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

Kluczowe flagi

Uwierzytelnianie w CI

codex exec obsługuje CODEX_API_KEY do nieinteraktywnego uwierzytelniania w środowiskach automatyzacji.

Baner startowy codex exec (v0.130.0). Baner startowy codex exec nie wyświetla już starszego sformułowania „research preview”. Jeśli CI pobiera dane z wyjścia startowego, tekst banera jest teraz krótszy; strukturalne zdarzenia --json pozostają bez zmian.⁹¹

codex remote-control (v0.130.0+)

codex remote-control to polecenie najwyższego poziomu, które uruchamia bezgłowy app-server przeznaczony do sterowania przez inny proces — rozszerzenia IDE, niestandardowe orkiestratory lub zdalne płaszczyzny sterowania. Zastępuje wieloflagowe wywołanie codex app-server, które wielu integratorów składało ręcznie, i daje narzędziom zewnętrznym pojedynczy, stabilny punkt wejścia do tego samego środowiska wykonawczego app-server, które jest dostarczane w powierzchniach desktopowych i IDE.⁹¹ v0.133.0 poprawia kształt wykonawczy tego polecenia: może działać jak polecenie pierwszoplanowe, czekać na gotowość, raportować status maszyny i nadal udostępniać jawne polecenia w stylu daemon start / stop dla długotrwałych konfiguracji kontrolera.⁹⁸

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

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

Warto łączyć codex remote-control z poniższymi APIs paginacji app-server podczas budowania UI, które muszą wyliczać obszerne historie wątków bez ładowania każdej tury do pamięci naraz.

Paginacja wątków app-server (v0.130.0+)

Klienci app-server mogą teraz stronicować duże wątki przez trzy odrębne widoki elementów tur:⁹¹

Paginację warto połączyć z interfejsem ThreadStore wprowadzonym w v0.121.0, aby wydajnie przechodzić przez długotrwałe wątki, zwłaszcza we wdrożeniach remote-control, w których orkiestrator może działać na innej maszynie niż pliki rollout.⁸²

Odświeżanie konfiguracji app-server na żywo (v0.130.0+)

Aktywne wątki app-server przejmują teraz zmiany w config.toml bez konieczności restartu — należy edytować konfigurację, zapisać ją, a działający wątek odzwierciedli nowe wartości przy następnej turze. To odpowiednik poprawki błędu dla codex remote-control: długotrwały bezgłowy serwer można rekonfigurować w miejscu, zamiast go zatrzymywać i uruchamiać od nowa.⁹¹

Szyfrowane zdalne executors (v0.141.0)

Od v0.141.0 (stable, 18 czerwca 2026) zdalne executors łączą się przez uwierzytelnione, szyfrowane end-to-end kanały Noise-relay — płaszczyzna sterowania i executor nie muszą już ufać przekaźnikowi znajdującemu się między nimi, co ma znaczenie zawsze wtedy, gdy orkiestrator steruje app-server przez granicę sieciową. Ta sama wersja sprawiła, że zdalne wykonywanie międzyplatformowe zachowuje natywny katalog roboczy i shell executora, więc kontroler w jednym OS, sterujący executorem w innym, nie ma już po drodze przepisywanych ścieżek ani semantyki shell. TLS akceptuje teraz również podpisy certyfikatów P-521 w celu zgodności z enterprise-proxy.¹⁰³

Codex Cloud i zadania w tle [EXPERIMENTAL]

Status: Codex Cloud jest funkcją eksperymentalną. Interfejsy, ceny i dostępność mogą się zmienić. OpenAI zarządza środowiskami chmurowymi, a użytkownik nie kontroluje infrastruktury.

Codex Cloud uruchamia zadania asynchronicznie w środowiskach zarządzanych przez OpenAI.⁴ Zobacz także GitHub Action i CI/CD, aby zintegrować Codex z potokiem CI.

Jak to działa

1. Przesłanie zadania (przez chatgpt.com/codex, integrację Slack lub CLI)
2. Codex klonuje repozytorium do izolowanego cloud sandbox
3. Agent pracuje niezależnie: czyta kod, uruchamia testy, wprowadza zmiany
4. Po zakończeniu Codex tworzy PR lub udostępnia diff do przeglądu
5. Wyniki można zastosować lokalnie za pomocą codex apply <TASK_ID>

Dostęp do internetu w chmurze

Internet agenta jest domyślnie wyłączony i konfigurowany dla każdego środowiska:

• Wyłączony: Brak dostępu agenta do internetu (domyślnie)
• Włączony: Opcjonalna lista dozwolonych domen + ograniczenia metod HTTP

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

Skrypty konfiguracyjne nadal mogą korzystać z internetu do instalowania zależności, nawet gdy internet agenta jest wyłączony.

Integracja ze Slack

Wzmianka @Codex w kanale lub wątku Slack uruchamia zadanie w chmurze.

Wymagania wstępne: 1. Kwalifikujący się plan ChatGPT (Plus, Pro, Business, Enterprise lub Edu) 2. Połączone konto GitHub 3. Co najmniej jedno skonfigurowane środowisko chmurowe 4. Aplikacja Slack zainstalowana w workspace

Codex odpowiada linkiem do zadania i publikuje wyniki po zakończeniu.

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)

Aplikacja Codex Desktop

Aplikacja desktopowa Codex (macOS i Windows) zapewnia graficzny interfejs zoptymalizowany pod kątem zarządzania wieloma projektami.¹⁶ Wersja dla Windows została uruchomiona 4 marca 2026 z natywną obsługą PowerShell i natywnym sandboxem Windows.⁶⁶

Instalacja

codex app                      # Auto-downloads and installs on first run

Lub pobrać bezpośrednio: Codex.dmg (macOS) | Dostępne w Microsoft Store (Windows)

Kluczowe funkcje

Appshots, komentarze w przeglądarce i Computer Use

Aktualizacje aplikacji z 21 maja sprawiają, że aplikacja desktopowa staje się mocniejszą powierzchnią kontekstową, a nie tylko menedżerem wątków. Warto używać Appshots, gdy Codex potrzebuje stanu innej aplikacji Mac, zanim będzie mógł działać: Codex przechwytuje okno znajdujące się na wierzchu, dostępny widoczny/pozaekranowy tekst udostępniany przez aplikację i przechowuje załącznik lokalnie w historii sesji.⁹⁹

W pracy nad webem i frontendem należy najpierw użyć przeglądarki w aplikacji, gdy strona nie wymaga uwierzytelnienia: daje ona Codex i użytkownikowi wspólny wyrenderowany podgląd, obsługuje działania typu browser-use, takie jak klikanie, zrzuty ekranu, pobieranie zasobów i inspekcja JavaScript w trybie tylko do odczytu, a także pozwala oznaczać regiony strony komentarzami, które Codex może uwzględnić w kolejnej turze.⁹⁹ W przypadku witryn wymagających logowania należy nadal korzystać z rozszerzenia Chrome.

Z Computer Use należy korzystać tylko wtedy, gdy ustrukturyzowana integracja lub podgląd w przeglądarce nie mogą zweryfikować zadania. Funkcja może sprawdzać i obsługiwać dozwolone aplikacje Mac, ale dziedziczy zatwierdzenia Codex oraz reguły sandboxa dotyczące edycji plików i poleceń powłoki, a użycie po zablokowaniu pozostaje wąskie: Codex może tymczasowo uzyskać dostęp do dozwolonych aplikacji podczas aktywnych, zaufanych tur Computer Use po zablokowaniu Maca, z zabezpieczeniami ponownego blokowania i wykrywaniem lokalnego wejścia.⁹⁹

Tryby wątków

Każdy wątek działa w jednym z trzech trybów wybieranych podczas jego tworzenia:

Mechanika izolacji Worktree:

Po rozpoczęciu wątku Worktree aplikacja desktopowa: 1. Tworzy nowy git worktree (git worktree add) w katalogu tymczasowym 2. Przełącza się na świeżą gałąź z bieżącego HEAD 3. Uruchamia agenta wewnątrz worktree — wszystkie zmiany plików są izolowane 4. Po zakończeniu przedstawia przegląd diffów — można wybrać, które zmiany scalić z powrotem

Oznacza to, że wiele wątków Worktree może działać jednocześnie na tym samym repozytorium bez konfliktów. Każdy otrzymuje własną gałąź i katalog roboczy.

Automations

Automations działają lokalnie w aplikacji, więc aplikacja musi być uruchomiona, a projekt dostępny na dysku:

• W repozytoriach Git automations używają dedykowanych worktrees działających w tle (odizolowanych od katalogu roboczego)
• W projektach bez Git uruchomienia wykonywane są bezpośrednio w katalogu projektu
• Automations używają domyślnych ustawień sandboxa

Konfigurowanie automation: 1. Otworzyć projekt w aplikacji desktopowej 2. Kliknąć kartę Automations na pasku bocznym 3. Zdefiniować wyzwalacz (harmonogram, webhook lub ręczny) 4. Napisać prompt i wybrać tryb wykonania (local lub worktree) 5. Ustawić poziom reasoning dla uruchomienia automation (App v26.312)⁷² 6. Automations działają według harmonogramu i kolejkują wyniki do przeglądu

Przykładowe zastosowania: - Triage zgłoszeń: Automatyczne kategoryzowanie i priorytetyzowanie nowych zgłoszeń - Monitorowanie CI: Obserwowanie niepowodzeń buildów i sugerowanie poprawek - Reakcja na alerty: Reagowanie na alerty monitoringu analizą diagnostyczną - Aktualizacje zależności: Sprawdzanie i stosowanie poprawek bezpieczeństwa

Wyniki pojawiają się w kolejce przeglądu do zatwierdzenia przez człowieka.

Obsługa Windows

Aplikacja Codex Desktop została uruchomiona na Windows 4 marca 2026 (App v26.304) z natywną obsługą PowerShell, natywnym sandboxem Windows i pełną zgodnością funkcji, w tym skills, automations i worktrees, bez wymagania WSL.⁶⁶

GitHub Action i CI/CD

Oficjalna GitHub Action integruje Codex z pipeline’em CI/CD.¹⁸

Podstawowe użycie

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

Opcje konfiguracji

Wyjście: final-message, końcowy tekst odpowiedzi Codex dla kolejnych kroków/zadań.

Strategie bezpieczeństwa

Kontrole dostępu

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

Domyślnie: tylko współpracownicy z dostępem do zapisu mogą wyzwalać workflow Codex.

Codex SDK

TypeScript SDK osadza możliwości agentowe Codex w aplikacjach niestandardowych.¹⁹

Instalacja

npm install @openai/codex-sdk

Podstawowe użycie

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

Zaawansowane funkcje SDK

• runStreamed(...): Asynchroniczny strumień zdarzeń dla aktualizacji pośrednich
• Uwierzytelnianie Python SDK (v0.132.0+): Logowanie kluczem API, przepływy ChatGPT w przeglądarce / z kodem urządzenia, inspekcja konta i wylogowanie są pełnoprawnymi ścieżkami SDK.⁹⁷
• Udogodnienie dla tur wyłącznie tekstowych (v0.132.0+): API tur Python przyjmują zwykłe ciągi tekstowe i zwracają bogatsze metadane TurnResult z zebranymi elementami, czasem wykonania i użyciem.⁹⁷
• outputSchema: Wymuszanie końcowego wyniku w kształcie JSON
• Wejście multimodalne: Przekazywanie tekstu + lokalnych obrazów ({ type: "local_image", path: "..." })
• Przepływy obrazów (v0.117.0): view_image zwraca adresy URL, wygenerowane obrazy można ponownie otwierać, a historia obrazów pozostaje dostępna po wznowieniu sesji⁷⁵
• Wielośrodowiskowe view_image (v0.130.0): W sesjach obejmujących wiele środowisk (wprowadzonych w v0.124.0 wraz z wyborem środowiska i katalogu roboczego dla każdej tury, dopracowanych w v0.125.0 dzięki trwałym środowiskom) view_image rozwiązuje teraz ścieżki plików przez wybrane środowisko, a nie przez lokalny system plików orkiestratora. Obraz dołączony ze zdalnego środowiska jest pobierany względem katalogu roboczego tego środowiska, a nie hosta uruchamiającego SDK.⁹¹

Konfiguracja wątku i klienta

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

Sesje są utrwalane w ~/.codex/sessions.

Środowisko uruchomieniowe: Node.js 18+.

Optymalizacja wydajności

Zarządzanie kontekstem

Okna kontekstu różnią się w zależności od modelu. Stan na kwiecień 2026: GPT-5.5 w Codex oferuje 400K (1M w API). GPT-5.4 / GPT-5.4-mini oferują odpowiednio 1M / 400K (odpowiednik API w Codex). Rodzina GPT-5.3-Codex / GPT-5.2-Codex działa z limitem 272K wejścia + 128K wyjścia (400K całkowitego budżetu). Wszystkie zapełniają się szybciej, niż można oczekiwać — należy zarządzać nimi proaktywnie:

1. Regularnie używać /compact: Podsumowuje historię rozmowy, aby zwolnić tokeny
2. Dostarczać lokalną dokumentację: Wysokiej jakości AGENTS.md i lokalna dokumentacja zmniejszają narzut eksploracji (który zużywa kontekst)
3. Używać @ do dołączania konkretnych plików: Odwoływać się bezpośrednio do plików zamiast prosić Codex o ich znalezienie
4. Utrzymywać prompt w wąskim zakresie: Prompty o określonym zakresie z dokładnymi plikami zużywają mniej kontekstu niż otwarta eksploracja

Efektywność tokenów

Optymalizacja szybkości

1. gpt-5.3-codex-spark: Wariant o niższym opóźnieniu do interaktywnej pracy w parze
2. --profile fast: Wstępnie skonfigurowany model mini z niskim reasoning
3. Równoległe wykonywanie narzędzi: Codex wykonuje niezależne odczyty/kontrole współbieżnie, dlatego warto tak strukturyzować prompty, aby to umożliwić
4. Pętle sterowane wynikiem: Prosić o „implement, test, fix, stop when green” zamiast podawać instrukcje krok po kroku

Jak debugować problemy?

Typowe problemy i rozwiązania

Referencja komunikatów błędów

Narzędzia diagnostyczne

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

Diagnostyka TUI w sesji:

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

Uwaga: codex --verbose nie jest prawidłową flagą najwyższego poziomu. Należy użyć powyższych podpoleceń debugowania i diagnostyki TUI.

Czysta reinstalacja

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

Tryb debugowania

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

Zgłaszanie problemów

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

Można też zgłaszać problemy pod adresem github.com/openai/codex/issues.¹

Codex Security [PREVIEW]

Codex Security wszedł w research preview 6 marca 2026, wprowadzając do stosu Codex kontekstowy przegląd bezpieczeństwa aplikacji.⁷⁷ Jest dostępny dla klientów ChatGPT Pro, Enterprise, Business i Edu przez Codex web.

Jak to działa: Codex Security analizuje repozytoria, aby zbudować model zagrożeń specyficzny dla projektu, identyfikuje podatności sklasyfikowane według realnego wpływu i testuje ustalenia w środowisku sandbox, aby je zweryfikować. Agent pokazuje ustalenia o wyższym poziomie pewności wraz z poprawkami, ograniczając szum powodowany przez nieistotne błędy.

Wydajność: W trakcie research preview Codex Security przeskanował 1,2 miliona commitów i zidentyfikował 10 561 podatności o wysokiej wadze. Precyzja poprawiała się z czasem — szum zmniejszono o 84%, zawyżanie poziomu ważności ograniczono o ponad 90%, a odsetek wyników fałszywie pozytywnych zmniejszono o połowę. System znalazł realne podatności w OpenSSH, GnuTLS i Chromium, a przypisano mu 14 CVE.⁷⁷

Uwaga: Codex Security jest odrębny od wbudowanego modelu bezpieczeństwa sandbox w CLI. Sandbox chroni komputer przed Codex; Codex Security chroni bazę kodu przed podatnościami.

Wdrożenie w przedsiębiorstwie

Kontrole administracyjne (requirements.toml)

Administratorzy egzekwują zasady organizacyjne za pomocą requirements.toml, pliku konfiguracji wymuszanej administracyjnie, który ogranicza ustawienia wrażliwe pod względem bezpieczeństwa, których użytkownicy nie mogą nadpisać:²¹

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

W przeciwieństwie do config.toml na poziomie użytkownika, który ustawia preferencje, requirements.toml jest warstwą twardych ograniczeń: zawęża wartości, które użytkownicy mogą wybrać, i nie może zostać przez nich nadpisany. Reguły wymagań administracyjnych mogą tylko prompt albo forbid (nigdy po cichu zezwalać).

Konfiguracja macOS MDM

Dystrybucja odbywa się przez MDM z użyciem domeny preferencji com.openai.codex.²¹ Codex respektuje standardowe ładunki macOS MDM (Jamf Pro, Fleet, Kandji itd.). TOML należy zakodować jako base64 bez zawijania wierszy:

Priorytet (od najwyższego do najniższego):

1. Zarządzane preferencje macOS (MDM)
2. Wymagania pobrane z chmury (ChatGPT Business / Enterprise)
3. /etc/codex/requirements.toml (lokalny system plików)

Wymagania z chmury wypełniają tylko nieustawione pola wymagań, więc warstwy zarządzane o wyższym priorytecie zawsze mają pierwszeństwo. Wymagania z chmury działają na zasadzie best-effort; jeśli pobieranie się nie powiedzie albo upłynie limit czasu, Codex kontynuuje działanie bez warstwy chmurowej.

Integracja z OpenTelemetry

Codex obsługuje propagację kontekstu śledzenia OpenTelemetry ze standardowych zmiennych środowiskowych OTel aż do wywołań OpenAI API. Przed uruchomieniem Codex należy ustawić standardowe zmienne środowiskowe:

# 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

• Respektowane są standardowe zmienne środowiskowe OTEL_* (endpoint, nazwa usługi, atrybuty zasobów)
• Kontekst śledzenia propaguje się przez Codex do wywołań API, umożliwiając obserwowalność end-to-end
• Atrybutów zasobów można używać do oznaczania śladów według zespołu, środowiska lub projektu
• Przy włączaniu logowania promptów/narzędzi należy pamiętać o wymaganiach prywatności — ślady mogą zawierać fragmenty kodu
• Konfigurowalne metadane śladów OpenTelemetry (v0.130.0+). Poza standardową otoczką OTEL_RESOURCE_ATTRIBUTES crate codex-otel udostępnia teraz konfigurowalne metadane śladów, dzięki czemu administratorzy mogą oznaczać ślady wymiarami specyficznymi dla organizacji (centrum kosztów, ID projektu, odwołanie do zgłoszenia) bez przebudowywania OTEL_RESOURCE_ATTRIBUTES od zera przy każdym wywołaniu. Warto połączyć to z bogatszą analityką przeglądów i opinii dostarczoną w tym samym wydaniu, aby uzyskać spójne debugowanie i triage w sesjach CLI, app-server oraz remote-control.⁹¹

Dostęp w przedsiębiorstwie

• ChatGPT Business / Enterprise / Edu: Dostęp kontrolowany przez administratora organizacji, z automatycznie stosowanymi wymaganiami pobieranymi z chmury. Obsługuje SSO przez SAML/OIDC za pośrednictwem dostawcy tożsamości (Okta, Entra ID itd.)
• API: Standardowe uwierzytelnianie, rozliczenia oraz kontrole organizacji/projektu dla API. OpenAI publikuje raporty SOC 2 Type II i SOC 3; HIPAA BAA jest dostępne dla warstwy Enterprise
• Codex SDK: Osadzanie w narzędziach wewnętrznych i przepływach pracy
• Egzekwowanie zasad na dużą skalę: Należy używać requirements_toml_base64 dystrybuowanego przez MDM albo /etc/codex/requirements.toml na poziomie systemu plików

Obsługa danych i zgodność: - Dane wejściowe/wyjściowe API nie są używane do trenowania zgodnie z warunkami OpenAI Business/Enterprise/API - W przypadku rezydencji danych ruch OpenAI API domyślnie przechodzi przez infrastrukturę w USA; w sprawie wymagań dotyczących rezydencji danych w UE należy skonsultować się z zespołem sprzedaży Enterprise OpenAI - Transkrypcje sesji są przechowywane lokalnie; poza urządzenie wychodzą tylko wywołania API - ChatGPT Enterprise obsługuje ramy zgodności, w tym SOC 2, GDPR i CCPA

Strategia wdrożenia

Zalecane etapowe wdrożenie dla organizacji:

1. Pilotaż (tydzień 1-2): Wdrożyć u 3-5 starszych inżynierów z requirements.toml wymuszającym tryb sandbox untrusted oraz wyszukiwanie w sieci cached. Zebrać opinie o wzorcach AGENTS.md i potrzebach serwera MCP.
2. Rozszerzenie na zespół (tydzień 3-4): Wdrożyć w całym zespole. Rozprowadzić zespołowy standard config.toml przez MDM albo repozytorium. Włączyć sandbox workspace-write dla zaufanych repozytoriów.
3. Integracja CI (tydzień 5-6): Dodać codex-action do potoków CI/CD na potrzeby automatycznego przeglądu PR i generowania testów. Użyć --ephemeral, aby utrzymać przewidywalne koszty.
4. Cała organizacja (miesiąc 2+): Wdrożyć przez MDM z requirements.toml wymuszającym zatwierdzone serwery MCP, zasady sandbox oraz allowlisty modeli.

Wzorce audytu

Śledzenie użycia Codex i egzekwowanie zgodności:

• Ślady OpenTelemetry: Monitorowanie wolumenu wywołań API, użycia tokenów i opóźnień dla każdego zespołu
• Trwałość sesji: Audyt ~/.codex/sessions/ na potrzeby przeglądu zgodności (w kontekstach wrażliwych można wyłączyć za pomocą --ephemeral)
• Egzekwowanie tożsamości MCP: requirements.toml rejestruje zablokowane próby użycia serwera — należy je przeglądać pod kątem nieautoryzowanego użycia narzędzi
• Ścieżka audytu Git: Wszystkie zmiany plików wprowadzane przez Codex przechodzą przez standardowy git — należy je przeglądać przez historię gałęzi i diffy PR

Najlepsze praktyki i antywzorce

Wzorce promptowania

1. Prompty oparte na ograniczeniach: Zacząć od granic. „NIE zmieniać kontraktów API. Refaktoryzować wyłącznie wewnętrzną implementację”.
2. Ustrukturyzowane kroki odtworzenia: Numerowane kroki dają lepsze poprawki błędów niż ogólne opisy
3. Prośby o weryfikację: Zakończyć słowami „Uruchomić lint + najmniejszy odpowiedni zestaw testów. Zgłosić polecenia i wyniki”.
4. Odwołania do plików: Używać @filename, aby dołączyć konkretne pliki do kontekstu
5. Pętle oparte na rezultacie: „Zaimplementować, uruchomić testy, naprawić błędy, zatrzymać się dopiero, gdy wszystkie testy przejdą”. Codex iteruje aż do zakończenia

Filozofia testowania

Społeczność skłania się ku współpracy z AI opartej na testach:²²

• Definiować testy z góry jako sygnały ukończenia
• Pozwolić Codex iterować, aż testy przejdą (red → green → refactor)
• Przyjąć wzorce programowania Tiger Style
• Podawać dokładną treść pliku przy prośbach o patche. Codex używa ścisłego dopasowania, a nie rozmytego patchowania opartego na AST

Najlepsze praktyki zarządzania kontekstem

• Dostarczać wysokiej jakości lokalną dokumentację zamiast polegać na wyszukiwaniu w sieci
• Utrzymywać ustrukturyzowany markdown ze spisami treści i plikami postępu („progressive disclosure”)
• Normalizować końce linii (LF vs CRLF) we wszystkich śledzonych plikach, aby zapobiegać niepowodzeniom patchy
• Utrzymywać AGENTS.md w zwięzłej formie, ponieważ długie instrukcje wypadają z kontekstu

Workflow Git

• Zawsze tworzyć nową gałąź przed uruchomieniem Codex na nieznanych repozytoriach
• Używać workflow opartych na patchach (git diff / git apply) zamiast bezpośrednich edycji
• Przeglądać sugestie Codex tak jak PR-y w code review
• Używać /diff, aby zweryfikować zmiany przed commitem

Społecznościowe skills i prompty

Repozytorium feiskyer/codex-settings udostępnia konfiguracje utrzymywane przez społeczność:²³

Prompty wielokrotnego użytku (w ~/.codex/prompts/): - deep-reflector: Wyodrębnianie wniosków z sesji programistycznych - github-issue-fixer [issue-number]: Systematyczna analiza błędów i tworzenie PR-ów - github-pr-reviewer [pr-number]: Workflow code review - ui-engineer [requirements]: Tworzenie frontendu klasy produkcyjnej

Społecznościowe skills: - claude-skill: Przekazywanie zadań do Claude Code z trybami uprawnień - autonomous-skill: Automatyzacja zadań obejmujących wiele sesji ze śledzeniem postępu - deep-research: Równoległa orkiestracja podzadań - kiro-skill: Pipeline wymagania → projekt → zadania → wykonanie

Antywzorce

Typowe błędy, które marnują tokeny, dają słabe wyniki albo tworzą frustrujące workflow.

Antywzorce kosztów

Antywzorce kontekstu

Antywzorce workflow

Antywzorce promptów

Przepisy workflow

Wzorce end-to-end dla typowych scenariuszy programistycznych.

Przepis 1: Konfiguracja nowego projektu

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

Przejrzeć wygenerowany AGENTS.md, edytować zgodnie z własnymi konwencjami, a następnie:

> Run the health endpoint test and confirm it passes

Przepis 2: Codzienny przepływ pracy programistycznej

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.

Przejrzeć za pomocą /diff, a następnie wykonać commit.

Przepis 3: Złożona refaktoryzacja w 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.

Przejrzeć plan. Zatwierdzić albo pokierować dalej:

[Tab] Also add a migration script using Alembic

Po wykonaniu przez Codex zweryfikować:

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

Przepis 4: Review PR za pomocą codex exec

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

Przepis 5: Debugowanie z 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."

Sprawdzić postęp później:

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

Zastosować poprawkę lokalnie po zakończeniu:

codex apply <TASK_ID>

Przewodnik migracji

Z Claude Code

Najważniejsze różnice, które należy zrozumieć:

• Sandbox działa na poziomie systemu operacyjnego: Codex używa Seatbelt/Landlock, a nie kontenerów. Ograniczenia działają na poziomie jądra, poniżej warstwy aplikacji.
• Hooks są rozwijane: Codex obsługuje teraz 5 zdarzeń hook: SessionStart, Stop i UserPromptSubmit (v0.114.0–v0.116.0, eksperymentalne) oraz AfterAgent (v0.99.0) i AfterToolUse (v0.100.0). System obejmuje cykl życia sesji, przechwytywanie promptów i automatyzację na poziomie narzędzi, choć ponad 12 zdarzeń cyklu życia w Claude Code nadal daje szerszy zakres. W przypadku wzorców automatyzacji, które nie są jeszcze obsługiwane, należy użyć instrukcji AGENTS.md lub skills.
• Sub-agents v2 (v0.117.0): Sub-agents używają teraz adresów opartych na ścieżkach (np. /root/agent_a) ze strukturalną komunikacją między agentami i listowaniem agentów.⁷⁵ Rozszerza to istniejący mechanizm (maks. 6 równoległych, zmniejszone z 12 w v0.91.0). Role wielu agentów pozostają konfigurowalne przez config (v0.104.0+).⁴⁷ W v0.105.0 dodano spawn_agents_on_csv do fanoutu po wierszach ze śledzeniem postępu i ETA.⁶¹ Codex nadal nie ma jawnego UX narzędzia Task z Claude Code do delegowania kierowanego przez użytkownika — dla wzorców delegowania należy używać cloud tasks lub orkiestracji SDK.
• AGENTS.md jest między narzędziami: Państwa AGENTS.md działa w Cursor, Copilot, Amp, Jules, Gemini CLI oraz w ponad 60 000 projektów open source. CLAUDE.md jest przeznaczony wyłącznie dla Claude.
• Profiles zastępują ręczne przełączanie: Zamiast zmieniać flagi przy każdym uruchomieniu, należy zdefiniować profiles w config.toml.

Z GitHub Copilot

Co można zyskać: - Sandbox na poziomie systemu operacyjnego (Seatbelt/Landlock — egzekwowany przez jądro, a nie oparty na kontenerach) - Delegowanie cloud tasks z codex apply - Profile config do przełączania przepływów pracy - Aplikację desktopową z izolacją worktree

Z Cursor

Szybka karta referencyjna

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

Dziennik zmian

Źródła

Uwaga dotycząca URL-i bloga OpenAI: Odwołania ¹⁶, ²⁵–³⁰, ³³, ⁶⁴, ⁶⁶, ⁶⁷, ⁷⁶ i ⁷⁷ prowadzą do wpisów blogowych openai.com/index/, które zwracają HTTP 403 przy dostępie automatycznym ze względu na ochronę przed botami Cloudflare. Te URL-e są prawidłowe po otwarciu w standardowej przeglądarce internetowej.