Codex CLI: Kompleksowa dokumentacja techniczna

TL;DR: Codex to działający na wielu powierzchniach agent programistyczny: czyta bazę kodu, uruchamia polecenia w sandboxie na poziomie systemu operacyjnego, modyfikuje pliki i deleguje zadania do chmury. Opanowanie pięciu systemów — config.toml, modelu sandboxa/zatwierdzania, AGENTS.md, MCP oraz skills — czyni go mnożnikiem produktywności. GPT-5.6 Sol jest zalecanym ustawieniem domyślnym (ustawienie „Power”, średni poziom rozumowania); GPT-5.5, flagowy model poprzedniej generacji, oferuje kontekst 400K w Codex i 1M w API.⁸³¹¹⁷ Dopiero zaczynasz? Przejdź od razu do sekcji Instalacja i Szybki start. Śledzisz wydania? Najnowsza stabilna wersja to v0.147.0 (7 sierpnia 2026 r.) — opis ostatnich wersji znajduje się w sekcji Najważniejsze zmiany w wydaniach, a wszystkie aktualizacje w Dzienniku zmian.¹¹⁶

Codex działa jako agent programistyczny dostępny na wielu powierzchniach, a nie chatbot piszący kod. CLI czyta bazę kodu, wykonuje polecenia w sandboxie, modyfikuje pliki, łączy się z usługami zewnętrznymi za pośrednictwem MCP i deleguje długotrwałe zadania do chmury. Działa lokalnie, lecz myśli globalnie; ta sama inteligencja napędza pięć odrębnych powierzchni, zależnie od sposobu pracy, w tym nowe rozszerzenie Chrome, które uruchamia Codex w przeglądarce, nie przejmując nad nią kontroli.⁹⁰

Różnicę między swobodnym a skutecznym korzystaniem z Codex tworzy pięć podstawowych systemów. Ich opanowanie sprawia, że Codex staje się mnożnikiem produktywności:

1. System konfiguracji: steruje zachowaniem za pomocą config.toml
2. Model sandboxa i zatwierdzania: określa, co Codex może robić
3. AGENTS.md: definiuje kontrakty operacyjne na poziomie projektu
4. Protokół MCP: rozszerza możliwości o usługi zewnętrzne
5. System skills: pakietuje wiedzę dziedzinową wielokrotnego użytku

Przez miesiące korzystałem z Codex równolegle z Claude Code w produkcyjnych bazach kodu, potokach CI/CD i przepływach pracy zespołów. Ten przewodnik destyluje te doświadczenia do kompletnego materiału referencyjnego, którego brakowało mi na początku. Każda funkcja zawiera rzeczywistą składnię, praktyczne przykłady konfiguracji oraz przypadki brzegowe, które potrafią zaskoczyć nawet doświadczonych użytkowników.

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, dlatego warto wybrać powierzchnię dopasowaną do własnego sposobu 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. Należy napisać je 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: rodzina GPT-5.6 (Sol, Terra, Luna) działa z oknem kontekstu 272K; GPT-5.5, flagowy model poprzedniej generacji, oferuje 400K w Codex i 1M w API. Aby proaktywnie zarządzać budżetem tokenów, warto używać /compact, precyzyjnych promptów i odwołań @file.⁸³¹¹²

Jak korzystać z tego przewodnika

To liczące ponad 3 300 wierszy kompendium — warto zacząć w miejscu odpowiadającym poziomowi doświadczenia:

Umieszczona na końcu karta szybkiego odniesienia zawiera łatwe do przejrzenia podsumowanie wszystkich głównych poleceń.

Najważniejsze zmiany w wydaniach: co zmieniło się ostatnio

Opis zmian według wersji dla osób śledzących cykl wydań Codex. Pierwsza wizyta? Proszę pominąć tę część i wrócić do niej po sekcji Szybki start — nic z niej nie jest niezbędne do produktywnej pracy.

GPT-5.6 Sol jest zalecanym domyślnym modelem w Codex — domyślne ustawienie „Power” ze średnim poziomem rozumowania, które można dostosować w kierunku Smarter lub Faster; GPT-5.5 (23 kwietnia 2026: kontekst 400K w Codex, 1M w API, 5 USD/30 USD za MTok, 82,7% Terminal-Bench 2.0 SOTA) jest flagowym modelem poprzedniej generacji.⁸³¹¹⁷ Od CLI v0.147.0 (stable, 7 sierpnia 2026) codex exec --full-auto jest usunięte (wycofywane od v0.128) — skrypty nadal przekazujące tę opcję kończą się teraz błędem; należy zastąpić ją przez --sandbox workspace-write wraz z flagą zatwierdzania lub profilem. v0.147.0 udostępnia także --approve-for-me (monity o zatwierdzenie rozstrzygane przez automatyczne sprawdzenie), przenośne Agent Plugins z wyszukiwaniem w katalogach lokalnych, osobistych, workspace i zdalnych, opcjonalny protokół MCP 2026-07-28 (stronicowane wykrywanie, żądania wieloetapowe, nieblokujące uruchamianie serwera) oraz sekcje rozmów do organizowania długich transkrypcji.¹¹⁶ v0.146.0 (stable, 29 lipca) sprawiło, że skonfigurowane proxy obejmują wszystkie warstwy transportu, dodało manifesty Agent Plugins oraz marketplace Amazon Bedrock i Claude Code, nazewnictwo sesji z przypinaniem wątków i skills dostarczane przez wykonawcę; v0.146.1 (5 sierpnia) wzmocniło domyślne ustawienia automatycznej weryfikacji dla modeli zdolnych do działań cybernetycznych.¹¹⁴¹¹⁵ Od CLI v0.145.0 (stable, 21 lipca 2026) /import migruje zarówno z Cursor, jak i Claude Code — ustawienia, serwery MCP, pluginy, sesje, polecenia i pamięci ograniczone do projektu — głos powraca jako strumieniowane rozmowy realtime V3 z wejściami audio i wyjściami narzędzi audio w popularnych formatach lokalnych, opcjonalne środowisko multi-agent v2 zostało ustabilizowane z konfigurowalnymi modelami sub-agentów, poziomami rozumowania i współbieżnością, eksperymentalna stronicowana historia wątków zapewnia wydajne wznawianie, wyszukiwanie, utrwalone nazwy, obsługę sub-agentów i pamięci, dostępne jest eksperymentalne logowanie Amazon Bedrock z obsługą niestandardowego endpointu i uwierzytelniania (GPT-5.6 Sol jako domyślny model Bedrock), a dołączone wybory modeli GPT-5.4 migrują do wariantów GPT-5.6 Terra i Luna; v0.144.6 (18 lipca) skorygowało okna kontekstu GPT-5.6 Sol/Terra/Luna do 272 000 tokenów.¹¹¹¹¹² Od CLI v0.140.0 (stable, 15 czerwca 2026) /usage pokazuje dzienną/tygodniową/skumulowaną aktywność tokenów na koncie, sesje można trwale usuwać za pomocą codex delete / /delete (z zabezpieczeniami potwierdzenia), /import selektywnie migruje konfigurację początkową, konfigurację 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 Amazon Bedrock API-key jest dostępne wraz z zaszyfrowanym magazynem lokalnym dla poświadczeń CLI i MCP OAuth; eksperymentalne sterowanie głosowe /realtime zostało usunięte z TUI (głos powrócił później w v0.145.0 jako strumieniowane realtime V3).¹⁰²¹¹² Od CLI v0.139.0 (stable, 9 czerwca 2026) tryb kodu może bezpośrednio wywoływać samodzielne wyszukiwanie w sieci (również ze zagnieżdżonych wywołań narzędzia JavaScript) i otrzymywać wyniki w postaci zwykłego tekstu, schematy wejściowe narzędzi/konektoró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 udostępnia źródła w codex plugin marketplace list --json oraz szybsze wyświetlanie katalogu z cache.¹²² v0.138.0 (8 czerwca) dodało /app, aby przekazać sesję CLI do aplikacji desktopowej w macOS i Windows, udostępniło modelowi lokalne ścieżki obrazów, uelastyczniło wybór poziomu rozumowania i zapewniło automatyzacji pluginów ustrukturyzowane dane wyjściowe JSON; rozpoczęło także szyfrowanie tekstu zadań przekazywanego od rodzica do sub-agenta w multi-agent v2, dzięki czemu instrukcje delegowania nie pojawiają się już w postaci zwykłego tekstu w lokalnych logach sesji (zob. Multi-Agent).¹²³¹⁰⁸ v0.137.0 (4 czerwca) udostępniło multi-agent v2 (środowisko uruchomieniowe zachowywane dla każdego wątku, czytelniejsze ustawienia domyślne kontynuacji i metadanych, hide_spawn_agent_metadata domyślnie true), skróty klawiszowe TUI F13–F24 oraz rozszerzenie skills v1 z rozwiązywaniem katalogu dla każdej tury.¹²⁴ Od CLI v0.135.0 (stable, 28 maja 2026) codex doctor raportuje bogatszy zestaw informacji o środowisku, Git, terminalu, app-server i wątkach; /status pokazuje szczegóły połączenia zdalnego i wersję serwera, gdy TUI jest połączone zdalnie; tryb vim zyskał edycję obiektów tekstowych, ulepszone zachowanie słów/końców wiersza oraz konfigurowalne przerywanie tury; /permissions rozumie teraz nazwane profile uprawnień i wyświetla profile niestandardowe; spakowane kompilacje Codex wykrywają i używają dołączonego poprawionego pomocnika zsh we wszystkich obsługiwanych systemach macOS; a Python SDK udostępnia przyjazne presety Sandbox dla APIów wątków i tur.¹²⁶ v0.134.0 (26 maja 2026) wprowadziło wyszukiwanie w lokalnej historii rozmów z niewrażliwymi na wielkość liter dopasowaniami treści i podglądami wyników, uczyniło --profile głównym selektorem profilu w CLI, uprawnieniach TUI i przepływach sandbox (starsze konfiguracje profili są odrzucane z instrukcjami migracji), ulepszyło konfigurację MCP dzięki kierowaniu środowiska dla każdego serwera i opcjom OAuth dla serwerów streamable HTTP, zwiększyło niezawodność schematów narzędzi konektorów przez zachowywanie lokalnych $ref/$defs oraz kompresowanie zbyt dużych schematów, umożliwiło uruchamianie narzędzi MCP tylko do odczytu współbieżnie, gdy deklarują readOnlyHint, oraz dodało bogatszy kontekst rozszerzeń i hooków, w tym historię rozmowy dla narzędzi rozszerzeń.¹⁰¹ v0.133.0 (21 maja 2026) domyślnie włączyło cele z dedykowanym magazynem i śledzeniem postępu; codex remote-control zyskało gotowość/status na pierwszym planie oraz uruchamianie/zatrzymywanie w stylu demona; profile uprawnień otrzymały listy APIów, dziedziczenie, zarządzane requirements.toml, odświeżanie w czasie działania oraz mocniejszą integrację z sandboxem Windows; wykrywanie pluginów pokazuje zainstalowane wersje, katalogi główne marketplace i zdalne kolekcje; a rozszerzenia mogą obserwować uruchamianie/zatrzymywanie subagentów, wykonywanie narzędzi, metadane tur oraz asynchroniczne przetwarzanie zatwierdzeń/tur. Aktualizacja aplikacji Codex z 21 maja dodała Appshots dla aktywnych okien Mac, Goal mode GA w aplikacji/IDE/CLI, ulepszenia adnotacji w przeglądarce w aplikacji oraz opcjonalne zablokowane Computer Use dla uprawnionych użytkowników Mac.⁹⁹¹⁰⁰ v0.132.0 (20 maja 2026) dodało uwierzytelnianie Python SDK jako funkcję pierwszej klasy, prostsze tekstowe APIy tur, bogatszy TurnResult, codex exec resume --output-schema, szybsze uruchamianie TUI, rejestrację zdalnego wykonawcy opartą na uwierzytelnianiu oraz zachowanie wierności obrazu w turach app-server. Należy używać jawnych flag sandbox/approval lub profili uprawnień — starsze --full-auto zostało usunięte od v0.147.0; js_repl pozostaje usunięte.^{86878991969798116}

Uwaga dotycząca stabilności: Funkcje oznaczone [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ą zarządzaną powierzchnią pierwszej klasy, wykrywanie pluginów jest łatwiejsze do kontrolowania, a remote-control można łatwiej uruchamiać jako polecenie app-server na pierwszym planie lub z demonizacją. Codex Cloud i tryb kodu pozostają eksperymentalne lub w trakcie rozwoju, natomiast podstawowe CLI, sandboxing, AGENTS.md, config.toml, Skills, hooks, narzędzia multi-agent, pluginy, Browser, Computer Use i Appshots są stabilnymi lub udokumentowanymi powierzchniami dla użytkowników, zależnie od platformy i planu. v0.132.0 uzupełnia uwierzytelnianie Python SDK i zautomatyzowane wznawianie o ustrukturyzowanej formie; v0.131.0 dodało codex doctor, ujednolicone wyszukiwanie wzmianek @, polecenia marketplace CLI, udostępnianie pluginów zależne od wersji, remote-control zarządzane przez demona z włączaniem/wyłączaniem w czasie działania, środowiska oparte na rejestrze oraz dodatkowe wzmocnienia sandboxa Windows.⁹⁶⁹⁷⁹⁸ Starsze --full-auto zostało usunięte w v0.147.0 (wycofywane od v0.128), a js_repl pozostaje usunięte.^8687116

Jak działa Codex: model mentalny

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

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

Warstwa podstawowa: Wszystko napędza rodzina modeli GPT-5.x. Według stanu na sierpień 2026 r. gpt-5.6-sol jest zalecanym ustawieniem domyślnym — ustawienie „Power”, średni poziom rozumowania — obok Terra (na co dzień) i Luna (szybki, przystępny cenowo); gpt-5.5 to flagowy model poprzedniej generacji (kontekst 400K w Codex, 1M w API), a gpt-5.4 zostanie wycofany z Codex 31 sierpnia 2026 r.⁸³¹¹⁷ Odczytuje pliki, zapisuje poprawki, wykonuje polecenia powłoki i analizuje bazę 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 Seatbelt firmy Apple wymusza ograniczenia na poziomie jądra. W systemie 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 polityka zatwierdzania określa, kiedy należy poprosić o potwierdzenie od człowieka.

Warstwa rozszerzeń: MCP łączy usługi zewnętrzne (GitHub, Figma, Sentry). Skills zawierają pakiety wielokrotnego użytku z przepływami pracy, które Codex ładuje na żądanie. Apps łączą się z konektorami ChatGPT. Wyszukiwanie w sieci dodaje aktualny 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 wykonywanych niezależnie.

Kluczowa obserwacja: Większość użytkowników korzysta tylko z jednej powierzchni. Zaawansowani użytkownicy korzystają ze wszystkich pięciu: Cloud do długotrwałych zadań, CLI do deterministycznych operacji na repozytorium, rozszerzenia IDE do ścisłych pętli programowania, 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. Podstawowe powierzchnie interakcji
4. Szczegółowe omówienie systemu konfiguracji
5. Który model wybrać?
6. Ile kosztuje Codex?
7. Ramy podejmowania decyzji
8. Jak działa system sandbox i zatwierdzania?
9. Jak działa AGENTS.md?
10. Hooks
11. Czym jest MCP (Model Context Protocol)?
12. Tryb Code
13. Środowisko wykonawcze REPL JavaScript
14. Czym są Skills?
15. Plugins
16. Tryb Plan 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 desktopowa Codex
22. Akcja GitHub i CI/CD
23. Codex SDK
24. Optymalizacja wydajności
25. Jak diagnozować problemy? — w tym codex doctor
26. Wdrożenie Enterprise
27. Najlepsze praktyki i antywzorce
28. Przepisy na przepływy pracy
29. Przewodnik migracji
30. Karta szybkiego odniesienia
31. Dziennik zmian
32. Źródła

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

Jak zaktualizować, obniżyć wersję lub odinstalować Codex CLI?

Od wersji v0.128.0 Codex zawiera polecenie samodzielnej aktualizacji; cała reszta odbywa się za pośrednictwem menedżera pakietów, który go zainstalował.⁸⁶ Od wersji v0.146.0 artefakty wydań, metadane kanałów i aliasy instalatora są obsługiwane przez infrastrukturę wydań hostowaną przez OpenAI, z GitHub jako rozwiązaniem awaryjnym.¹¹⁴ Jeśli sieć dopuszcza GitHub dla instalacji i aktualizacji Codex, należy dodać również host wydań OpenAI — mechanizm awaryjny sprawia, że brak na liście dozwolonych powoduje ciche pogorszenie działania zamiast wyraźnego błędu.

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

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

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

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

Przypięcie wersji to właściwy krok, gdy wydanie powoduje problemy. Codex działa w szybko aktualizowanej stabilnej linii, więc zainstalowanie dokładnej wersji jest najszybszym sposobem wycofania zmian — należy zgłosić problem, przypiąć wersję i kontynuować pracę. Warto potwierdzić wycofanie za pomocą codex --version, ponieważ druga instalacja przesłaniająca tę właściwą na PATH może nadal po cichu uruchamiać stary plik binarny (codex doctor wskazuje to dokładnie w sekcji Environment).

Odinstalowanie pakietu nie usuwa stanu. Dane uwierzytelniania, konfiguracja i historia sesji znajdują się w ~/.codex/. Pozostawienie ich zachowuje logowania i historię po ponownej instalacji; należy je usunąć wyłącznie, gdy potrzebny jest rzeczywiście czysty start — rm -rf ~/.codex usuwa również config.toml, auth.json i każdą zapisaną sesję.

Bezpośredni skrypt instalacyjny (v0.106.0+)

Dla macOS i Linux dostępny jest jednolinijkowy 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 oraz umieszcza go w PATH.

Pobieranie plików binarnych

W środowiskach bez npm lub Homebrew należy pobrać pliki binarne dla danej platformy z wydań GitHub¹:

Wymagania systemowe

• macOS: Apple Silicon lub Intel (pełna obsługa sandbox za pośrednictwem Seatbelt)
• Linux: x86_64 lub arm64 (sandbox za pośrednictwem Landlock + seccomp)
• Windows: Natywny sandbox z ograniczonymi tokenami (awansowany z wersji eksperymentalnej w v0.100.0). Obsługiwany jest również WSL²

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): Proszę zalogować się przy użyciu istniejącej subskrypcji Plus, Pro, Team, Business, Edu lub Enterprise. Pełny dostęp do funkcji, w tym do zadań w chmurze.
2. Klucz API: Należy ustawić go za pomocą zmiennej środowiskowej CODEX_API_KEY lub codex login --with-api-key. Niektóre funkcje (wątki w chmurze) mogą być niedostępne.

Wskazówka dla zaawansowanych: Przechowywanie poświadczeń można skonfigurować za pomocą 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 file).

Logowanie Amazon Bedrock (v0.145.0, eksperymentalne): Zespoły, których dostęp do modeli działa przez Amazon Bedrock, otrzymują eksperymentalną ścieżkę logowania z obsługą niestandardowego punktu końcowego i uwierzytelniania, obok istniejącego zarządzanego uwierzytelniania kluczem API (v0.140.0+) oraz łańcucha poświadczeń AWS (zobacz Custom Model Providers). GPT-5.6 Sol jest domyślnym modelem Bedrock.¹¹²

Uzupełnianie poleceń 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.147.0

Szybki start: pierwsza sesja

Od zera do produktywnej pracy w 5 minut.

1. Zainstaluj i uwierzytelnij się:

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

2. Przejdź do projektu:

cd ~/my-project                  # Any git repo works

3. Uruchom Codex:

codex

Pojawi się interaktywny TUI. Codex automatycznie odczytuje strukturę projektu.

4. Zadaj pytanie:

> What does this project do? Summarize the architecture.

Codex odczytuje kluczowe pliki i wyjaśnia bazę kodu. Takie pytanie nie wprowadza żadnych zmian — Codex modyfikuje pliki tylko wtedy, gdy zostanie poproszony o zmianę, a sandbox i zasady zatwierdzania określają, kiedy musi najpierw poprosić o zgodę.

5. Wprowadź zmianę:

> Add input validation to the login endpoint

Codex proponuje edycje w formie diff. Należy je przejrzeć i zatwierdzić za pomocą y albo odrzucić za pomocą n.

6. Użyj slash command:

> /plan Refactor the database layer to use connection pooling

Codex tworzy plan bez jego wykonywania. Należy przejrzeć plan, a następnie zatwierdzić go, aby rozpocząć wykonywanie.

7. Sprawdź swoją pracę:

> /diff

Wyświetla wszystkie zmiany wprowadzone przez Codex w bieżącej sesji.

Co dalej:

• Skonfiguruj AGENTS.md z instrukcjami projektu (zobacz Jak działa AGENTS.md?)
• Skonfiguruj profil dla swojego przepływu pracy (zobacz Profiles)
• Wypróbuj codex exec do automatyzacji nieinteraktywnej (zobacz Tryb nieinteraktywny)

Podstawowe interfejsy interakcji

Codex oferuje pięć odrębnych interfejsów opartych na tej samej inteligencji. Każdy z nich optymalizuje inny model pracy.

1. Interaktywny CLI (Terminal UI)

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

Terminal UI to aplikacja pełnoekranowa z:

• Edytorem poleceń: wpisywaniem promptów, dołączaniem plików za pomocą @ oraz uruchamianiem poleceń powłoki z prefiksem !
• Panelem wyjściowym: strumieniowaniem odpowiedzi modelu, wywołaniami narzędzi i wynikami poleceń
• Paskiem stanu: modelem, użyciem tokenów, gałęzią git i trybem sandbox

Najważniejsze skróty TUI:

Zmiana w wierszu stanu (v0.121.0): Stary miernik okna kontekstu w wierszu stanu został zastąpiony przez wskaźnik procentu kontekstu, pokazujący stopień zapełnienia okna kontekstu. Jeśli skrypty lub hooks analizują wiersz stanu, należy uwzględnić tę zmianę formatu.⁸² Codex wyświetli także powiadomienie o aktualizacji CLI, gdy dostępna będzie nowa wersja.

Slash commands dostępne w TUI:

Przeprojektowanie selektora przepływu pracy (v0.129.0): Wznawianie i rozgałęzianie są teraz łatwiej dostępne z przeprojektowanego selektora, a nowy tryb surowego przewijania historii pozwala przewijać nieprzetworzony transkrypt, gdy trzeba dosłownie skopiować polecenia lub wynik modelu. Przydatne podczas analizy długiej sesji debugowania lub przekazywania danych wyjściowych do innego narzędzia.⁸⁹

Ujednolicone menu wzmianek @ (v0.140.0): Wpisanie @ w edytorze poleceń otwiera teraz domyślnie jedno menu wzmianek obejmujące pliki, pluginy i skills, zastępując przepływ dołączania tylko plików — jedno naciśnięcie klawisza pozwala 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 nie ma CLI:

• Wielozadaniowość: jednoczesne uruchamianie wielu równoległych agentów w różnych projektach
• Izolacja Git worktree: każdy wątek pracuje na odizolowanej kopii repozytorium
• Wbudowany przegląd diffów: przygotowywanie, cofanie i commitowanie zmian bez opuszczania aplikacji
• Zintegrowany terminal: terminal dla każdego wątku do uruchamiania poleceń
• Rozgałęzianie rozmów: tworzenie gałęzi rozmów w celu eksplorowania alternatyw
• Pływające wyskakujące okna: odłączanie rozmów do przenośnych okien
• Automatyzacje: planowanie powtarzalnych zadań (triage zgłoszeń, monitorowanie CI, reakcje na alerty)
• Appshots: dołączanie okna aplikacji Mac znajdującego się na pierwszym planie do wątku wraz ze zrzutem ekranu i dostępnym tekstem
• Komentarze w przeglądarce aplikacji: podgląd lokalnych lub publicznych stron, pozostawianie komentarzy do elementów/obszarów oraz umożliwienie Codex obsługi precyzyjnych uwag wizualnych
• Computer Use: umożliwienie Codex obsługi dozwolonych aplikacji Mac w ramach określonej pracy GUI; zablokowane użycie jest opcjonalne dla kwalifikujących się zdalnych tur Mac Computer Use

ChatGPT Voice, obsługiwany przez GPT-Live (desktop 26.715, 23 lipca 2026 r.): Aplikacją desktopową można teraz sterować głosem — omawiać pracę i koordynować zadania między Chat, Work i Codex bez pisania. W macOS włączenie Screen context udostępnia rozmowie appshot okna znajdującego się na pierwszym planie, dzięki czemu można pytać o to, na co się patrzy, zamiast to opisywać. Dostępne w planach Plus, Pro, Business, Edu i Enterprise, w aplikacji desktopowej oraz przez Remote na iOS. Jest to obsługa głosowa powierzchni desktopowej; własna transkrypcja głosowa aktywowana spacją w CLI jest odrębną, eksperymentalną funkcją.¹¹³

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

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

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

• Domyślnie tryb agenta: odczytuje pliki, wprowadza zmiany i uruchamia polecenia
• Edycje w tekście: sugestie uwzględniające kontekst w aktywnych plikach
• Współdzielone sesje: sesje synchronizują się między CLI a rozszerzeniem IDE
• To samo uwierzytelnianie: logowanie za pomocą konta ChatGPT lub klucza API

Instalacja z VS Code Marketplace lub sklepów z rozszerzeniami Cursor/Windsurf.³

4. Codex Cloud [EKSPERYMENTALNE]

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

• Uruchom i zapomnij: kolejkowanie zadań działających niezależnie od lokalnego komputera
• Wykonywanie równoległe: jednoczesne uruchamianie wielu zadań cloud
• Tworzenie PR: Codex tworzy pull requesty na podstawie ukończonej pracy
• Lokalne zastosowanie: pobieranie wyników cloud 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 cloud są także dostępne z poziomu chatgpt.com/codex.⁴

5. Codex for Chrome [NOWOŚĆ]

Codex jest dostępny jako rozszerzenie przeglądarki Chrome, dodając piąty interfejs obok CLI, aplikacji desktopowej, rozszerzenia IDE i cloud. Rozszerzenie zaprojektowano tak, aby towarzyszyło zwykłemu przeglądaniu, zamiast je przejmować: Codex działa równolegle w tle 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: można utworzyć allow-list witryn, z którymi Codex może wchodzić w interakcję; domyślnie dostęp nie jest przyznany.
• Przeglądarka jako środowisko pracy: rozszerzenie najlepiej sprawdza się przy pracy z aplikacjami i witrynami, gdzie strona jest źródłem prawdy — konsolami administracyjnymi, wewnętrznymi dashboardami, interfejsami do zarządzania treścią, systemami zgłoszeń — a nie jako zamiennik CLI dla lokalnych repozytoriów.
• Ten sam mózg: Codex for Chrome korzysta z tej samej inteligencji GPT-5.x-Codex, której używają pozostałe interfejsy, więc konfiguracja AGENTS.md lub skills działająca w CLI zachowuje te same konwencje w pracy sterowanej przez przeglądarkę.

Instalacja z dokumentacji rozszerzenia Codex Chrome.⁹⁰

Szczegółowe omówienie systemu konfiguracji

Codex używa TOML do konfiguracji. Zrozumienie hierarchii pierwszeństwa ma kluczowe znaczenie, ponieważ określa, które ustawienia mają zastosowanie w przypadku 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ę 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ń polityki, która ogranicza wartości wybierane przez użytkowników po zwykłym scaleniu konfiguracji. Zobacz Wdrożenie w przedsiębiorstwie.

Lokalizacje plików konfiguracji

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

Projekty desktopowe z wieloma folderami (26.715, 23 lipca 2026 r.): Lokalny projekt w aplikacji komputerowej ChatGPT może teraz obejmować kilka powiązanych folderów, z których jeden jest wyznaczony jako folder główny (menu projektu → Edytuj projekt). Automatyczne wykrywanie config.toml działa wyłącznie względem folderu głównego; foldery dodatkowe pozostają dostępne do wyszukiwania, odczytywania i edytowania plików, ale nie wnoszą konfiguracji. Plik .codex/config.toml znajdujący się w folderze dodatkowym jest plikiem, który Codex może odczytać, a nie konfiguracją, którą ładuje. Jest to zakres projektu aplikacji desktopowej, a nie zmiana zasad pierwszeństwa opisanych powyżej — CLI nadal rozwiązuje konfigurację projektu, przechodząc w górę od bieżącego katalogu roboczego.¹¹³

Pełne odniesienie do konfiguracji

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Profile

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

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

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

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

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

Aktywowanie 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ć za pomocą --profile.

Niestandardowi dostawcy modeli

Połącz 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 przewodowego chat/completions (wire_api = "chat") został wycofany dla modeli hostowanych przez OpenAI, a OpenAI zapowiedziało jego usunięcie w lutym 2026 r.³⁴ Lokalni dostawcy (Ollama, LM Studio) mogą nadal akceptować ten format. W przypadku endpointów OpenAI należy zamiast tego użyć wire_api = "responses".

Używanie 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 (sierpień 2026)

GPT-5.5 (23 kwietnia 2026 r.) był zalecanym przez OpenAI wyborem do większości zadań Codex w chwili premiery: złożonego programowania, korzystania z komputera, pracy z wiedzą i 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 równoważyć przepustowość i koszt między poziomami subskrypcji; API udostępnia pełne 1M. Cennik (API): 5 USD za wejście / 30 USD za wyjście na MTok (2× stawka GPT-5.4; OpenAI podaje ~20% efektywnego wzrostu po uwzględnieniu poprawy wydajności tokenowej). Benchmarki: 82,7% Terminal-Bench 2.0 (obecne SOTA wśród publicznie dostępnych modeli), 84,9% GDPval (44 zawody), 78,7% OSWorld-Verified, 98,0% Tau2-bench Telecom (bez dostrajania promptów). OpenAI użyło wewnętrznie GPT-5.5 + Codex do przepisania infrastruktury obsługującej przed premierą — uzyskano 20% wzrost szybkości generowania tokenów.⁸³

GPT-5.4 i GPT-5.4 mini zostaną wycofane z Codex 31 sierpnia 2026 r.¹¹⁷ Do tego czasu GPT-5.4 pozostaje dostępny do wyboru na wszystkich powierzchniach Codex.⁶⁴ Dokładna lista modeli zależy od konta i etapu wdrażania. Proszę sprawdzić lokalną pamięć podręczną: ~/.codex/models_cache.json.

Uwaga dotycząca wycofania (11 marca 2026 r.): Modele GPT-5.1 nie są już dostępne w ChatGPT. Istniejące rozmowy automatycznie kontynuują działanie na GPT-5.3 Instant, GPT-5.4 Thinking lub GPT-5.4 Pro. GPT-5.1-Codex-Mini pozostawał dostępny przez API i CLI do wyłączenia 23 lipca 2026 r.⁷¹⁸⁸

Uwaga dotycząca bezpłatnego poziomu (5 maja 2026 r.): GPT-5.5 Instant został udostępniony w bezpłatnym poziomie ChatGPT 5 maja 2026 r. Poszerza to grono odbiorców rodziny GPT-5.5 poza płatne plany, chociaż dostęp do Codex CLI nadal wymaga kwalifikującej subskrypcji Plus / Pro / Business / Enterprise / Edu / Go albo klucza API.⁹²

GPT-5.4 mini (17 marca 2026 r.): Mniejszy, szybszy wariant GPT-5.4 z kontekstem 400K, w cenie 0,75 USD/4,50 USD za MTok — wykorzystuje zaledwie 30% limitu GPT-5.4. Idealny do delegowania zadań subagentom: GPT-5.4 może obsługiwać planowanie i koordynację, podczas gdy subagenci GPT-5.4 mini równolegle realizują węższe podzadania (przeszukiwanie kodu źródłowego, przegląd plików, przetwarzanie dokumentów).⁷⁶

Bedrock GPT-5.6 (Sol, Terra, Luna) (v0.143.0, 8 lipca 2026 r.): Codex dodał natywną obsługę trzech wariantów modeli GPT-5.6 hostowanych w Amazon Bedrock, w tym obsługę poziomu wysiłku rozumowania max. Dla zespołów, których dostęp do modeli działa przez dostawcę Bedrock, można je wybierać tak samo jak inne modele dostawców niestandardowych (zobacz Custom Model Providers); poziom wysiłku max jest przeznaczony do najtrudniejszych zadań wymagających rozumowania i pracy agentowej.¹⁰⁶ v0.144.6 (18 lipca 2026 r.) odświeżyła dołączone instrukcje dla Sol, Terra i Luna oraz skorygowała ich okna kontekstu do 272 000 tokenów.¹¹¹ v0.145.0 (21 lipca 2026 r.) dodaje eksperymentalne logowanie Bedrock z obsługą niestandardowego punktu końcowego i uwierzytelniania, ustawia GPT-5.6 Sol jako domyślny model Bedrock oraz przenosi dołączone wybory modeli GPT-5.4 do odpowiadających im wariantów Terra i Luna.¹¹²

Schemat wyboru modelu

Is this a quick fix or simple question?
├─ Yes → gpt-5.6-luna (fastest, most affordable)
└─ No
   ├─ Do you need real-time pairing speed?
   │  ├─ Yes → gpt-5.3-codex-spark (near-instant, Pro only)
   │  └─ No
   │     ├─ Subagent or parallel subtask (search, review, processing)?
   │     │  ├─ Yes → gpt-5.6-luna (the bundled subagent pick since v0.145.0)
   │     │  └─ No
   │     │     ├─ Everyday coding task (refactor, migration, feature build)?
   │     │     │  ├─ Yes → gpt-5.6-terra (everyday model, 272K context)
   │     │     │  └─ No → gpt-5.6-sol (flagship — the default "Power" setting)
   └─ Still unsure? → gpt-5.6-sol

Wysiłek rozumowania

Pozwala określić, 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 ekspercka: Rozumowanie xhigh może zużyć dla tego samego promptu 3–5× więcej tokenów niż medium. Warto zarezerwować je dla rzeczywiście trudnych problemów, w których dodatkowe rozumowanie przynosi korzyść.

Szybkie sterowanie poziomem rozumowania w TUI (v0.124.0+).⁸⁵ W interaktywnej sesji TUI klawisze Alt+, obniżają poziom rozumowania o jeden stopień, a Alt+. podnoszą go o jeden stopień — jest to przydatne, gdy trudny problem w trakcie sesji uzasadnia tymczasowe przejście medium → high → xhigh bez używania /effort ani -c. Po zaakceptowaniu aktualizacji modelu w trakcie sesji poziom rozumowania resetuje się do domyślnego dla nowego modelu, zamiast zachowywać poprzedni poziom.

Przełączanie modeli

Modele można przełączać w trakcie sesji za pomocą slash command /model lub ustawiać dla każdego uruchomienia przez --model / -m:

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

Ile kosztuje Codex?

Zobacz też Wybór modelu, aby poznać możliwości, oraz Ramy decyzyjne, aby dobrać odpowiedni model do zadania.

Dostęp w planach ChatGPT

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

Aktualizacja cen z kwietnia 2026 r.: Roczna cena Business spadła z $25 do $20 za stanowisko miesięcznie. Stanowiska tylko Codex z rozliczaniem pay-as-you-go są teraz dostępne dla obszarów roboczych Business i Enterprise — bez stałej opłaty za stanowisko, rozliczane według zużycia tokenów.⁷⁹ Strona z cenami publikuje obecnie limity jako przedziały zależne od modelu (zobacz tabelę powyżej), zamiast promocyjnych mnożników 2x z premiery Desktop App w lutym 2026 r.¹⁶¹¹⁹

Podwyższenie limitów użycia z maja 2026 r. (wygasło 31 maja 2026 r.): Codex w planie Plus działał z 25× limitem 5-godzinnym (w porównaniu ze standardowym zwiększeniem 20×), a poziom $100/miesiąc został podwojony dla tego samego okna.⁸⁹

Koszty kredytów

Operacje Codex zużywają kredyty z przydziału planu:

W praktyce „średnie użycie GPT-5.6 wynosi 5–40 kredytów na wiadomość”; tryb szybki zużywa kredyty szybciej w obsługiwanych modelach, a generowanie obrazów wykorzystuje zawarte limity 3–5x szybciej niż porównywalne tury wyłącznie tekstowe.¹¹⁹

Plany Enterprise i Edu skalują liczbę kredytów wraz z przydziałem kontraktowym. Aby sprawdzić bieżące użycie, należy użyć /status w TUI.

Rozliczanie API

Podczas korzystania z Codex za pośrednictwem API, OpenAI rozlicza użycie za token zgodnie ze standardowymi cenami OpenAI API dla wybranego modelu (z uwzględnieniem wszelkich obowiązujących zniżek za cache promptów). Aktualne stawki są dostępne na oficjalnej stronie cen API.²⁰

Strategie optymalizacji kosztów

1. Używaj profili: Utwórz profil fast z gpt-5.6-luna oraz model_reasoning_effort = "low" do rutynowych zadań
2. Zachowaj intensywne rozumowanie na wymagające zadania: xhigh należy stosować wyłącznie do naprawdę trudnych problemów, ponieważ zużywa 3–5x więcej tokenów
3. Używaj --ephemeral: Pomijaj trwałość sesji w CI/CD, aby zmniejszyć narzut
4. Ograniczaj podsumowania rozumowania: Ustaw model_reasoning_summary = "none", gdy wyjaśnienia nie są potrzebne
5. Wykonuj wsadowo w trybie exec: codex exec eliminuje narzut TUI w zautomatyzowanych przepływach pracy
6. Monitoruj użycie: Sprawdzaj /status w TUI oraz pulpity rozliczeniowe organizacji

Przykłady kosztów w praktyce

Reprezentatywne koszty API dla typowych zadań (migawka cen gpt-5.3-codex z połowy 2026 r., średnie rozumowanie — względne proporcje przenoszą się między modelami):

Koszty różnią się w zależności od intensywności rozumowania, cache i długości rozmowy. Do rutynowych zadań warto używać gpt-5.6-luna, aby znacząco ograniczyć wydatki na takie zadania. Tokeny wejściowe z pamięci podręcznej są rozliczane ze zniżką.

Ukryty narzut tokenów

Każde wywołanie narzędzia dodaje tokeny poza widocznym promptem:

Wskazówka ekspercka: Rzeczywiste użycie można monitorować przez /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 z nich dodaje definicje narzędzi do każdego wywołania API.

Zarządzanie kosztami zespołu

Strategie kontroli kosztów zespołowych: - Ustaw requirements.toml, aby egzekwować limity modelu i intensywności rozumowania w całej organizacji - Używaj gpt-5.6-luna w CI/CD — zautomatyzowane potoki rzadko potrzebują maksymalnej intensywności rozumowania - Budżetowanie oparte na profilach — zdefiniuj profile ci, review i dev z odpowiednimi limitami kosztów - Monitorowanie przez 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

Tryb planowania a bezpośrednie wykonanie

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

Praktyczna zasada: Enter = „zatrzymaj się, wysłuchaj tego teraz”. Tab = „gdy skończysz, zrób także to”.

Desktop App a 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.6-luna"
model_reasoning_effort = "low"

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

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

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

Przełączanie profili dla poszczególnych sesji: codex --profile careful

Jak działa system sandbox i zatwierdzania?

Codex wykorzystuje dwuwarstwowy model zabezpieczeń, który oddziela to, co jest technicznie możliwe, od momentu, w którym Codex prosi człowieka o zatwierdzenie. To podejście zasadniczo różni się od systemu uprawnień Claude Code — Codex wymusza ograniczenia na poziomie jądra systemu operacyjnego.⁵ Warto również zapoznać się z sekcją Wdrożenie w przedsiębiorstwie, w której opisano ograniczenia requirements.toml egzekwowane przez administratorów 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: mechanizm Apple Seatbelt za pośrednictwem sandbox-exec, z profilami właściwymi dla poszczególnych trybów, kompilowanymi w czasie działania i egzekwowanymi przez jądro systemu⁶. Od wersji v0.121.0 profile sandbox w macOS mogą dodawać określone gniazda Unix do listy dozwolonych (np. docker.sock i gniazda IPC edytora), a prywatne rozpoznawanie DNS nie jest już domyślnie blokowane.⁸²
• Linux: Landlock do ograniczania dostępu do systemu plików oraz seccomp do filtrowania wywołań systemowych. Samodzielny proces pomocniczy (codex-linux-sandbox) zapewnia wielowarstwową izolację.⁵ Bubblewrap (bwrap) jest dołączany do kodu źródłowego i kompilowany w ramach wersji dla systemu Linux (od v0.100.0 nie jest już opcjonalny)⁷. Wersja v0.117.0 poprawiła niezawodność sandbox na starszych dystrybucjach ze starszymi konfiguracjami jądra.⁷⁵ Wersja v0.129.0 wzmocniła zabezpieczenia uruchamiania sandbox w systemie Linux i zaktualizowała dołączony Bubblewrap do wersji 0.11.2, obejmującej poprawki zabezpieczeń z projektu nadrzędnego; w wersji v0.130.0 dodatkowo wzmocniono zabezpieczenia uruchamiania.⁸⁹⁹¹
• Windows: natywny sandbox z ograniczonymi tokenami (od wersji v0.100.0 nie jest już funkcją eksperymentalną). Obsługiwany jest również WSL (dziedziczy mechanizmy Landlock i seccomp z systemu Linux). Wersja v0.117.0 zawiera ulepszenia sandbox opartego na ograniczonych tokenach, zapewniające lepszą izolację procesów.⁷⁵ Wersja v0.130.0 zapewnia użytkownikom sandbox dostęp do pamięci podręcznej plików binarnych środowiska uruchomieniowego aplikacji desktopowej, dzięki czemu sandbox w systemie Windows może niezawodnie odnajdywać te pliki dla użytkowników sandbox przestrzeni roboczej.⁹¹

Dlaczego ma to znaczenie: w przeciwieństwie do izolacji opartej na kontenerach (Docker) sandbox na poziomie systemu operacyjnego działa szybciej, jest lżejszy i trudniej się z niego wydostać. Jądro egzekwuje ograniczenia, zanim Codex w ogóle otrzyma wywołanie systemowe.

Poprawki zabezpieczeń: - Obejście sandbox przez zsh-fork (v0.106.0): naprawiono lukę, przez którą wykonywanie poleceń powłoki za pośrednictwem rozwidlania procesów zsh mogło omijać ograniczenia sandbox.⁶⁰ Jeśli korzystają Państwo ze starszej wersji, należy natychmiast przeprowadzić aktualizację. - Limit rozmiaru danych wejściowych (v0.106.0): Codex egzekwuje teraz limit danych wejściowych wynoszący około 1 miliona znaków, aby zapobiegać zawieszaniu się programu wskutek przetwarzania nadmiernie dużych ładunków.⁶⁰ - Bezpieczny profil devcontainera (v0.121.0): nowy, wzmocniony profil klienta dla devcontainerów Docker wykorzystuje Bubblewrap do izolacji wewnątrz kontenera. WSL2 jest obsługiwany, natomiast WSL1 jest jednoznacznie odrzucany (Bubblewrap jest niezgodny z warstwą zgodności jądra WSL1).⁸² - Przegląd Guardian i hooks (v0.121.0): hooks są wyłączone podczas sesji przeglądu Guardian, aby hooks uruchamiane przed użyciem narzędzia i po nim nie mogły wpływać na decyzje subagenta Guardian.⁸² Jeśli hooks służą do rejestrowania zdarzeń lub walidacji, należy pamiętać, że przegląd Guardian je pomija — gdy potrzebna jest pełna ścieżka audytu, należy skorzystać z obserwowalności serwera aplikacji. - System plików /dev w systemie Linux (v0.105.0): polecenia uruchamiane w sandbox w systemie Linux otrzymują teraz minimalny system plików /dev, co poprawia zgodność z narzędziami oczekującymi obecności węzłów urządzeń.⁶¹

Zasady ReadOnlyAccess (v0.100.0+): konfigurowalna struktura zasad umożliwiająca szczegółową kontrolę dostępu do odczytu. Pozwala ograniczyć katalogi, z których Codex może odczytywać dane, nawet w trybie workspace-write:

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

Warstwa 2: zasady zatwierdzania (kiedy pytać)

Zasady zatwierdzania określają, kiedy Codex wstrzymuje działanie i prosi człowieka o potwierdzenie:

on-failure nadal występuje w niektórych starszych przykładach i ścieżkach zgodności, jednak aktualna dokumentacja konfiguracji OpenAI oznacza tę opcję jako przestarzałą. Do pracy interaktywnej należy wybierać on-request, a do uruchomień nieinteraktywnych, które mają już zewnętrzną granicę bezpieczeństwa — never.⁸⁷

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

Codex przypisuje teraz odrębny identyfikator zatwierdzenia każdemu poleceniu w wieloetapowej operacji powłoki. Dzięki temu zatwierdzenia są szczegółowe — zatwierdzenie jednego polecenia w sekwencji nie powoduje automatycznego zatwierdzenia kolejnych poleceń w ramach tego samego wywołania powłoki.⁴⁹

Elastyczne mechanizmy zatwierdzania (v0.105.0+)

Proces zatwierdzania obsługuje teraz dodatkowe uprawnienia sandbox i szczegółowe odrzucanie:⁶¹

• Dodatkowe uprawnienia sandbox: gdy polecenie wymaga dostępu wykraczającego poza bieżący tryb sandbox, Codex może poprosić o konkretne dodatkowe uprawnienia zamiast wymagać całkowitej zmiany trybu
• Szczegółowe odrzucanie: można odrzucać poszczególne wywołania narzędzi wraz z informacją zwrotną, aby Codex mógł zmienić podejście, zamiast jedynie 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 poprosić o konkretne uprawnienia (do ścieżek systemu plików, sieci itp.) za pośrednictwem procesu zatwierdzania w TUI, zamiast kończyć działanie bez wyjaśnienia lub wymagać ponownego uruchomienia przez użytkownika z innymi flagami.

Tryb zatwierdzania aplikacji writes (v0.144.0+)

Aplikacje i konektory otrzymują pośredni poziom zatwierdzania: tryb zatwierdzania aplikacji writes pozwala wykonywać zadeklarowane przez aplikację działania tylko do odczytu bez pytania, a nadal wstrzymuje operacje zapisujące dane.¹⁰⁷ Wcześniej zatwierdzanie aplikacji działało bardziej na zasadzie „wszystko albo nic”; writes odpowiada modelowi zaufania, którego większość operatorów faktycznie oczekuje od integracji — swobodnie odczytywać, pytać przed modyfikacją.

Automatycznie weryfikowane zatwierdzenia: --approve-for-me (v0.147.0+)

Nowa flaga CLI --approve-for-me przekształca prośby o zatwierdzenie w automatycznie weryfikowane zatwierdzenia: zamiast przerywać pracę każda prośba jest oceniana w ramach przeglądu, a następnie zatwierdzana lub odrzucana w Państwa imieniu.¹¹⁶ Rozwiązanie to znajduje się pomiędzy „zatwierdzaj wszystko” (do czego zachęcał już usunięty tryb --full-auto) a „przerywaj przy wszystkim” — prośby nadal stanowią punkty decyzyjne, lecz odpowiada na nie recenzent. Warto połączyć tę funkcję z bezpieczniejszymi domyślnymi ustawieniami automatycznego przeglądu dla modeli zdolnych do zadań cyberbezpieczeństwa, wprowadzonymi w wersji v0.146.1 i dziedziczonymi przez tę flagę. Należy traktować ją jak każde przekazanie uprawnień: sprawdza się przy długich, nienadzorowanych uruchomieniach, podczas których przerwanie oznacza zatrzymanie pracy, ale nie nadaje się do sesji obejmujących dane uwierzytelniające lub stan produkcyjny, gdy chcą Państwo osobiście podejmować decyzje.

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

Profile uprawnień rozdzielają zasady sandbox dotyczące systemu plików i sieci na nazwane sekcje wielokrotnego użytku. W default_permissions należy wskazać wbudowany profil, taki jak :read-only lub :workspace, albo niestandardową tabelę [permissions.<name>].⁸⁷ Wersja v0.133.0 wprowadza profile jako zarządzany mechanizm: listy APIs udostępniają metadane dostępnych profili, profile mogą dziedziczyć po sobie, zarządzany plik requirements.toml może deklarować wymagania dotyczące uprawnień, aktywne profile są odświeżane w czasie działania, a konfiguracja sandbox w systemie Windows korzysta teraz z wynikowego profilu zamiast z odrębnych zasad tworzonych doraźnie.⁹⁸

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"

W przypadku poufnych plików i wzorców glob, które mają pozostać nieczytelne nawet wtedy, gdy katalog główny projektu umożliwia zapis, należy użyć none. Dla jednorazowych wyjątków dotyczących poleceń lepiej stosować reguły niż szeroko rozszerzać profil.⁸⁷

Starsze zalecenia dotyczące --full-auto

W starszych przewodnikach --full-auto opisywano jako wygodny alias następujących opcji:

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

W informacjach o wersji v0.128.0 oznaczono --full-auto jako przestarzałe, a aktualna pomoc CLI nie wymienia już tej opcji dla uruchomień interaktywnych. Zamiast niej należy użyć powyższych jawnych flag lub nazwanego profilu uprawnień.⁸⁶

Wersja v0.147.0 kończy proces usuwania tej funkcji: codex exec --full-auto już nie istnieje. Skrypt, który nadal przekazuje tę flagę, zgłosi teraz błąd zamiast się uruchomić. Migracja jest mechaniczna — należy zastąpić ją opcją --sandbox workspace-write (oraz flagą zatwierdzania lub profilem, jeśli poprzednie wywołanie korzystało z zachowania zatwierdzania zapewnianego przez --full-auto). Przed aktualizacją należy skontrolować każdą automatyzację uruchamiającą codex exec za pośrednictwem powłoki: problem objawi się jako przerwany potok, a nie ostrzeżenie o wycofaniu funkcji.¹¹⁶

Niezawodność sandbox (v0.129.0): wzmocnienie procesu uruchamiania sandbox w systemie Linux ogranicza wyścigi na wolnych systemach plików lub w kopiach roboczych korzystających z dowiązań symbolicznych; ulepszenia niezawodności sandbox w systemie Windows eliminują kilka awarii brzegowych występujących podczas długotrwałych uruchomień; ponadto dołączony Bubblewrap zaktualizowano do wersji 0.11.2, zawierającej poprawki zabezpieczeń z projektu nadrzędnego. Zmiany konfiguracji nie są wymagane. Aby je zastosować, należy uruchomić codex update.⁸⁹

Zalecane konfiguracje

Codzienna praca programistyczna (bezpieślny wybór domyślny):

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

Zaawansowany użytkownik (pełny dostęp z udziałem człowieka w procesie):

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

Społeczność poleca to połączenie jako „złoty środek”: maksymalne możliwości przy obowiązku zatwierdzenia każdego polecenia.⁸

Automatyzacja CI/CD:

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

Inteligentne zatwierdzanie przy użyciu subagenta Guardian (v0.115.0+)

Funkcja Smart Approvals może kierować prośby o przegląd do subagenta Guardian, zamiast wymagać zatwierdzenia przez człowieka przy każdym działaniu. Sesja Guardian jest utrzymywana pomiędzy zatwierdzeniami, aby ponownie wykorzystywać pamięć podręczną promptów i unikać narzutu związanego z uruchamianiem. Każdy przegląd otrzymuje czystą historię (wcześniejsze decyzje nie przenikają do kolejnych przeglądów).⁷³

Recenzenta należy skonfigurować w config.toml:

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

Jest to szczególnie przydatne w procesach CI/CD, w których potrzebny jest automatyczny przegląd z uzasadnieniem zamiast bezwarunkowego ustawienia approval_policy = "never".

Zaostrzenie klasyfikatora PowerShell (v0.142.2): polecenia PowerShell zawierające wykonywalne obszary AST, których klasyfikator bezpieczeństwa nie może sprawdzić, wymagają teraz zatwierdzenia, zamiast przechodzić automatyczne zatwierdzanie — eliminuje to lukę, przez którą zaciemniony lub dynamicznie tworzony kod PowerShell mógł unikać klasyfikacji w systemie Windows.¹⁰⁵

Rozszerzone wykrywanie niebezpiecznych poleceń (v0.144.5): mechanizm rozpoznaje teraz więcej wymuszonych wariantów rm, a odrzucone polecenia są zwracane z jaśniejszym uzasadnieniem odrzucenia zamiast nieczytelnej odmowy — przydaje się to podczas dostrajania zasad zatwierdzania, gdy trzeba ustalić, dlaczego polecenie zostało zablokowane.¹¹⁰

Włączanie dostępu do sieci

Codex domyślnie blokuje dostęp do sieci w trybie workspace-write. W razie potrzeby można go włączyć:

# 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 serwera proxy WebSocket (v0.104.0+)

W środowiskach firmowych, w których ruch WebSocket jest kierowany przez serwer 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ę HTTPS_PROXY i serwerów proxy SOCKS5 (v0.93.0+).

Dopiero wersja v0.146.0 sprawiła, że określenie „wszystkie warstwy transportowe” stało się w pełni zgodne z rzeczywistością. Skonfigurowane serwery proxy są teraz uwzględniane podczas uwierzytelniania, pobierania pluginów, autoryzacji MCP, zdalnego wykonywania, połączeń WebSocket, przekierowań HTTP i połączeń z LM Studio — w siedmiu ścieżkach, które zgodnie z dziennikiem zmian wcześniej ignorowały proxy.¹¹⁴ Jeśli przed wersją v0.146.0 Codex działał za firmowym serwerem proxy, a logowanie lub instalowanie pluginów kończyło się niepowodzeniem mimo poprawnego działania zwykłych wywołań modelu, prawdopodobnym wyjaśnieniem jest właśnie ta luka.

Systemowy serwer proxy w macOS (v0.142.2+): po włączeniu respect_system_proxy klienty uwierzytelniania w macOS uwzględniają ustawienia systemowego serwera proxy, PAC i WPAD — dzięki temu firmowe komputery Mac, na których konfiguracja proxy jest rozpowszechniana za pomocą profili, nie wymagają już zmiennych środowiskowych proxy ustawianych osobno w każdej powłoce dla ruchu uwierzytelniającego.¹⁰⁵ Od wersji v0.143.0 obejmuje to również system Windows i ruch Responses API: Codex kieruje zarówno uwierzytelnianie, jak i wywołania Responses API przez systemowy serwer proxy macOS lub Windows, z uwzględnieniem automatycznej konfiguracji PAC i WPAD, co eliminuje ostatnią lukę w ściśle zabezpieczonych sieciach firmowych w obu systemach operacyjnych.¹⁰⁶

Testowanie sandbox

Przed obdarzeniem sandbox zaufaniem należy sprawdzić jego działanie:

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 prawidłowo, oba polecenia powinny zakończyć się błędem odmowy dostępu w profilu ograniczonym do przestrzeni roboczej. Jeśli którekolwiek polecenie zostanie wykonane pomyślnie, 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. Jest obsługiwany przez Codex, Cursor, Copilot, Amp, Jules (Google), Gemini CLI, Windsurf, Cline, Aider, Zed, Factory, RooCode oraz ponad 60 000 projektów open source. Określa sposób działania Codex w konkretnym repozytorium lub folderze. Pakiety wiedzy wielokrotnego użytku, które uzupełniają AGENTS.md, opisano w sekcji Skills.

Hierarchia wykrywania

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

1. Globalnie (~/.codex/): AGENTS.override.md > AGENTS.md
2. W projekcie (od katalogu głównego repozytorium git do bieżącego folderu): na każdym poziomie sprawdzane są kolejno AGENTS.override.md > AGENTS.md > zastępcze nazwy plików
3. Scalanie: pliki są łączone od katalogu głównego w dół; pliki położone bliżej bieżącego folderu pojawiają się później w prompcie 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

Projekty wielofolderowe w aplikacji komputerowej (26.715, 23 lipca 2026): Opisane powyżej przechodzenie dotyczy CLI, który rozpoznaje wszystkie elementy względem bieżącego folderu roboczego. Aplikacja komputerowa ChatGPT pozwala obecnie, aby projekt lokalny obejmował kilka powiązanych folderów, jednak wykrywanie odbywa się względem dokładnie jednego z nich: „Nowe czaty, operacje Git oraz automatyczne wykrywanie AGENTS.md, skills i config.toml korzystają z folderu głównego. Foldery dodatkowe pozostają dostępne do wyszukiwania, odczytywania i edytowania plików”. Folder główny wybiera się w menu projektu za pomocą opcji Edytuj projekt.¹¹³

To jedno ustawienie steruje jednocześnie trzema z pięciu podstawowych systemów Codex — instrukcje, skills i konfiguracja korzystają z folderu głównego. W praktyce oznacza to, że AGENTS.md w folderze dodatkowym jest plikiem, który Codex może otworzyć, ale nie obowiązującym zestawem reguł, który automatycznie wczyta. Jeśli repozytorium zawierające reguły dodano jako drugie, należy ustawić je jako główne albo powtórzyć te reguły w pliku AGENTS.md folderu głównego; dotyczy to również folderów repozytorium zawierających skills, które miały być automatycznie wykrywane. W sposobie przechodzenia CLI przez foldery nic się nie zmieniło — chodzi wyłącznie o zakres projektu w aplikacji komputerowej.

Co wyróżnia dobry plik AGENTS.md

Na podstawie bezpośrednich wskazówek samego Codex oraz wzorców wypracowanych przez społeczność¹⁰:

NALEŻY: - Formułować konkretne instrukcje: "Use rg --files for discovery" jest lepsze niż "search efficiently" - Określić kryteria zakończenia: co oznacza „gotowe”? (testy przechodzą, lint nie zgłasza błędów itd.) - Podawać polecenia: budowanie, testowanie, lintowanie i formatowanie (dokładne wywołania) - Porządkować instrukcje według zadań: sekcje dotyczące programowania, przeglądu, wydania oraz incydentów/debugowania - Określić sposób eskalacji: co zrobić w razie blokady lub napotkania nieoczekiwanego stanu

NIE NALEŻY: - Wklejać całych przewodników stylistycznych bez reguł wykonawczych - Używać niejednoznacznych wytycznych („zachowaj ostrożność”, „zoptymalizuj”) - Łączyć sprzecznych priorytetów (szybkość + wyczerpująca weryfikacja + brak budżetu na uruchomienie) - Pisać dokumentacji opisowej (AGENTS.md to zasady operacyjne, a nie README)

Przykład: produkcyjny plik 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 obszar istotny dla bezpieczeństwa, a nie wyłącznie jako kod źródłowy. Informacje o wydaniach Codex opisują tworzenie migawek powłoki i prace nad redagowaniem zmiennych środowiskowych, a system pamięci skanuje zapisywane dane w poszukiwaniu sekretów. Zabezpieczenia te nie sprawiają jednak, że dane uwierzytelniające można bezpiecznie wyświetlać w wynikach poleceń, transkrypcjach sesji, migawkach powłoki, lokalnych logach czy skryptach pomocniczych.³⁷⁵⁵⁹⁵

Zasada operacyjna jest prosta: nie należy wyświetlać sekretów, aby model mógł je analizować; dane uwierzytelniające narzędzi pomocniczych trzeba przechowywać w konfiguracji wymaganej przez środowisko; podczas audytów należy rozdzielać wykonywalny kod źródłowy, dokumentację, wygenerowaną pamięć podręczną, transkrypcje sesji, migawki powłoki, logi oraz celowe magazyny sekretów; lokalną historię trzeba redagować po wykryciu wzorca z dużym prawdopodobieństwem wskazującego na sekret; hooks zapobiegawcze należy wdrażać dopiero po sprawdzeniu ręcznego procesu higieny. Publicznie warto udostępniać mapę obszarów i kryteria akceptacji, a nie prywatne wartości tokenów, dokładne ścieżki czy wewnętrzne mechanizmy detektorów.⁹⁵

Mechanizm zastępowania

Plik AGENTS.override.md na dowolnym poziomie folderów zastępuje standardowy plik AGENTS.md w danym zakresie. Można go użyć w następujących sytuacjach:

• Zamrożenie wydania: „Bez nowych funkcji, tylko poprawki”
• Tryb incydentu: „Wszystkie zmiany muszą zostać sprawdzone przez osobę pełniącą dyżur”
• Tymczasowe wzmacnianie zabezpieczeń: „W tym sprincie bez aktualizacji zależności”

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

Można również zweryfikować łańcuch instrukcji:

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

Hooks

Codex wprowadził hooks w wersji v0.99.0 (AfterAgent) i v0.100.0 (AfterToolUse), a następnie w wersji v0.114.0 dodał eksperymentalny silnik hooks ze zdarzeniami SessionStart oraz Stop.⁷⁰ Od wersji v0.124.0 (23 kwietnia 2026) hooks są stabilne.⁸⁵ Można je teraz konfigurować bezpośrednio w plikach config.toml i requirements.toml — osobny plik skryptów hooks nie jest już potrzebny — a mechanizm obserwuje narzędzia MCP wraz z apply_patch i długo działającymi sesjami Bash. System obejmuje obecnie cykl życia sesji i automatyzację na poziomie narzędzi, niwelując różnicę względem modelu hooks w Claude Code.

Dostępne zdarzenia hooks

Konfiguracja hooks

Hooks konfiguruje się w pliku .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 hooka SessionStart trafia do kontekstu modelu, dlatego doskonale nadaje się do wstrzykiwania dynamicznych informacji — takich jak daty, nazwy gałęzi czy zmienne środowiskowe — na początku sesji.

Odtwarzanie wzorców hooks z Claude Code

Podczas migracji z Claude Code podobną automatyzację można uzyskać w następujący sposób:

Wskazówka ekspercka: Od wersji v0.124.0 (23 kwietnia 2026) silnik hooks jest stabilny. Nowe zdarzenia hooks nadal pojawiają się w kolejnych wydaniach — warto sprawdzać dziennik zmian Codex.

Przeglądarka hooks w TUI (v0.129.0): W TUI należy uruchomić /hooks, aby poznać dostępne hooks, sprawdzić, które z nich są obecnie aktywne, oraz włączać lub wyłączać poszczególne hooks bez edytowania config.toml. Przydaje się to podczas rozwiązywania problemów z nieprawidłowo działającym hookiem dołączonym do pluginu albo przy tymczasowym wyłączaniu lintera AfterToolUse na czas intensywnej sesji edytowania.⁸⁹

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 eksperymentalna, a polecenia i format konfiguracji mogą zmieniać się między wydaniami. Codex obsługuje dwa typy transportu: STDIO (procesy lokalne) oraz Streamable HTTP (serwery zdalne).¹¹

Zmiany MCP w v0.121.0: Narzędzia są teraz rejestrowane z przestrzenią nazw, dlatego ich nazwy na listach mają postać <server>:<tool> zamiast samych nazw — należy zaktualizować skrypty lub prompty wyszukujące niekwalifikowane nazwy narzędzi. Nowa flaga supports_parallel_tool_calls jest przekazywana do dołączonych MCP, umożliwiając wykonywanie równoległe w przypadku serwerów deklarujących jego obsługę. Metadane stanu sandboxa są teraz przekazywane przez metadane narzędzi MCP, dzięki czemu serwery mogą dostosowywać zachowanie (np. ostrzegać o działaniu w sandboxie tylko do odczytu). Własne żądanie codex/sandbox-state zostało usunięte — należy zamiast niego używać ścieżki metadanych. W tym wydaniu pojawia się faza 3 wdrażania aplikacji MCP z obsługą wywołań narzędzi; obsługiwane są teraz spłaszczone odroczone wywołania narzędzi dla serwerów korzystających ze wzorca deferred-call.⁸²

Zmiany MCP w v0.142.2 (25 czerwca 2026): Narzędzia MCP domyślnie używają teraz wyszukiwania narzędzi, gdy jest obsługiwane — zamiast wczytywać z góry definicję każdego narzędzia, Codex wykrywa narzędzia na żądanie, co usprawnia wykrywanie w konfiguracjach z dużą liczbą narzędzi przy zachowaniu zgodności ze starszymi modelami i providerami. Zdalne serwery stdio MCP akceptują także bezwzględne katalogi robocze zapisane w formacie ścieżek zdalnej platformy (ścieżkę w stylu Windows od klienta macOS lub odwrotnie).¹⁰⁵

Zmiany MCP w v0.147.0 (7 sierpnia 2026): Codex dodaje opcjonalną obsługę wersji protokołu MCP z 2026-07-28 — stronicowane wykrywanie (duże katalogi narzędzi są przesyłane stronami zamiast w jednej zbyt obszernej liście), żądania wielorundowe (serwer może utrzymać wieloetapową wymianę w ramach jednego logicznego żądania) oraz nieblokujące uruchamianie serwera, gdzie narzędzia MCP z cache są udostępniane przed zakończeniem uruchamiania serwera, dzięki czemu wolny serwer nie wstrzymuje już startu sesji. Obsługa jest opcjonalna, więc serwery korzystające ze starszej wersji działają bez zmian.¹¹⁶

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 sesji: /mcp wyświetla aktywne serwery i dostępne narzędzia. /mcp verbose (v0.123.0+)⁸⁴ zwraca pełną diagnostykę serwera, zasoby i szablony zasobów — jest to przydatne, gdy serwer nie chce się załadować lub narzędzia nie pojawiają się w oczekiwanym miejscu. Zwykłe /mcp pozostaje szybkie. Od v0.144.0 narzędzia MCP mogą żądać uwierzytelnienia interaktywnie bez eksperymentalnego opt-in — serwer wymagający uwierzytelnienia w trakcie sesji wyświetla monit w zwykłym przepływie zamiast kończyć się niepowodzeniem, dopóki nie zostanie wykonane wcześniejsze uwierzytelnienie za pomocą codex mcp login.¹⁰⁷

Wczytywanie MCP przez pluginy (v0.123.0+) akceptuje zarówno standardowy schemat mcpServers, jak i mapy serwerów na najwyższym poziomie w .mcp.json, dzięki czemu pluginy utworzone zgodnie z każdą z tych konwencji wczytują się poprawnie.⁸⁴

Uruchamianie Codex JAKO serwera MCP

Codex może udostępniać się jako serwer MCP do orkiestracji wielu agentów:¹²

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

Serwer udostępnia dwa narzędzia: 1. codex(): Rozpoczyna nową sesję z parametrami promptu, sandboxa, modelu i zatwierdzania 2. codex-reply(): Kontynuuje istniejącą sesję przy użyciu threadId i promptu

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: Rozwój świadomy kontekstu — Połącz Context7 z dokumentacją swojego frameworka, aby Codex zawsze miał aktualne odwołania API:

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

Wzorzec 2: Limity wyjścia — Odpowiedzi narzędzi MCP są domyślnie obcinane do 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ć je do konkretnych narzędzi i zachować skupienie odpowiedzi.

Wzorzec 2a: Multimodalne wyjście narzędzi (v0.107.0) — Własne narzędzia mogą teraz zwracać wyjście multimodalne (obrazy, rozbudowaną zawartość) obok tekstu. Umożliwia to narzędziom tworzącym artefakty wizualne — zrzuty ekranu, diagramy, renderingi wykresów — przekazywanie ich bezpośrednio do modelu w celu analizy.⁶²

Wzorzec 3: Zarządzanie MCP w przedsiębiorstwie — Można ograniczyć serwery 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 podczas uruchamiania. Pełną konfigurację zasad opisano w Wdrażanie przedsiębiorstwa.

Code Mode [EXPERIMENTAL]

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

Od v0.139.0 code mode może wywoływać samodzielne wyszukiwanie w sieci bezpośrednio — także z zagnieżdżonych wywołań narzędzi JavaScript — i otrzymuje wyniki w postaci zwykłego tekstu, dzięki czemu przepływ code mode może pobierać aktualne informacje bez opuszczania sandboxowego kontekstu kodowania.¹²² v0.146.0 rozszerza samodzielne wyszukiwanie w sieci na zgodnych niestandardowych providerów modeli, więc możliwość ta nie jest już ograniczona do modeli hostowanych przez OpenAI.¹¹⁴

v0.146.0 umożliwia app-server łączenie się z zdalnymi hostami Code Mode przez WebSocket, więc środowisko uruchomieniowe code mode nie musi już działać na tej samej maszynie co klient.¹¹⁴

Ta funkcja jest eksperymentalna. Należy sprawdzać informacje o wydaniach pod kątem aktualizacji.

Środowisko uruchomieniowe REPL JavaScript [REMOVED]

Codex v0.100.0 dodał eksperymentalne środowisko uruchomieniowe REPL JavaScript (js_repl), a v0.106.0 udostępnił je przez interfejs /experimental.⁶⁰ Te wskazówki mają teraz charakter historyczny. W v0.128.0 dziennik zmian 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 wykonywalna logika, należy użyć poleceń powłoki, skryptów dodanych do repozytorium, narzędzi MCP lub umiejętności Codex z katalogiem scripts/.

Czym są skills?

Skills to pakiety wielokrotnego użytku, zapewniające funkcje przeznaczone do konkretnych zadań, 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 skills wskazywane przez dowiązania symboliczne.

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

• Jawne: menu /skills lub wzmianka $skill-name w promptcie
• Niejawne: Codex automatycznie wykrywa skills pasujące do opisu zadania (jeśli allow_implicit_invocation: true)
• Kreator: aby interaktywnie utworzyć nową skill, należy użyć $skill-creator
• Instalator: aby zainstalować skills społeczności, należy użyć $skill-installer install <name>
• Udostępniane przez executor (v0.146.0): Codex wykrywa skills oferowane przez executor i odczytuje powiązane z nimi zasoby, w tym skills wybrane jawnie¹¹⁴

Budżety kontekstu ograniczają katalogi skills. W wersji v0.146.0 przy ograniczonym kontekście zachowywanych jest więcej dostępnych skills, a użytkownik otrzymuje ostrzeżenie, gdy katalog musi zostać skrócony.¹¹⁴ Wcześniej duża biblioteka skills mogła zostać skrócona bez powiadomienia, przez co oczekiwana skill po prostu nie była oferowana w danym kontekście. W przypadku korzystania z niejawnego wywoływania wielu skills warto zwracać uwagę na to ostrzeżenie.

Włączanie i 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: skill powinna być widoczna w TUI po użyciu /skills
2. Zweryfikować ścieżkę: upewnić się, że folder skill znajduje się w rozpoznawanej lokalizacji (~/.codex/skills/, katalogu głównym projektu lub /etc/codex/skills/)
3. Sprawdzić enabled: skills z wartością 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ędnienie w promptcie terminów z pola description danej skill zwiększa trafność niejawnego dopasowania

Przykład produkcyjny: skill do wdrażania

Kompletna, wieloplikowa skill pokazująca współdziałanie materiałów referencyjnych i skryptów:

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

Wtyczki

Wtyczki łączą skills, wpisy MCP, hooks i konektory aplikacji w jeden instalowalny pakiet (v0.110.0+).⁶⁵ Od v0.117.0 wtyczki są pełnoprawnymi elementami: wtyczki przypisane do produktu synchronizują się automatycznie przy uruchamianiu, a /plugins udostępnia przeglądarkę w TUI do ich odkrywania i zarządzania nimi.⁷⁵ v0.128.0 rozszerzyła przepływy pracy z wtyczkami o instalowanie z marketplace, cache zdalnych pakietów, zdalne API odinstalowywania, hooks dołączane do wtyczek, stan włączenia hooków oraz import konfiguracji zewnętrznych agentów.⁸⁶ v0.129.0 (7 maja 2026) dodaje udostępnianie wtyczek w workspace (przesyłanie zestawu wtyczek współpracownikom bez ponownego publikowania), kontrolę dostępu do udostępniania (włączanie/wyłączanie dla poszczególnych odbiorców, cofanie dostępu), filtrowanie źródeł (ograniczanie marketplace’ów, z których pobiera workspace) 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 audytowanie wyszukiwania wtyczek: dane listy uwzględniają marketplace, widoczne są zainstalowane wersje, wyświetlane są korzenie marketplace’ów, a zdalne kolekcje wtyczek można prezentować bez zgadywania, z którego rejestru pochodzi wynik.⁹⁸ v0.130.0 (8 maja 2026) zwiększa przejrzystość pakowania wtyczek i kontrolę nad przepływem udostępniania:⁹¹

• Hooks dołączone do wtyczki widoczne w szczegółach. Widok szczegółów /plugins wyświetla teraz każdy hook cyklu życia dołączony do wtyczki (SessionStart, UserPromptSubmit, Stop itd.). Przed zainstalowaniem wtyczki można dokładnie sprawdzić, które hooks zarejestruje dla sesji — koniec z nieoczekiwanymi efektami ubocznymi hooków z wtyczki, której ufa się wyłącznie ze względu na jej narzędzia.
• Metadane udostępnionej wtyczki w shareContext. Gdy wtyczka jest udostępniana z workspace, ładunek linku udostępniania ujawnia teraz metadane linku (twórcę, zakres, aktualność), dzięki czemu sesje odbierające mogą pokazać pochodzenie i zdecydować, czy je zaakceptować.
• Kontrola wykrywalności w ustawieniach udostępniania. Ustawienia udostępniania udostępniają przełącznik wykrywalności, dzięki któremu zespoły mogą publikować wtyczki w określonych workspace’ach lub dla list odbiorców bez udostępniania ich na ogół dostępnych listach w całej organizacji.

v0.143.0 (8 lipca 2026) domyślnie włącza zdalne wtyczki. Zdalne wtyczki są teraz włączone bez flagi opt-in, katalog /plugins zyskuje bogatsze wiersze (źródła marketplace npm obok git i lokalnych), a każdy wpis pokazuje zarówno swoją zdalną, jak i lokalnie zainstalowaną wersję, więc rozbieżności są widoczne od razu.¹⁰⁶ Dla zespołu standaryzującego wspólny zestaw wtyczek podejście zdalne domyślnie usuwa etap włączania na każdym komputerze, który wcześniej blokował wdrożenie.

Źródła wtyczek

Od v0.147.0 wyszukiwanie wtyczek obejmuje lokalne, osobiste, workspace i zdalne katalogi w jednym zapytaniu — wyszukuje się funkcję, a nie katalog, który akurat ją zawiera. W połączeniu z przenośnymi pakietami Agent Plugin wtyczka utworzona w jednym środowisku instaluje się poprawnie w innym, zamiast być powiązaną z komputerem lub workspace’em, w którym została utworzona.¹¹⁶

Odkrywanie wtyczek

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

Wzmianki @plugin (v0.112.0+)

Do dowolnej zainstalowanej wtyczki można odwołać się bezpośrednio w czacie za pomocą @plugin-name.⁶⁸ Po wspomnieniu wtyczki jej kontekst (możliwości, narzędzia, konfiguracja) jest automatycznie dołączany do okna kontekstu modelu — nie trzeba opisywać, co robi wtyczka.

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

Działa to z każdą zainstalowaną wtyczką, w tym z niestandardowymi skills, serwerami MCP i konektorami aplikacji.

Marketplace wtyczek (v0.113.0+)

Marketplace wtyczek obejmuje teraz bogatsze wyszukiwanie z metadanymi, kategoriami i ocenami.⁶⁹ Kontrole uwierzytelniania podczas instalacji weryfikują, czy wtyczki wymagające kluczy API lub OAuth mają prawidłowe poświadczenia przed instalacją. Endpoint odinstalowywania w czysty sposób usuwa wtyczki i powiązaną z nimi konfigurację.

Dodawanie marketplace’ów innych firm (v0.121.0+)

Aktualna dokumentacja OpenAI Codex zachowuje zarządzanie źródłami marketplace pod codex plugin marketplace. Formalizuje to dystrybucję wtyczek innych firm poza własnym marketplace OpenAI i obsługuje skrócony zapis repozytoriów GitHub, adresy Git HTTP(S), adresy URL SSH oraz lokalne katalogi główne marketplace’ów; użyj --ref, aby przypiąć ref Git, a --sparse PATH powtarzaj wyłącznie 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 git@example.com:team/plugins.git

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

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

Po dodaniu wtyczki z marketplace’u pojawiają się w przeglądarce /plugins obok domyślnych. Wywołujący app-servera (integracje IDE/desktop) mają równoległy endpoint do programowego rejestrowania marketplace’ów.⁸²

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

Agent Plugins: standard między dostawcami (v0.146.0–v0.147.0)

„Agent Plugins” to nie tylko nazwa funkcji Codex — to otwarty, neutralny wobec dostawców standard pakowania, opublikowany jako Agent Plugins 1.0.0 6 sierpnia 2026, którego oficjalna strona podsumowuje go jako „Przenośny format pakietu dla komponentów wielokrotnego użytku rozszerzających agentów AI”.¹¹⁸ Wtyczka to katalog z wymaganym manifestem plugin.json (zamknięty schemat dokładnie dziesięciu dozwolonych pól najwyższego poziomu — $schema, name, version, description, author, homepage, repository, license, keywords, extensions — gdzie „Clients MUST report and ignore each unknown field”), opcjonalnym folderem skills/ (każdy bezpośredni katalog podrzędny zawierający SKILL.md jest jednym skillem), opcjonalnym mcp.json deklarującym serwery stdio, Streamable HTTP lub starsze HTTP+SSE oraz opcjonalnymi katalogami przestrzeni nazw klienta o odwróconej domenie, które inni klienci „MUST ignore”. Jego normatywny zakres to pakowanie: specyfikacja „defines the canonical Agent Plugins Specification v1.0.0 for packaging reusable components that extend AI agents into distributable plugins” — Agent Skills i MCP zachowują własne specyfikacje pod nim.¹¹⁸

Kluczowa jest kwestia zarządzania standardem. Vercel zainicjował propozycję i opracował specyfikację 1.0 wspólnie z Amazon, Anysphere (Cursor), GitHub, Microsoft i OpenAI; lista opiekunów repozytorium specyfikacji obejmuje Amazon, Cursor, Microsoft, OpenAI i Vercel, a Google ogłosił w dniu premiery, że dołącza do głównych opiekunów.¹¹⁸ Wśród wskazanych klientów premierowych są ChatGPT, Codex, Cursor, GitHub Copilot, Kiro i VS Code. Jeden wyraźny brak: Anthropic, który stworzył bazowy format Agent Skills i samo MCP, nie należy do grona opiekunów — Claude Code zachowuje własny format wtyczek, a Codex wypełnia lukę ze swojej strony za pomocą źródła marketplace Claude Code (v0.146.0) i /import.¹¹⁸

W terminologii Codex: v0.146.0 dodaje manifesty Agent Plugins, publikowanie wtyczek w workspace oraz dwa dodatkowe marketplace’y wtyczek — Amazon Bedrock i Claude Code¹¹⁴ — a v0.147.0 zamyka pętlę instalacją przenośnych Agent Plugins oraz wyszukiwaniem w katalogach lokalnych, osobistych, workspace i zdalnych.¹¹⁶ Publikowanie w workspace to dla zespołów operacyjnie użyteczna połowa: wtyczki można publikować we własnym workspace zamiast tworzyć publiczny marketplace lub prosić każdego programistę o ręczne dodanie źródła Git.

Informacje o wydaniu ogłaszają powierzchnie Codex bez publikowania ich kluczy konfiguracji ani składni CLI. Ten wpis dokumentuje udostępnienie możliwości i specyfikację standardu, a nie sposób sterowania nim z Codex — przepływ pracy tworzenia manifestu oraz każde wywołanie codex plugin publish należy uznać za niezweryfikowane, dopóki dokumentacja OpenAI ich nie opisze.

Zarządzanie wtyczkami

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ć pojedyncze wtyczki bez opuszczania sesji.⁷⁵

Wskazówka ekspercka: Wtyczki konsolidują to, co wcześniej wymagało osobnej konfiguracji MCP, instalacji skills i konfiguracji konektora aplikacji. Pojedyncza wtyczka może zawierać wszystkie trzy elementy — dzięki temu wdrażanie zespołu jest szybsze, a konfiguracja bardziej przenośna.

Plan Mode i współpraca

Plan Mode umożliwia Codex opracowanie podejścia przed wprowadzeniem zmian. Jest domyślnie włączony (od wersji v0.94.0).¹⁴ Drzewo decyzyjne „Plan Mode a bezpośrednie wykonanie” znajduje się w sekcji Ramy podejmowania decyzji.

Włączanie Plan Mode

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

W Plan Mode Codex: - Odczytuje pliki i analizuje bazę kodu - Proponuje plan implementacji - Nie wprowadza zmian bez zatwierdzenia - Wyświetla plan na bieżąco w osobnym widoku TUI

Steer Mode

Steer Mode (domyślnie włączony od wersji v0.98.0) umożliwia przekazywanie nowych instrukcji podczas aktywnej pracy Codex bez przerywania bieżącego zadania.¹⁴

Instrukcje można przekazać na 2 sposoby:

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. Aby zaczekać z przekazaniem instrukcji do zakończenia pracy przez Codex, wystarczy wpisać je w zwykły sposób po zakończeniu tury — nie jest potrzebny żaden specjalny tryb.

Ulepszenia TUI (v0.105.0–v0.106.0)

Podświetlanie składni (v0.105.0): TUI podświetla teraz składnię w wydzielonych blokach kodu oraz różnice bezpośrednio w treści. Schemat kolorów można wybrać za pomocą /theme.⁶¹

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

Transkrypcja głosowa (v0.105.0, funkcja eksperymentalna): Naciśnięcie spacji pozwala dyktować prompty za pomocą transkrypcji głosowej. Ta funkcja jest eksperymentalna i może wymagać uprawnień dostępu do mikrofonu.⁶¹ Od wersji v0.107.0 sesje głosowe w czasie rzeczywistym obsługują wybór mikrofonu i głośników, co pozwala wskazać konkretne urządzenia wejścia i wyjścia audio.⁶² Usunięto w wersji v0.140.0, przywrócono w v0.145.0: eksperymentalne elementy sterujące głosem /realtime i ich zależności audio usunięto z TUI w wersji v0.140.0 (nie wpłynęło to na transkrypcję głosową uruchamianą spacją).¹⁰² W wersji v0.145.0 obsługa głosu powraca w nowej postaci: wejścia audio i dane wyjściowe narzędzi audio w popularnych lokalnych formatach audio, a także strumieniowe rozmowy realtime V3.¹¹²

Pozostałe ulepszenia: - Długie linki pozostają teraz klikalne nawet po zawinięciu do kolejnych wierszy TUI (v0.105.0)⁶¹ - Linki do lokalnych plików są wyświetlane z ulepszonym formatowaniem (v0.106.0)⁶⁰ - Markdown w TUI zachowuje klikalność linków internetowych dzięki metadanym OSC 8, a tabele, które nie mieszczą się w dostępnej przestrzeni, są wyświetlane jako czytelne rekordy klucz/wartość bez utraty adresów docelowych linków (v0.136.0)¹²⁵ - Poprawiono obsługę Ctrl+C w przypadku sub-agentów, aby prawidłowo kończyć procesy potomne (v0.106.0)⁶⁰

System pamięci

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

Polecenia pamięci

Informacje są przechowywane w plikach Markdown w katalogu ~/.codex/memory/. Codex wczytuje je przy rozpoczynaniu sesji i wykorzystuje do kształtowania swojego działania we wszystkich przyszłych sesjach.

Co warto przechowywać

Pamięć najlepiej sprawdza się w przypadku trwałych preferencji i informacji o projekcie:

• Konwencje projektu: „W tym projekcie używa się tabulatorów, a nie spacji” lub „Odpowiedzi API zawsze zawierają pole meta”
• Preferencje dotyczące narzędzi: „Używaj pnpm zamiast npm” lub „Uruchamiaj testy za pomocą pytest -x --tb=short”
• Decyzje architektoniczne: „Moduł uwierzytelniania znajduje się w src/core/auth/, a nie w src/middleware/”
• Preferencje dotyczące przepływu pracy: „Zawsze uruchamiaj linter przed pokazaniem mi różnic”

Pamięć w potokach

Podczas uruchamiania codex exec informacje z pamięci są wczytywane automatycznie. Dzięki temu potoki CI/CD i skrypty korzystają z tego samego kontekstu co sesje interaktywne — nie trzeba powtarzać instrukcji przy każdym uruchomieniu.

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

• Usuwanie danych poufnych: Przed zapisaniem na dysku informacje przeznaczone do pamięci są automatycznie skanowane pod kątem danych poufnych
• Uwzględnianie CWD: Pliki pamięci zawierają teraz kontekst katalogu roboczego, co ułatwia przywoływanie informacji dotyczących konkretnego projektu
• Wykluczenie komunikatów deweloperskich: Komunikaty deweloperskie i systemowe są wykluczane z danych wejściowych pamięci fazy 1, co poprawia jakość pamięci dzięki skupieniu się na interakcjach z użytkownikiem
• Zapominanie na podstawie różnic (v0.106.0): Pamięć wykorzystuje teraz mechanizm zapominania oparty na różnicach, aby usuwać nieaktualne fakty i z czasem zachowywać zwięzły oraz trafny zbiór informacji⁶⁰
• Wybór uwzględniający częstotliwość użycia (v0.106.0): Pobieranie informacji z pamięci uwzględnia teraz częstotliwość użycia, nadając priorytet informacjom często używanym i ostatnio istotnym⁶⁰
• Konfigurowalna pamięć (v0.107.0): Pamięć można teraz w pełni konfigurować. Polecenie codex debug clear-memories pozwala usunąć wszystkie zapisane informacje i rozpocząć od nowa — jest to przydatne przy przełączaniu się między niepowiązanymi projektami lub gdy stan pamięci przestał odpowiadać bieżącemu kontekstowi⁶²
• Uaktualnienie modelu fazy 2 (v0.121.0): Modelem konsolidacji pamięci w fazie 2 jest teraz gpt-5.4 (zamiast wcześniejszego modelu domyślnego). Potok fazy 2 działa między sesjami i przekształca transkrypcje z fazy 1 w trwałe fakty; zmiana modelu poprawia jakość przywoływania informacji przy takim samym koszcie tokenów.⁸²
• Menu pamięci w TUI (v0.121.0): Nowy interfejs dostępny podczas sesji umożliwia zarządzanie trybem pamięci, usuwanie poszczególnych informacji i resetowanie pamięci. Reset pamięci zachowuje wcześniejsze przebiegi, zamiast je unieważniać, dzięki czemu usuwa informacje przywoływane w przyszłości bez zakłócania odtwarzania sesji.⁸²

Pamięć a AGENTS.md

Wskazówka: Warto używać /m_update do zapisywania faktów, które powinny być przechowywane bezterminowo. Kontekst dotyczący wyłącznie bieżącej sesji wystarczy przekazać Codex bezpośrednio w rozmowie. Do udostępniania kontekstu całemu zespołowi należy użyć AGENTS.md.

Zarządzanie sesjami

Codex przechowuje sesje w ~/.codex/sessions/, umożliwiając wznawianie, rozgałęzianie i przepływy pracy z wieloma wątkami w CLI oraz na powierzchniach desktopowych.

v0.146.0 umożliwia adresowanie wątków. /new i /clear przyjmują teraz nazwę sesji, ważne wątki można przypinać, a rozmowy poboczne pozostają otwarte, zamiast wymuszać zamknięcie jednej, aby przejść do innej.¹¹⁴ W praktyce długotrwały projekt przestaje być listą znaczników czasu, które trzeba rozpoznawać po dacie. v0.147.0 dodaje sekcje rozmów: rozmowy są organizowane w trwałe, ręcznie uporządkowane sekcje, a długie transkrypcje są przeglądane stopniowo, zamiast ładować je w całości.¹¹⁶

Wznawianie

Kontynuowanie od miejsca, w którym przerwano:

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 ukośnikowe /resume w TUI otwiera ten sam interaktywny selektor z wyszukiwaniem.

Stronicowana historia wątków (v0.145.0) [EXPERIMENTAL]: Eksperymentalna stronicowana historia wątków zapewnia efektywne wznawianie, wyszukiwanie w historii, zachowywane nazwy wątków, obsługę sub-agentów i pamięci w zarządzaniu sesjami — historia ładuje się strona po stronie, a nie cała naraz, co ma znaczenie w długo używanych katalogach roboczych z setkami sesji. To funkcja eksperymentalna: należy oczekiwać zmian interfejsu między wydaniami.¹¹²

Rozgałęzianie

Rozgałęzianie rozmowy pozwala badać alternatywy bez utraty bieżących postępów:

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

Rozgałęzienia tworzą niezależne wątki współdzielące tę samą historię do punktu rozgałęzienia. Od v0.146.0 historia rozgałęzień jest stronicowana, a rozgałęzienia mogą być tworzone jako tymczasowe — tymczasowe rozgałęzienie nie pojawia się na listach wątków, dzięki czemu jednorazowe eksperymenty nie zaśmiecają listy wątków, po której faktycznie odbywa się nawigacja.¹¹⁴ Zmiany w jednym rozgałęzieniu nie wpływają na drugie. Jest to przydatne do porównywania podejść (np. „utwórz rozgałęzienie i wypróbuj Redis zamiast Memcached”) lub bezpiecznego badania ryzykownych zmian.

Rozgałęzianie wątków do sub-agentów (v0.107.0): Wątki można teraz rozgałęziać do niezależnych sub-agentów, co pozwala rozmowie uruchamiać równoległe strumienie pracy wykonywane autonomicznie. Rozszerza to istniejący model rozgałęziania — zamiast jedynie rozdzielać rozmowę, rozgałęziony wątek staje się sub-agentem z własnym kontekstem wykonawczym.⁶² Od v0.117.0 sub-agenci używają adresów opartych na ścieżkach (np. /root/agent_a) ze strukturalnym przesyłaniem wiadomości między agentami, dzięki czemu koordynacja wielu agentów jest bardziej jednoznaczna i łatwiejsza do debugowania.⁷⁵

Szyfrowane wiadomości między agentami (v0.138.0+): Multi-agent v2 teraz szyfruje tekst zadania, który agent nadrzędny wysyła podczas uruchamiania lub wysyłania wiadomości do sub-agenta. Parametry wiadomości spawn_agent, send_message i followup_task są oznaczone jako szyfrowane: Responses API szyfruje ładunek, gdy model nadrzędny emituje wywołanie narzędzia, lokalnie uruchomiony Codex przenosi wyłącznie tekst zaszyfrowany (InterAgentCommunication.encrypted_content, z pustą treścią jawną), a API odszyfrowuje go po stronie serwera, przekazując go modelowi odbierającemu.¹⁰⁸ Ma to trzy praktyczne konsekwencje:

• Lokalne logi sesji nie zawierają już jawnego tekstu delegowania. Można zobaczyć, że agent nadrzędny uruchomił sub-agenta i co wróciło, ale nie dokładną instrukcję, którą wysłał. W przypadku audytu lub debugowania przebiegów z wieloma agentami na podstawie historii sesji ten zapis nie jest dostępny; otwarte zgłoszenie regresji śledzące ten problem nie ma powiązanej poprawki według stanu na połowę lipca 2026 r.¹⁰⁹ Zdarzenia cyklu życia rozszerzeń (uruchomienie/zatrzymanie subagenta, wykonanie narzędzia, metadane tury — v0.133.0+) oraz obserwowalność app-server pozostają mechanizmami umożliwiającymi odtworzenie przebiegu zdarzeń.⁹⁸
• Modele niestandardowych dostawców mogą przestać działać. Punkt końcowy modelu, który nie jest skonfigurowany do użycia szyfrowanych narzędzi, odrzuca zaszyfrowany schemat spawn_agent z błędem 400 ("declares encrypted parameters but is not configured for encrypted tool use"). Jeśli delegowanie do wielu agentów nie powiedzie się z tym błędem u niestandardowego dostawcy, przyczyną jest zmiana szyfrowania, a nie konfiguracja.
• Powiadomienia generowane przez Codex pozostają czytelne. Powiadomienia o zakończeniu pracy przez dzieci są generowane przez sam Codex, dlatego pozostają w postaci jawnego tekstu i są teraz renderowane jako typowane elementy agent_message, a nie serializowane koperty JSON.¹⁰⁸

OpenAI nie opublikowało modelu zagrożeń stojącego za tą zmianą; PR opisuje przepływ tekstu zaszyfrowanego bez określenia, przed czym ma on chronić.

Stabilizacja multi-agent v2 (v0.145.0, opt-in): Doświadczenie multi-agent v2, które zadebiutowało w v0.137.0 i zyskało szyfrowane delegowanie w v0.138.0, jest teraz ustabilizowane jako funkcja opt-in. v0.145.0 dodaje konfigurowalne modele sub-agentów, poziomy rozumowania dla poszczególnych sub-agentów, konfigurowalną współbieżność, przywrócone role multi-agent oraz ulepszoną nawigację po agentach. Jeśli wdrożenie v2 zostało odłożone podczas okresu stabilizacji v0.137/v0.138, jest to wydanie, w którym powierzchnia konfiguracji się ustala — wybór modelu i poziomu rozumowania sub-agenta znajduje się teraz w konfiguracji, zamiast być narzucony przez środowisko wykonawcze.¹¹²

Lista wątków

Wyświetlanie i zarządzanie aktywnymi sesjami:

/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 różnic.

Cykl życia sesji

Sesje synchronizują się między CLI a aplikacją desktopową — można rozpocząć w jednej i kontynuować w drugiej.

Tryb nieinteraktywny (codex exec)

codex exec uruchamia Codex w trybie nieinteraktywnym 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 i zdarzenia do stderr, a końcową wiadomość agenta do stdout. Dzięki takiej konstrukcji można go łączyć ze standardowymi potokami systemu Unix.

Archiwizowanie sesji (v0.136.0)

Sesje można archiwizować, aby zachować przejrzystość listy wznawiania i rozwidlania bez usuwania historii. Archiwizację można wykonać w TUI za pomocą /archive albo z poziomu powłoki:¹²⁵

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

Zarchiwizowana sesja jest chroniona przed wznowieniem lub rozwidleniem do czasu jej przywrócenia z archiwum — to zabezpieczenie przed przypadkowym kontynuowaniem sesji, która miała zostać wycofana. W tym samym wydaniu: codex app-server --stdio uruchamia app-server w trybie stdio na potrzeby integracji z edytorami i hostami, a /diff nie może już wykonywać dostarczonych przez repozytorium pomocniczych narzędzi Git (poprawka bezpieczeństwa poleceń). W systemie Windows ścieżka aprowizacji w wersji alfa dodaje dla administratorów polecenie codex sandbox setup --elevated.¹²⁵

Dane wyjściowe w wierszach JSON

Po użyciu --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}}

Ustrukturyzowane dane wyjściowe

Można wymusić strukturę odpowiedzi za pomocą schematu JSON:

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

-o / --output-last-message zapisuje końcową wiadomość do pliku.

Wznawianie i przeglądanie 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

Najważniejsze flagi

Uwierzytelnianie w CI

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

Baner startowy codex exec (v0.130.0). Baner startowy codex exec nie wyświetla już wcześniejszego określenia „research preview”. Jeśli system CI analizuje dane wyjściowe uruchamiania, tekst banera jest teraz krótszy; ustrukturyzowane zdarzenia --json pozostają bez zmian.⁹¹

codex remote-control (v0.130.0+)

codex remote-control to polecenie najwyższego poziomu, które uruchamia bezinterfejsowy app-server przeznaczony do sterowania przez inny proces — rozszerzenia IDE, niestandardowe orkiestratory lub zdalne płaszczyzny sterowania. Zastępuje ono wieloflagowe wywołanie codex app-server, które wielu integratorów składało ręcznie, i zapewnia narzędziom innych firm jeden stabilny punkt dostępu do tego samego środowiska uruchomieniowego app-server, które jest dostarczane z interfejsami aplikacji desktopowej i IDE.⁹¹ Wersja v0.133.0 usprawnia sposób działania polecenia: może ono działać jako polecenie pierwszoplanowe, czekać na gotowość, raportować stan maszyny, a jednocześnie udostępniać jawne polecenia start / stop w stylu demona na potrzeby długotrwałych konfiguracji kontrolera.⁹⁸ Wersja v0.143.0 dodaje codex remote-control pair, które generuje ręczny kod parowania z działającego demona, dzięki czemu kontroler może się połączyć bez automatycznego uzgadniania wykrywania — jest to przydatne, gdy proces sterujący działa na innym hoście lub w innym segmencie sieci niż demon.¹⁰⁶

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

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

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

Podczas tworzenia interfejsów użytkownika, które muszą wyliczać obszerne historie wątków bez jednoczesnego wczytywania do pamięci każdej tury, należy połączyć codex remote-control z opisanymi poniżej mechanizmami API stronicowania app-server.

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

Klienty app-server mogą teraz stronicować duże wątki za pomocą 3 odrębnych widoków elementów tur:⁹¹

Stronicowanie warto połączyć z interfejsem ThreadStore, wprowadzonym w wersji v0.121.0, aby sprawnie przeglądać długotrwałe wątki — zwłaszcza we wdrożeniach zdalnego sterowania, w których orkiestrator może znajdować się na innej maszynie niż pliki przebiegu.⁸² Wersja v0.143.0 rozszerza zakres danych dostępnych kontrolerowi: klienty app-server mogą teraz wyliczać dostępne środowiska, wyświetlać wątki potomne danego wątku oraz rozwidlać historię od określonej tury — są to mechanizmy potrzebne interfejsowi użytkownika do utworzenia odgałęzienia przebiegu od wcześniejszego punktu bez ponownego odtwarzania go aż do przodu.¹⁰⁶

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

Aktywne wątki app-server uwzględniają teraz zmiany w config.toml bez konieczności ponownego uruchamiania — wystarczy zmodyfikować i zapisać konfigurację, a działający wątek zastosuje nowe wartości przy następnej turze. Jest to poprawka uzupełniająca codex remote-control: długotrwale działający bezinterfejsowy serwer można skonfigurować ponownie bez jego wyłączania.⁹¹

Szyfrowane zdalne executory (v0.141.0)

Od wersji v0.141.0 (stabilnej, 18 czerwca 2026) zdalne executory łączą się za pośrednictwem uwierzytelnianych, kompleksowo szyfrowanych kanałów Noise-relay — płaszczyzna sterowania i executor nie muszą już ufać pośredniczącemu przekaźnikowi, co ma znaczenie zawsze wtedy, gdy orkiestrator steruje app-server przez granicę sieci. To samo wydanie sprawiło, że zdalne wykonywanie między platformami zachowuje natywny katalog roboczy i powłokę executora, więc kontroler działający w jednym systemie operacyjnym i sterujący executorem w innym nie powoduje już niejawnego przekształcania ścieżek ani semantyki powłoki. TLS akceptuje teraz również podpisy certyfikatów P-521, co zapewnia zgodność z firmowymi serwerami proxy.¹⁰³

Codex Cloud i zadania w tle [EXPERIMENTAL]

Status: Codex Cloud jest funkcją eksperymentalną. Interfejsy, ceny i dostępność mogą ulec zmianie. OpenAI zarządza środowiskami chmurowymi, a użytkownik nie ma kontroli nad infrastrukturą.

Codex Cloud uruchamia zadania asynchronicznie w środowiskach zarządzanych przez OpenAI.⁴ Informacje o integracji Codex z potokiem CI zawiera również sekcja GitHub Action i CI/CD.

Jak to działa

1. Przesłanie zadania (przez chatgpt.com/codex, integrację ze Slack lub CLI)
2. Codex klonuje repozytorium do izolowanego sandboxa w chmurze
3. Agent pracuje samodzielnie: odczytuje kod, uruchamia testy i 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

Dostęp agenta do internetu jest domyślnie wyłączony i konfigurowany osobno dla każdego środowiska:

• Wyłączony: brak dostępu agenta do internetu (ustawienie domyślne)
• Włączony: opcjonalna lista dozwolonych domen i ograniczenia metod HTTP

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

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

Integracja ze Slack

Aby rozpocząć zadanie w chmurze, należy wspomnieć @Codex na kanale lub w wątku Slack.

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 przestrzeni roboczej

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

CLI chmury

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)

Codex Desktop App

Aplikacja Codex Desktop App (macOS i Windows) udostępnia interfejs graficzny zoptymalizowany pod kątem zarządzania wieloma projektami.¹⁶ Wersja dla systemu Windows została wydana 4 marca 2026 roku z natywną obsługą PowerShell i natywnym sandboxem systemu Windows.⁶⁶

Instalacja

codex app                      # Auto-downloads and installs on first run

Można też pobrać bezpośrednio: Codex.dmg (macOS) | Dostępna w Microsoft Store (Windows)

Najważniejsze funkcje

Appshots, komentarze w przeglądarce i Computer Use

Aktualizacje aplikacji z 21 maja sprawiają, że aplikacja desktopowa staje się rozbudowanym źródłem kontekstu, a nie tylko narzędziem do zarządzania wątkami. Z funkcji Appshots warto korzystać, gdy przed podjęciem działania Codex potrzebuje informacji o stanie innej aplikacji na Macu: Codex przechwytuje okno znajdujące się na pierwszym planie oraz dostępny tekst widoczny i znajdujący się poza ekranem, który udostępnia aplikacja, a następnie zapisuje załącznik lokalnie w historii sesji.⁹⁹

Przy pracy nad stronami internetowymi i frontendem warto najpierw korzystać z przeglądarki w aplikacji, jeśli strona nie wymaga uwierzytelnienia: zapewnia ona użytkownikowi i Codex wspólny podgląd wyrenderowanej strony, obsługuje działania w przeglądarce, takie jak klikanie, wykonywanie zrzutów ekranu, pobieranie zasobów i inspekcja JavaScript tylko do odczytu, a także pozwala oznaczać obszary strony komentarzami, do których Codex może odnieść się w następnej turze.⁹⁹ W przypadku witryn wymagających zalogowania należy nadal korzystać z rozszerzenia Chrome.

Z funkcji Computer Use należy korzystać tylko wtedy, gdy nie można zweryfikować zadania za pomocą integracji strukturalnej ani podglądu w przeglądarce. Funkcja ta może analizować i obsługiwać dozwolone aplikacje na Macu, lecz w przypadku edycji plików i poleceń powłoki podlega regułom akceptacji i sandboxa Codex. Użycie po zablokowaniu pozostaje ściśle ograniczone: po zablokowaniu Maca Codex może tymczasowo uzyskiwać dostęp do dozwolonych aplikacji podczas aktywnych, zaufanych tur Computer Use, z zabezpieczeniami wymuszającymi ponowne blokowanie i wykrywaniem lokalnych działań użytkownika.⁹⁹

Tryby wątków

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

Mechanizm izolacji Worktree:

Po uruchomieniu wątku Worktree aplikacja desktopowa: 1. Tworzy nowy git worktree (git worktree add) w katalogu tymczasowym 2. Tworzy i przełącza się na nową gałąź na podstawie bieżącego HEAD 3. Uruchamia agenta wewnątrz worktree — wszystkie zmiany plików pozostają odizolowane 4. Po zakończeniu przedstawia różnice do przeglądu — można wybrać zmiany, które mają zostać scalone z powrotem

Dzięki temu w tym samym repozytorium może jednocześnie działać wiele wątków Worktree bez konfliktów. Każdy otrzymuje własną gałąź i katalog roboczy.

Automatyzacje

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

• W repozytoriach Git automatyzacje korzystają z dedykowanych worktrees działających w tle, odizolowanych od katalogu roboczego
• W projektach innych niż Git zadania są wykonywane bezpośrednio w katalogu projektu
• Automatyzacje korzystają z domyślnych ustawień sandboxa

Konfigurowanie automatyzacji: 1. Otworzyć projekt w aplikacji desktopowej 2. Kliknąć kartę Automations na pasku bocznym 3. Zdefiniować wyzwalacz (harmonogram, webhook lub uruchomienie ręczne) 4. Wprowadzić prompt i wybrać tryb wykonywania (local lub worktree) 5. Ustawić poziom rozumowania dla uruchomienia automatyzacji (App v26.312)⁷² 6. Automatyzacje są uruchamiane zgodnie z harmonogramem, a ich wyniki trafiają do kolejki przeglądu

Przykładowe zastosowania: - Klasyfikacja zgłoszeń: automatyczne kategoryzowanie nowych zgłoszeń i nadawanie im priorytetów - Monitorowanie CI: obserwowanie nieudanych kompilacji i sugerowanie poprawek - Reagowanie na alerty: reagowanie na alerty monitoringu za pomocą analizy diagnostycznej - Aktualizacje zależności: sprawdzanie i stosowanie poprawek zabezpieczeń

Wyniki pojawiają się w kolejce przeglądu, gdzie wymagają zatwierdzenia przez człowieka.

Obsługa systemu Windows

Aplikacja Codex Desktop App została wydana dla systemu Windows 4 marca 2026 roku (App v26.304) z natywną obsługą PowerShell, natywnym sandboxem systemu Windows i pełnym zestawem funkcji, w tym skills, automatyzacjami i worktrees, bez konieczności korzystania z WSL.⁶⁶

GitHub Action i CI/CD

Oficjalna GitHub Action integruje Codex z potokiem 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

Dane wyjściowe: final-message, tekst końcowej odpowiedzi Codex przeznaczony dla kolejnych kroków lub zadań.

Strategie bezpieczeństwa

Kontrola dostępu

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

Domyślnie: przepływy pracy Codex mogą wyzwalać wyłącznie współpracownicy z uprawnieniami do zapisu.

Codex SDK

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

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 za pomocą klucza API, przepływy ChatGPT w przeglądarce/kodu urządzenia, inspekcja konta i wylogowanie to podstawowe ścieżki SDK.⁹⁷
• Ułatwienie dla tur wyłącznie tekstowych (v0.132.0+): Tury Python API akceptują zwykłe ciągi znaków i zwracają bogatsze metadane TurnResult z zebranymi elementami, czasem i wykorzystaniem.⁹⁷
• outputSchema: Wymuszanie końcowego wyniku w formacie JSON
• Dane wejściowe multimodalne: Przekazywanie tekstu + lokalnych obrazów ({ type: "local_image", path: "..." })
• Przepływy pracy z obrazami (v0.117.0): view_image zwraca adresy URL, wygenerowane obrazy można ponownie otworzyć, a historia obrazów jest zachowywana po wznowieniu sesji⁷⁵
• view_image w wielu środowiskach (v0.130.0): W przypadku sesji obejmujących wiele środowisk (wprowadzonych w v0.124.0 wraz z wyborem środowiska i katalogu roboczego dla każdej tury oraz udoskonalonych w v0.125.0 przez trwałe środowiska), view_image rozwiązuje teraz ścieżki plików przez wybrane środowisko, a nie 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ą zapisywane w ~/.codex/sessions.

Środowisko wykonawcze: Node.js 18+.

Optymalizacja wydajności

Zarządzanie kontekstem

Okna kontekstowe różnią się w zależności od modelu. Obecna rodzina GPT-5.6 (Sol, Terra, Luna) działa z oknem 272K; GPT-5.5, flagowy model poprzedniej generacji, oferuje 400K w Codex (1M w API); GPT-5.4 / GPT-5.4-mini (wycofywane z Codex 31 sierpnia 2026 r.) oferują 1M / 400K; starsza rodzina GPT-5.3-Codex działała z budżetem 272K danych wejściowych + 128K danych wyjściowych (400K łącznie). Wszystkie zapełniają się szybciej, niż można się spodziewać — warto zarządzać nimi proaktywnie:

1. Regularnie używać /compact: Podsumowuje historię rozmowy, aby zwolnić tokeny
2. Udostępniać lokalną dokumentację: Wysokiej jakości AGENTS.md i lokalna dokumentacja ograniczają nakład związany z eksploracją (która zużywa kontekst)
3. Używać @ do dołączania konkretnych plików: Warto odwoływać się bezpośrednio do plików, zamiast prosić Codex o ich znalezienie
4. Utrzymywać skupione prompty: Prompty o wyraźnym zakresie i wskazanych plikach 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 gpt-5.6-luna z niskim poziomem rozumowania
3. Równoległe wykonywanie narzędzi: Codex uruchamia niezależne odczyty i kontrole równocześnie, dlatego warto formułować prompty tak, aby to umożliwić
4. Pętle zorientowane na wynik: Zamiast instrukcji krok po kroku warto poprosić: „zaimplementuj, przetestuj, napraw, zatrzymaj się, gdy wszystko będzie zielone”

Jak diagnozować problemy?

Typowe problemy i rozwiązania

Informacje o błędach

Do czego służy codex doctor?

codex doctor to jedno polecenie, które warto uruchomić przed zgłoszeniem błędu lub diagnozowaniem uszkodzonej instalacji. Zbiera w jednym raporcie informacje o lokalnym środowisku uruchomieniowym, konfiguracji, uwierzytelnianiu, terminalu, sieci i stanie, a własny szablon zgłoszenia projektu prosi o wklejenie jego danych wyjściowych.¹²⁰

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

Raport jest uporządkowany w stałe sekcje, więc można szybko przejść do potrzebnej:¹²⁰

Każda kontrola ma znacznik stanu — ✓ ok, ✗ błąd, ⚠ ostrzeżenie, ○ bezczynny — oraz wiersz podsumowania. --json nadaje każdej kontroli stabilny identyfikator, dzięki czemu narzędzie można wykorzystać w CI lub skrypcie wsparcia, a nie tylko do ręcznej oceny.¹²⁰

Polecenie rozbudowywano w kolejnych wydaniach: pojawiło się w v0.131.0, w v0.135.0 zyskało raportowanie środowiska, Git, terminala, app-servera i inwentarza wątków, a w v0.139.0 dodano szczegóły edytora i pagera (z wrażliwymi wartościami zredagowanymi w JSON).^96126122

Używać najpierw, nie na końcu. Większość zgłoszeń „Codex jest zepsuty” sprowadza się do czegoś, co doctor już wskazuje: nieaktualnego trybu uwierzytelniania, config.toml, którego nie udało się przeanalizować, albo drugiej instalacji zasłaniającej tę znajdującą się w PATH.

Narzędzia diagnostyczne

codex doctor                           # Full local diagnostic (start here)
codex --version                        # Check CLI version
codex login status                     # Verify authentication
codex mcp list                         # Check MCP server status
codex debug app-server --help          # Debug app server issues

Diagnostyka TUI w trakcie 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

Zachowuje ~/.codex/ (uwierzytelnianie, konfigurację, sesje). Aby przypiąć dokładną wersję, obniżyć wersję po nieudanym wydaniu lub całkowicie wyczyścić stan, zobacz Aktualizacja, obniżanie wersji lub odinstalowywanie.

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 na github.com/openai/codex/issues.¹

Codex Security [PREVIEW]

Codex Security wszedł do wersji zapoznawczej badań 6 marca 2026 r., wprowadzając do stosu Codex analizę bezpieczeństwa aplikacji uwzględniającą kontekst.⁷⁷ Funkcja jest dostępna dla klientów ChatGPT Pro, Enterprise, Business i Edu za pośrednictwem Codex web.

Jak to działa: Codex Security analizuje repozytoria, aby stworzyć model zagrożeń specyficzny dla projektu, identyfikuje podatności sklasyfikowane według rzeczywistego wpływu oraz testuje ustalenia pod presją w środowisku sandbox, aby je zweryfikować. Agent przedstawia ustalenia o wyższej wiarygodności wraz z poprawkami, ograniczając szum pochodzący z nieistotnych błędów.

Wydajność: W trakcie wersji zapoznawczej badań Codex Security przeskanował 1,2 miliona commitów i zidentyfikował 10 561 podatności o wysokiej istotności. Precyzja z czasem się poprawiła — szum zmniejszono o 84%, zawyżanie istotności ograniczono o ponad 90%, a wskaźnik wyników fałszywie pozytywnych zmniejszono o połowę. System wykrył rzeczywiste podatności w OpenSSH, GnuTLS i Chromium, a przypisano 14 CVE.⁷⁷

Uwaga: Codex Security jest odrębny od wbudowanego modelu bezpieczeństwa sandbox CLI. Sandbox chroni maszynę przed Codex; Codex Security chroni kod źródłowy przed podatnościami.

Wdrożenie w przedsiębiorstwie

Kontrole administracyjne (requirements.toml)

Administratorzy egzekwują politykę przedsiębiorstwa za pomocą requirements.toml, pliku konfiguracji wymuszanego przez administratora, który ogranicza ustawienia wrażliwe z punktu widzenia bezpieczeństwa i których użytkownicy nie mogą zmienić:²¹

v0.146.0 dodaje rozpoznawanie planu Enterprise oraz kontrolę administratora nad aktualizacjami w aplikacji.¹¹⁴ W zarządzanej flocie oznacza to różnicę między samodzielnym aktualizowaniem przez deweloperów CLI po zauważeniu nowej wersji a decyzją administratora o tym, kiedy dana wersja zostanie wdrożona. Informacje o wydaniu zapowiadają tę kontrolę, nie publikując jednak jej klucza requirements.toml — do czasu udokumentowania go przez OpenAI należy uznać dokładną nazwę ustawienia za niezweryfikowaną.

# /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 ustawiania preferencji przez config.toml na poziomie użytkownika, requirements.toml stanowi warstwę twardych ograniczeń, która zawęża wartości dostępne dla użytkowników i nie może być przez nich nadpisana. Reguły wymagań administratora mogą wyłącznie pytać albo zabraniać (nigdy po cichu zezwalać).

Konfiguracja macOS MDM

Dystrybucję przez MDM należy przeprowadzić z użyciem domeny preferencji com.openai.codex.²¹ Codex obsługuje standardowe ładunki macOS MDM (Jamf Pro, Fleet, Kandji itd.). Należy zakodować TOML w base64 bez zawijania wierszy:

Kolejność pierwszeństwa (od najwyższej do najniższej):

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

Wymagania z chmury wypełniają wyłącznie nieustawione pola wymagań, dlatego warstwy zarządzane o wyższym pierwszeństwie zawsze mają przewagę. Wymagania z chmury działają w trybie best-effort; jeśli pobranie się nie powiedzie lub przekroczy limit czasu, Codex działa dalej bez warstwy chmurowej.

Integracja z OpenTelemetry

Codex obsługuje propagację kontekstu śledzenia OpenTelemetry ze standardowych zmiennych środowiskowych OTel aż do wywołań API OpenAI. 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 zasobu)
• Kontekst śledzenia jest propagowany przez Codex do wywołań API, umożliwiając obserwowalność end-to-end
• Atrybuty zasobu można wykorzystać do oznaczania śledzeń według zespołu, środowiska lub projektu
• Przy włączaniu rejestrowania promptów/narzędzi należy uwzględnić wymagania dotyczące prywatności — śledzenia mogą zawierać fragmenty kodu
• Konfigurowalne metadane śledzenia OpenTelemetry (v0.130.0+). Poza standardową otoczką OTEL_RESOURCE_ATTRIBUTES, crate codex-otel udostępnia teraz konfigurowalne metadane śledzenia, dzięki którym administratorzy mogą oznaczać śledzenia wymiarami specyficznymi dla organizacji (centrum kosztów, identyfikator projektu, odwołanie do zgłoszenia) bez ponownego tworzenia od podstaw OTEL_RESOURCE_ATTRIBUTES przy każdym uruchomieniu. W połączeniu z bogatszą analityką przeglądów/feedbacku udostępnioną w tym samym wydaniu umożliwia to ujednolicone debugowanie i triage w sesjach CLI, app-server oraz remote-control.⁹¹

Dostęp przedsiębiorstwa

• 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 kontrola organizacji/projektu API. OpenAI publikuje raporty SOC 2 Type II i SOC 3; BAA HIPAA jest dostępne w warstwie Enterprise
• Codex SDK: Osadzanie w wewnętrznych narzędziach i przepływach pracy
• Egzekwowanie polityk na dużą skalę: Należy użyć dystrybuowanego przez MDM requirements_toml_base64 albo /etc/codex/requirements.toml na poziomie systemu plików

Obsługa danych i zgodność: - Dane wejściowe/wyjściowe API nie są wykorzystywane do trenowania zgodnie z warunkami OpenAI Business/Enterprise/API - W przypadku rezydencji danych ruch OpenAI API jest domyślnie kierowany przez infrastrukturę w USA; w sprawie wymagań dotyczących rezydencji danych w UE należy skontaktować się z zespołem sprzedaży Enterprise OpenAI - Transkrypcje sesji są przechowywane lokalnie; tylko wywołania API opuszczają urządzenie - 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żenie dla 3–5 starszych inżynierów z requirements.toml wymuszającym tryb sandbox untrusted oraz wyszukiwanie w sieci cached. Należy zebrać opinie o wzorcach AGENTS.md i potrzebach dotyczących serwerów MCP.
2. Rozszerzenie na zespół (tydzień 3–4): Wdrożenie dla całego zespołu. Dystrybucja standardowego dla zespołu config.toml przez MDM lub repozytorium. Włączenie sandbox workspace-write dla zaufanych repozytoriów.
3. Integracja z CI (tydzień 5–6): Dodanie codex-action do potoków CI/CD na potrzeby automatycznego przeglądu PR i generowania testów. Użycie --ephemeral, aby utrzymać przewidywalność kosztów.
4. Cała organizacja (miesiąc 2+): Wdrożenie przez MDM z requirements.toml wymuszającym zatwierdzone serwery MCP, polityki sandbox i listy dozwolonych modeli.

Wzorce audytu

Należy śledzić użycie Codex i egzekwować zgodność:

• Śledzenia OpenTelemetry: Monitorowanie liczby 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 wrażliwych kontekstach należy wyłączyć za pomocą --ephemeral)
• Egzekwowanie tożsamości MCP: requirements.toml rejestruje zablokowane próby użycia serwera — należy przeglądać je pod kątem nieautoryzowanego użycia narzędzi
• Ścieżka audytu Git: Wszystkie zmiany plików Codex przechodzą przez standardowy git — przegląd poprzez historię gałęzi i różnice PR

Sprawdzone praktyki i antywzorce

Wzorce tworzenia promptów

1. Prompty oparte na ograniczeniach: Zacznij od granic. „NIE zmieniaj kontraktów API. Refaktoryzuj wyłącznie wewnętrzną implementację”.
2. Ustrukturyzowane kroki reprodukcji: Numerowane kroki prowadzą do lepszych poprawek błędów niż ogólne opisy
3. Prośby o weryfikację: Zakończ słowami „Uruchom lint + najmniejszy odpowiedni zestaw testów. Podaj polecenia i wyniki”.
4. Odwołania do plików: Użyj @filename, aby dołączyć konkretne pliki do kontekstu
5. Pętle ukierunkowane na wynik: „Zaimplementuj, uruchom testy, napraw błędy, zakończ dopiero, gdy wszystkie testy przejdą pomyślnie”. Codex iteruje aż do ukończenia

Filozofia testowania

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

• Zdefiniuj testy z wyprzedzeniem jako sygnały ukończenia
• Pozwól Codex iterować, aż testy przejdą pomyślnie (czerwony → zielony → refaktoryzacja)
• Stosuj wzorce programowania Tiger Style
• Podawaj dokładną treść plików podczas proszenia o poprawki. Codex używa ścisłego dopasowywania, a nie rozmytego patchowania opartego na AST

Sprawdzone praktyki zarządzania kontekstem

• Zapewniaj wysokiej jakości lokalną dokumentację zamiast polegać na wyszukiwaniu w sieci
• Utrzymuj uporządkowany Markdown ze spisami treści i plikami postępu („stopniowe ujawnianie”)
• Ujednolicaj zakończenia linii (LF vs CRLF) we wszystkich śledzonych plikach, aby zapobiegać błędom patchowania
• Zachowuj zwięzłość AGENTS.md, ponieważ długie instrukcje wypadają z kontekstu

Workflow Git

• Zawsze twórz nową gałąź przed uruchomieniem Codex w nieznanych repozytoriach
• Używaj workflow opartego na patchach (git diff / git apply) zamiast bezpośrednich edycji
• Przeglądaj sugestie Codex tak jak PR-y podczas code review
• Użyj /diff, aby zweryfikować zmiany przed zatwierdzeniem

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ębnia wnioski 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 frontendów gotowych do produkcji

Społecznościowe skills: - claude-skill: Przekazywanie zadań do Claude Code z trybami uprawnień - autonomous-skill: Automatyzacja zadań w wielu sesjach ze śledzeniem postępów - deep-research: Równoległa orkiestracja podzadań - kiro-skill: Potok wymagania → projekt → zadania → realizacja

Antywzorce

Typowe błędy, które marnują tokeny, dają słabe wyniki lub prowadzą do frustrujących workflow.

Antywzorce kosztowe

Antywzorce związane z kontekstem

Antywzorce workflow

Antywzorce promptów

Przepisy workflow

Kompletne wzorce 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

Przejrzyj wygenerowany plik AGENTS.md, dostosuj go do swoich konwencji, a następnie:

> Run the health endpoint test and confirm it passes

Przepis 2: Codzienny workflow programistyczny

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.

Przejrzyj zmiany za pomocą /diff, a następnie wykonaj commit.

Przepis 3: Złożona refaktoryzacja w trybie planu

codex

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

Przejrzyj plan. Zatwierdź go lub skieruj Codex inaczej:

[Tab] Also add a migration script using Alembic

Po wykonaniu zmian przez Codex zweryfikuj je:

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

Przepis 4: Przegląd PR za pomocą codex exec

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

Przepis 5: Debugowanie za pomocą 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."

Sprawdź postęp później:

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

Zastosuj poprawkę lokalnie po ukończeniu:

codex apply <TASK_ID>

Przewodnik migracji

Z Claude Code

Najważniejsze różnice, które warto 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ń hooks: 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 Claude Code nadal zapewnia szerszy zakres. W przypadku wzorców automatyzacji, które nie są jeszcze obsługiwane, należy użyć instrukcji AGENTS.md lub skills.
• Sub-agenci v2 (v0.117.0): Sub-agenci używają teraz adresów opartych na ścieżkach (np. /root/agent_a), ze strukturyzowaną komunikacją między agentami i listowaniem agentów.⁷⁵ Rozszerza to istniejącą mechanikę (maks. 6 równoczesnych, zmniejszone z 12 w v0.91.0). Role wieloagentowe pozostają konfigurowalne za pomocą config (v0.104.0+).⁴⁷ Wersja v0.105.0 dodała spawn_agents_on_csv do rozdzielania pracy między wiersze z monitorowaniem postępu i ETA.⁶¹ Codex nadal nie ma wyraźnego UX narzędzia Task w Claude Code do delegowania zadań kierowanego przez użytkownika — w przypadku wzorców delegowania należy użyć cloud tasks lub orkiestracji SDK.
• AGENTS.md działa 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 działa wyłącznie w Claude.
• Profiles zastępują ręczne przełączanie: Zamiast zmieniać flagi przy każdym uruchomieniu, warto zdefiniować profiles w config.toml.

Z GitHub Copilot

Co zyskuje użytkownik: - Sandbox na poziomie systemu operacyjnego (Seatbelt/Landlock — wymuszany przez jądro zamiast oparty na kontenerach) - Delegowanie cloud tasks za pomocą codex apply - Profile config do przełączania przepływów pracy - Aplikację desktopową z izolacją worktrees

Z Cursor

Karta szybkiego odniesienia

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

Dziennik zmian