OpenAI Codex CLI — The AI Toolchain

OpenAI Codex CLI rust-v0.152.0-alpha.6

Mon, 31 Aug 2026 02:12:53 GMT

Codex CLI alpha.6 adds actionable rate-limit banners in the TUI and makes the `update_plan` tool opt-in via config. • Adds `tools.update_plan.enabled` config key (defaults to `false`); set it to `true` to explicitly expose the `update_plan` tool — removing bundled planning guidance from prompts when disabled. • Adds actionable rate-limit banners in the TUI rendered above the composer, with actions for usage, credits, resets, owner notifications, plan management, and automatic fallback-model switching when instructed by the banner. • Sets `history_ingest_requested` to `true` in Responses turn metadata when the history-notes token-budget extension is enabled, and reserves the key so caller-provided metadata cannot override it. Breaking changes: • The `update_plan` tool now defaults to disabled (`tools.update_plan.enabled: false`); any workflow relying on `update_plan` being available by default will stop receiving it until the key is explicitly set to `true`.

OpenAI Codex CLI rust-v0.152.0-alpha.5

Mon, 31 Aug 2026 01:11:03 GMT

Codex CLI now accepts package-style MCP server names containing `:`, `@`, `/`, and `.` • MCP server names may now contain `:`, `@`, `/`, and `.` in addition to letters, numbers, `-`, and `_`, enabling names like `npm:@modelcontextprotocol/server-sequential.thinking` across `mcp add`, `get`, `list`, and `remove` commands, runtime tool namespaces, and OAuth credential lookup.

OpenAI Codex CLI rust-v0.152.0-alpha.4

Sun, 30 Aug 2026 13:56:08 GMT

Codex CLI gains clock tools from model metadata, per-tool MCP output limits, configurable sleep-tool gating, and elicitation form support. • Adds `clock.curr_time` and `clock.sleep` tools when a model lists `clock` in `experimental_supported_tools` metadata, with current-time reminder injection controlled separately by the `current_time_reminder` feature. • Adds configurable gating for the sleep tool. • Adds Vim search motions to the TUI composer. • Subagents now follow the root service tier. • Guardian context rolls over before follow-up reviews to handle exhausted context windows, replaying the full transcript and image evidence after compaction. • History notes images are forwarded to the model. • MCP HTTP helper headers are refreshed after authorization failures. • Executor hooks now run for interrupted turns.

OpenAI Codex CLI rust-v0.151.0-alpha.7.2

Sat, 29 Aug 2026 21:46:50 GMT

Adds configurable `sleep_tool` feature gating, model-metadata-driven clock tools, and one-shot exec fallback with `timeout_ms` in managed mode. • Adds `features.sleep_tool` config key with `model_driven` and `always_on` modes to independently gate registration of the built-in sleep tool, separate from the broader clock tool. • Registers both `clock.curr_time` and `clock.sleep` tools automatically when a model advertises `clock` in its `experimental_supported_tools` metadata. • Preserves `exec_command` in completion-only (one-shot) mode when `unified_exec` is disabled, adding a `timeout_ms` argument and terminating timed-out commands with exit code 124. • Removes `tty`, `yield_time_ms`, `session_id`, and `write_stdin` from one-shot exec mode when `unified_exec` is disabled. Breaking changes: • `tty`, `yield_time_ms`, `session_id`, and `write_stdin` are removed from `exec_command` when operating in completion-only mode with `unified_exec` disabled.

OpenAI Codex CLI rust-v0.152.0-alpha.1

Sat, 29 Aug 2026 10:47:53 GMT

Codex CLI 0.152.0-alpha.1 adds clock tools, configurable sleep gating, per-tool MCP output limits, configurable thread shell timeouts, and elicitation form support. • Adds configurable gating for the `sleep` tool, allowing it to be independently controlled. • Adds support for per-tool MCP output limits to cap individual tool response sizes. • Adds support for configurable timeouts for thread shell commands. • Adds support for `openai/elicitation` form requests in the agent runtime. • Exposes the PowerShell version in environment context for Windows sessions. • Adds app-server notification media filtering to suppress media from function call output notifications. • Supports compression for shared rollout lineages. • Preloads plugin recommendations during session startup for faster availability. • Forwards history note images to the model for multimodal context. • Makes subagents follow the root service tier for consistent resource usage. • Supports app targets in executor plugin hooks.

OpenAI Codex CLI rust-v0.151.0

Sat, 29 Aug 2026 09:55:39 GMT

Codex CLI adds configurable MCP startup grace period, extension MCP result interception, and per-repo plugin catalog merging. • Adds a configurable grace period for discovering tools from optional MCP servers at startup, preventing slow servers from blocking the agent. • Enables extensions to inspect or replace MCP tool results before they reach the model, allowing middleware-style transformation of tool output. • Plugin catalogs now merge per-repository configuration with global settings and surface invalid project marketplace entries without suppressing valid plugins.

OpenAI Codex CLI rust-v0.151.0-alpha.12

Sat, 29 Aug 2026 01:29:50 GMT

Codex CLI alpha.12 adds compression for shared rollout lineages, per-tool MCP output limits, and configurable shell command timeouts. • Adds opt-in `local_thread_store_shared_compression` feature flag to enable zstd compression for shared rollout lineages, including referenced sources and fork pointers. • Supports per-tool MCP output limits, letting operators cap how much output individual MCP tools can return. • Records `codex.app_server.codex_home.size_bytes` metrics for `CODEX_HOME`, `sessions`, and `archived_sessions` subdirectories at app-server startup. • Responds to terminal queries from TTY subprocesses, improving compatibility with interactive tools run inside the agent. • Restricts cloud task credentials to trusted origins, narrowing the credential exposure surface.

OpenAI Codex CLI rust-v0.151.0-alpha.11

Fri, 28 Aug 2026 21:28:20 GMT

Adds configurable `timeoutMs` to `thread/shellCommand` and platform-aware Windows shell guidance for `exec_command`. • Adds optional `timeoutMs` parameter to `thread/shellCommand` to set per-command deadlines; defaults to one hour when omitted or `null`, treats `0` as an immediate timeout, and rejects negative values. • Adapts `exec_command` tool description to include Windows-specific safety guidance when the executor platform is Windows, and omits it for non-Windows executors. • Measures `CODEX_HOME` disk usage at app-server startup, recording `codex.app_server.codex_home.size_bytes` for the home directory and `sessions` / `archived_sessions` subdirectories.

OpenAI Codex CLI rust-v0.151.0-alpha.3

Wed, 26 Aug 2026 23:07:13 GMT

Codex CLI adds `write_stdin_approval` feature flag to gate input to escalated terminals and exposes MCP provenance to tool lifecycle extensions. • Adds `write_stdin_approval` feature flag (disabled by default) to require an explicit approval before sending non-empty input to an escalated unified-exec terminal, routing reviews through hooks, Guardian, app-server, and the TUI as `writeStdin` approvals. • Exposes MCP provenance metadata via optional `McpToolContext` in `ToolStartInput`, classifying MCP calls as connectors, configured servers, plugin servers, executor-selected plugins, or other registrations. • Gives Guardian a bounded trusted context fragment for user-configured MCP tools and connectors, while keeping tool descriptions, outputs, and unrelated tools untrusted. • Records Windows sandbox world-writable scan results in the `codex.windows_sandbox.world_writable_scan_flagged_directories` histogram, tagged with `success` or `error`, for both startup and warning-triggered scans. • Prearms Guardian's WebSocket pool in a background task so thread startup and resume are no longer blocked by initial Guardian connection delays.

OpenAI Codex CLI rust-v0.151.0-alpha.2

Wed, 26 Aug 2026 21:27:08 GMT

Codex CLI adds Guardian V2 risk score persistence, dedicated Guardian endpoints, Vim buffer jump motions, and layered plugin config support. • Adds `features.guardianv2.persist_scores` config option (default `false`) to opt into writing Guardian V2 reviewed actions and risk scores to rollout files for debugging. • Adds `features.guardianv2.free_guardian` config option to route eligible Guardian reviews to `/guardian` and asynchronous classifications to `/guardian-classifier` instead of `/responses`. • Honors layered configuration (not just user config) when loading plugins and marketplace sources. • Adds Vim buffer jump motions to the TUI. • Attaches originating Responses item ID to MCP tool request metadata as `_meta.itemId`. • Classifies streaming rate-limit errors as `RateLimitExceeded` for more precise error handling. • Enables clock tools for persistent reasoning turns. • Restricts macOS scratch directory access to process sandboxes. • Records `call_id` and `action` fields on `SecurityRiskScore` so persisted scores identify the tool call and bounded action that produced them.

OpenAI Codex CLI rust-v0.150.0

Wed, 26 Aug 2026 19:37:28 GMT

Codex CLI v0.150.0 adds task `@` mentions, `/copy` target picker, `Interrupt` hooks, and keybindings for permission-mode cycling. • Adds `/copy` command picker to select full responses, individual code blocks, or blockquotes when copying output. • Adds `/rename` command that suggests an editable title for the current task based on the conversation. • New `Interrupt` hooks let you run commands or MCP handlers when an active top-level turn is interrupted. • Adds keybindings for cycling through TUI permission modes, and `.` in Vim mode to repeat the last edit. • Supports referencing other Codex tasks with `@` mentions, enabling agents to read, create, or message tasks from the terminal. • Unnamed terminal tasks now receive descriptive titles automatically. • Markdown links render as clickable labels in supported terminals, with visible URLs retained in other terminals.

OpenAI Codex CLI rust-v0.150.0-alpha.11

Tue, 25 Aug 2026 21:30:06 GMT

Codex CLI alpha.11 adds per-turn cyber access program selection and hardens MCP OAuth callback handling. • Adds the experimental `turn/start.cyberAccessProgram` option with `standard`, `daybreakBlue`, and `daybreakRed` values, forwarded as `access_programs.cyber` on Responses, WebSocket, and remote-compaction requests when using ChatGPT authentication. • Hardens MCP OAuth callback handling by validating issuer-bound authorization responses, persisting registered callback URLs for MCP servers and plugins, and inserting the active listener port into portless loopback redirects. • Adds a hidden `--feedback` flag to `codex doctor` that bounds each SQLite database integrity scan to a one-second deadline when collecting diagnostic attachments. • Restricts `--code-mode-host` on the app server to accept only `http://` and `https://` gRPC endpoints; WebSocket (`ws://`, `wss://`) host URLs are now rejected at CLI parse time. Breaking changes: • The app server `--code-mode-host` flag no longer accepts `ws://` or `wss://` URLs; only `http://` and `https://` gRPC endpoints are valid. Any configuration passing a WebSocket URL to `--code-mode-host` will fail at startup.

OpenAI Codex CLI rust-v0.150.0-alpha.10

Tue, 25 Aug 2026 20:36:48 GMT

Codex CLI alpha.10 adds managed AWS Bedrock access keys, computer-use-only Guardian scope, dot-repeat in Vim mode, and OTEL turn-cost metrics. • Adds `features.guardianv2.review_scope.computer_use_only` config key to restrict async Guardian v2 classification and fast approvals exclusively to browser and computer-use REPL tools, keeping all other tools on the synchronous approval path. • Adds `amazonBedrockAccessKeys` login flow, persisting SigV4-signed credentials in the configured auth store and reporting `bedrockAccessKeys` as a distinct auth mode. • Adds `root_turn_id` field to turn and tool-item analytics events to associate subagent activity with its originating top-level turn. • Introduces paginated thread history APIs and defaults durable threads to paginated history. • Adds Amazon Bedrock setup to the TUI onboarding flow. • Adds worktree settings parser for per-worktree configuration. • Brokers credential aliases in child environments, replacing embedded credentials with broker dummies and restoring only virtualized aliases. • Shows reconnect guidance in the TUI when disconnecting from tasks. • Allows extensions to skip host skill discovery. • Reconnects MCP servers automatically when authentication mode changes or startup timeout is updated.

OpenAI Codex CLI rust-v0.150.0-alpha.9

Tue, 25 Aug 2026 12:51:26 GMT

Codex CLI adds managed AWS access keys for Amazon Bedrock, computer-use-only Guardian v2 scope, OTEL turn-cost metrics, and dot-repeat in Vim mode. • Adds `BedrockAccessKeys` as a distinct auth mode, enabling the experimental `amazonBedrockAccessKeys` app-server login flow with SigV4-signed Bedrock requests; credentials are persisted in the configured auth store and reported as `bedrockAccessKeys` in login status. • Adds `features.guardianv2.review_scope.computer_use_only` config option to restrict async classification and fast approvals exclusively to browser and computer-use REPL tools, giving this scope precedence over `sandboxed_exec_commands` when both are enabled. • Brokers credential aliases in child environments by discovering, replacing, and restoring credentials inherited from the parent even when their canonical provider variable is filtered out of the child environment. • Adds dot-repeat support to Vim mode in the TUI. • Generates descriptive TUI thread titles and suggests conversation-based titles via `/rename`. • Persists realtime events in the thread timeline and adds persisted thread artifact models. • Adds hooks for interrupted turns.

OpenAI Codex CLI rust-v0.149.1

Mon, 24 Aug 2026 00:28:28 GMT

Codex CLI gains `--thread-source` flag to classify new threads, plus an opt-in `compaction_image_budget` for image-aware remote compaction. • Adds global `--thread-source ` flag to `codex exec` to classify newly created or forked threads (e.g. `automated_review`, `memory_consolidation`); defaults to `user` when omitted and does not override the source when resuming an existing thread. • Adds opt-in `compaction_image_budget` feature to charge retained images against the remote compaction budget using the existing image size estimate, preventing image-heavy histories from exceeding the intended context budget.

OpenAI Codex CLI rust-v0.149.0-alpha.4.3

Sun, 23 Aug 2026 23:29:33 GMT

Codex CLI gains `--thread-source` flag for classifying new threads, plus Amazon Bedrock multi-agent and compaction improvements. • Switches Amazon Bedrock to multi-agent V1 protocol, which does not require response items unsupported by Bedrock. • Enables Responses compaction (`compaction_trigger` items via `/v1/responses`) for Amazon Bedrock, bringing it in line with OpenAI and Azure Responses providers.

OpenAI Codex CLI rust-v0.150.0-alpha.7

Sat, 22 Aug 2026 21:26:34 GMT

Codex CLI adds app signature verification, MCP event streaming, shell snapshot caching, hostname in TUI status, and `codex agents` session config • Adds `codex agents` subcommand to allow session configuration directly from the CLI. • Adds keybindings for cycling TUI permission modes interactively. • Adds a response target picker to the `/copy` command. • Enforces issuer binding for MCP OAuth endpoints. • Enables discovery of HTTP MCP servers from selected executors. • Supports attaching to existing realtime calls. • Enforces environment network policies for remote execution. • Makes tool-result telemetry limits configurable. • Ignores project instructions for untrusted projects.

OpenAI Codex CLI rust-v0.149.0-alpha.7.2

Sat, 22 Aug 2026 19:48:54 GMT

Amazon Bedrock gets multi-agent V1 support and Responses-based compaction; Guardian reviews now cancel with their tool calls. • Enables multi-agent V1 protocol for Amazon Bedrock models, which do not support the response items required by multi-agent V2. • Switches Amazon Bedrock remote compaction to `compaction_trigger` items sent through `/v1/responses`, replacing the legacy dedicated compaction protocol. • Propagates tool cancellation tokens into Guardian approval reviews so interrupting a tool also aborts its pending review, including server-initiated MCP approval elicitation. Breaking changes: • The legacy dedicated compaction protocol is removed from provider capabilities; remote compaction now defaults to unsupported and must be explicitly enabled per provider (currently OpenAI, Azure Responses, and Amazon Bedrock).

OpenAI Codex CLI rust-v0.150.0-alpha.6

Fri, 21 Aug 2026 22:42:06 GMT

Codex CLI alpha.6 adds Guardian internal sessions, Amazon Bedrock app-server setup, browser/computer-use config, and a response target picker for `/copy`. • Adds a response target picker to the `/copy` command, letting users choose which response to copy. • Implements Amazon Bedrock setup in the app server, enabling Bedrock-backed model configuration. • Adds browser and computer-use configuration and exposes browser/computer-use requirements through the app server. • Adds Guardian internal session support, with escalated commands routed through synchronous Guardian review and Guardian reviews reused in async risk scoring. • Enforces environment network policies for remote execution, composing owner rules with controller constraints and saved network decisions. • Hides Fast mode status for models that do not support it.

OpenAI Codex CLI rust-v0.150.0-alpha.3

Fri, 21 Aug 2026 16:43:40 GMT

Codex CLI alpha.3 adds `codex agents` session config, TUI permission-mode keybindings, and existing-realtime-call attachment. • Adds `previous_permission_mode` and `next_permission_mode` actions to `tui.keymap.chat` in `config.toml`, letting users bind keys to cycle through available built-in permission modes in the TUI. • Adds `existingCall` transport to `thread/realtime/start`, accepting a client-provided `callId` and optional `realtimeSessionId` so clients can attach Codex to a pre-negotiated realtime call. • Allows `codex agents` to accept session-configuration options — model, approval policy, sandbox mode, web search, working directory, and config overrides — when opening the agents dashboard. • Discovers HTTP MCP servers from selected executors and honors required MCP servers declared by those executors. • Enforces issuer binding for MCP OAuth endpoints. • Adds in-memory shell snapshots to unified exec and honors request PATH in exec-server shell snapshots. • Supports voice-aware configuration and version-skew builds.

OpenAI Codex CLI rust-v0.150.0-alpha.2

Fri, 21 Aug 2026 04:24:03 GMT

Codex CLI alpha adds macOS app signature verification, shell snapshot caching, MCP event streaming, and Amazon Bedrock multi-agent support. • Adds `additional_developer_instructions` to managed requirements, exposed via `configRequirements/read` as `additionalDeveloperInstructions`, with a 10,000 estimated-token size limit. • Adds app-server MCP event streaming. • Adds hostname to the configurable TUI status line. • Adds history and notes tools for token-budget sessions. • Adds `resolve_permission_profile_selection` to select the effective permission profile using configured defaults, managed requirements, and allowlists without compiling platform-specific paths. • Verifies Codex desktop app bundle signatures using Apple codesign (bundle identifier `com.openai.codex`, team ID `2DC432GLL2`) before launching or installing on macOS. • Enables multi-agent V1 protocol and Responses compaction for Amazon Bedrock models. • Requires filesystem backends to implement directory walks with bounded local walks on a blocking task, including symlink cycle detection, deterministic ordering, error collection, and response-size limits. • Includes suggestion IDs in plugin install metadata. • Supports turn cost telemetry for custom model providers. • Supports standalone named function call outputs handled as external context. • Refreshes bundled model definitions. • Retries transient registry failures during initial exec connection.

OpenAI Codex CLI rust-v0.149.0-alpha.4.1

Fri, 21 Aug 2026 02:28:23 GMT

Codex CLI adds Amazon Bedrock multi-agent V1 support and Responses-based compaction for Bedrock providers. • Enables multi-agent V1 protocol for Amazon Bedrock models, normalizing Bedrock model catalogs to advertise `MultiAgentVersion::V1` to work around Bedrock's lack of support for response items required by multi-agent V2. • Switches Amazon Bedrock remote compaction to use `compaction_trigger` items sent through `/v1/responses` instead of the legacy dedicated compaction protocol, and explicitly enables remote compaction for OpenAI, Azure Responses, and Amazon Bedrock providers. Breaking changes: • The legacy dedicated compaction protocol is removed from provider capabilities; remote compaction now defaults to unsupported and must be explicitly enabled per provider.

OpenAI Codex CLI rust-v0.150.0-alpha.1

Thu, 20 Aug 2026 22:06:34 GMT

Codex CLI 0.150.0-alpha.1 adds app signature verification, shell snapshot caching, MCP event streaming, and configurable TUI hostname display. • Adds `shellSnapshotV2` executor capability and an optional shell snapshot request to `ExecParams`, caching and restoring Unix shell state and profile exports for `bash`, `zsh`, and `sh` in an in-memory, attachment-scoped cache. • Adds `additional_developer_instructions` to managed requirements, exposed through `configRequirements/read` as `additionalDeveloperInstructions`, with a 10,000 estimated-token size limit and support across compaction, resume, and agent forks. • Adds app-server MCP event streaming support. • Adds hostname to the configurable TUI status line. • Verifies Codex desktop app bundle signatures against OpenAI's Apple Team ID (`2DC432GLL2`) using `codesign --verify --deep --strict` before launch or install. • Adds `resolve_permission_profile_selection` to select the effective permission profile using configured defaults, managed requirements, and allowlists, returning a merged catalog without compiling platform-specific paths. • Requires filesystem backends to implement directory walks natively, with bounded local walks including symlink cycle detection, deterministic ordering, error collection, and response-size limits. • Supports turn cost telemetry for custom model providers. • Supports standalone named function call outputs handled as external context. • Refreshes bundled model definitions. • Retries transient registry failures during initial exec server connection. • Includes suggestion IDs in plugin install metadata. • Supports host-accepted exec-server WebSockets.

OpenAI Codex CLI rust-v0.149.0

Thu, 20 Aug 2026 21:04:55 GMT

Codex CLI v0.149.0 adds an interactive agents dashboard, `codex queue`, TUI working-directory commands, and expanded `codex doctor` diagnostics. • Adds `codex agents` command with an interactive dashboard for searching, starting, opening, renaming, and stopping tasks, with configurable shortcuts. • Adds `codex queue` command for sending messages to existing local or remote sessions. • Adds `/cd`, `/pwd`, and `/cwd` commands for managing the working directory inside TUI sessions. • Expands `codex doctor` to diagnose endpoint protection, network/proxy failures, desktop app state, Windows sandbox provisioning, and update connectivity. • SDK users can now pass exact CLI config overrides and select `max` or `ultra` reasoning effort. • Expands Vim editing in the TUI composer with character replacement and change motions including `cw`, `c$`, and `cc`.

OpenAI Codex CLI rust-v0.149.0-alpha.4

Thu, 20 Aug 2026 09:39:59 GMT

Codex CLI alpha.4 raises MCP tool name limit to 128 bytes, adds `--no-alt-screen` flag, warns on deprecated `codex mcp-server`, and hardens sandbox IPC isolation. • Adds `--no-alt-screen` flag to the `resume` and `fork` subcommands, preserved across both interactive and subcommand invocations. • Emits a deprecation warning when `codex mcp-server` is invoked: 'warning: `codex mcp-server` is deprecated and will be removed in a future release.' • Passes `--unshare-ipc` in Bubblewrap sandbox arguments to isolate IPC namespaces in both restricted-filesystem and full-filesystem sandbox paths. • Guardian V2 now satisfies required model reviews and skips sandboxed shell commands by default. • Exposes permission profile resolution in the core API. • Validates linked worktrees before inheriting project trust. • Binds MCP OAuth refresh tokens to their issuer and hardens OAuth fallback credential writes. • Applies composer editing preferences to TUI text prompts. • Preserves inline TUI scrollback in Windows Terminal. • Shows strict review warnings in the TUI and hides approved automatic review warnings. • Prompts to unarchive sessions before resuming or forking. • Adds cwd-relative turn diff paths. • Enforces filesystem permissions when loading `AGENTS.md`. • Advertises the Desktop app in graphical Linux sessions. • Restricts plugin migration to home scope and hardens skill installation against unsafe symlinks. • Streams executor capability and skill file reads. Breaking changes: • The `untrusted` approval policy has been retired and is no longer available.

OpenAI Codex CLI rust-v0.149.0-alpha.1

Wed, 19 Aug 2026 00:54:20 GMT

codex doctor gains endpoint protection, network, desktop, sandbox, and security diagnostics in v0.149.0-alpha.1 • Expands `codex doctor` with desktop app diagnostics, desktop update diagnostics, and desktop security enforcement diagnostics. • Improves `codex doctor` network diagnostics with dedicated network checks via new `network` module. • Adds sandbox checks to `codex doctor` via new `sandbox_check`. • Adds working-directory commands to the TUI, letting users change the working directory from within the interactive session. • Adds a configurable skill catalog token budget. • Isolates external editor buffers from sandbox-writable paths, protecting composer text from exposure under restricted filesystem policies. • Adds experimental app-server project APIs. • Enforces environment-specific command policies and honors per-environment shell variable policies. • Restricts MCP HTTP redirects to the configured origin and isolates MCP resource headers during OAuth requests. • Adds managed gates for in-app chat and dictation. • Compacts successful command activity in the TUI for a cleaner transcript view. • Enables editing queued messages with Vim history-up bindings. • Identifies Mac mini hosts in remote control handshakes. Breaking changes: • Rejects obsolete app-server permission profile fields — configs using removed fields will be refused on upgrade. • Stops loading legacy managed config on Windows.

OpenAI Codex CLI rust-v0.148.0

Tue, 18 Aug 2026 22:26:03 GMT

Codex CLI gains Markdown conversation export, session forking/archiving, Bedrock support, and async hooks in v0.148.0 • Adds `/export` TUI command to export complete conversations to Markdown, sending output to the clipboard or a new file. • Adds `codex exec fork` subcommand to fork sessions, plus archive and restore actions in the TUI resume picker. • Adds Amazon Bedrock Runtime as a built-in provider with AWS profile, region, and GPT-5.6 routing support. • Hooks can now run commands asynchronously and invoke MCP tools. • Adds `/status` command display and status-line/terminal-title indicators for estimated thread credits or cost in eligible workspaces. • Draft prompts can now be composed while the TUI initializes, with resume and fork progress shown during startup.

OpenAI Codex CLI rust-v0.148.0

Tue, 18 Aug 2026 22:26:03 GMT

Codex CLI v0.148.0 adds Markdown export, session forking, Amazon Bedrock, async hooks, and cost visibility in the TUI. • Adds `/export` TUI command to export full conversations to Markdown, either to the clipboard or a new file. • Adds `codex exec fork` subcommand to fork sessions, plus archive and restore actions in the TUI resume picker. • Adds Amazon Bedrock Runtime as a built-in provider with AWS profile, region, and GPT-5.6 routing support. • Hooks can now run commands asynchronously and invoke MCP tools. • Adds estimated thread credits or cost display in `/status`, status lines, and terminal titles for eligible workspaces. • Supports drafting prompts while the TUI initializes, with resume and fork progress shown during startup.

OpenAI Codex CLI rust-v0.148.0-alpha.23

Tue, 18 Aug 2026 21:23:03 GMT

Codex CLI alpha.23 adds exec-server forwarding mode, PowerShell Tree-sitter safety analysis, and hardens auth isolation for custom providers. • Adds exec-server forwarding mode via a new `ExecServerSubcommand` (accessible as `codex exec-server `), enabling the exec-server to be composed in additional topologies. • Adds `--remote ` flag to `exec-server` (now marked `global`) for registering the exec-server as a remote environment, and makes `--strict-config` global so subcommands inherit it. • Adds a fail-closed Tree-sitter-based PowerShell lowerer that converts a conservative subset of literal PowerShell commands into argument vectors, rejecting dynamic expressions, `#requires` directives, and unrecognized syntax instead of guessing. • Adds symlink-safe reading of sensitive files via `read_sensitive_file_to_string`, refusing to follow the final symlink component on Unix or reparse points on Windows. • Rejects symbolic links used as memory workspace roots and removes links created during consolidation, preventing path-traversal out of the workspace. • Adds provider-owned authentication recovery, allowing providers to handle their own auth refresh flow independently. • Scopes MCP resource reads by connector, preventing cross-connector data access. • Requires fresh approval beneath denied permission paths, closing a re-approval gap in the permission model. • Adds Guardian v2 approval review metrics, risk classification improvements, and Node REPL policy injection into Guardian review sessions. • Reconnects WebRTC Realtime sideband transports on disconnection for improved reliability of real-time agent communication.

OpenAI Codex CLI rust-v0.148.0-alpha.23

Tue, 18 Aug 2026 21:23:03 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.22

Tue, 18 Aug 2026 13:30:36 GMT

Codex CLI adds `codex agents` dashboard, desktop diagnostics in `codex doctor`, and queued-message dispatch for multi-process sessions. • Adds `codex agents` as a dedicated interactive task dashboard command for monitoring and navigating agents in the TUI. • Adds desktop app diagnostics and desktop update diagnostics to `codex doctor`, covering app-server handshake status, security enforcement (macOS Gatekeeper/XProtect, Windows), and update state. • Adds a command to queue messages for existing sessions, enabling other processes to write to a running thread's durable queue and have idle threads dispatch them automatically. • Adds configurable keyboard shortcuts for the agents dashboard. • Restricts MCP HTTP redirects to the configured origin, tightening network policy for MCP app integrations. • Applies user MCP policy to selected executor plugins. • Adds network policy metadata to environment configuration. • Raises the GPT-5.6 maximum context window. • Drops capabilities from Linux sandbox processes, hardening the sandbox security posture. • Hardens Windows sandbox provisioning against reparse points. • Surfaces interactive requests in realtime conversations. • Requires approval for commands with dynamic shell words. • Adds managed gates for in-app chat and dictation. Breaking changes: • The experimental thread config endpoint has been removed (`Remove the experimental thread config endpoint`). • Skill model delegation support has been removed.

OpenAI Codex CLI rust-v0.148.0-alpha.22

Tue, 18 Aug 2026 13:30:36 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.21

Mon, 17 Aug 2026 19:27:11 GMT

Codex CLI gains endpoint protection detection in `codex doctor`, improved network diagnostics, and working-directory TUI commands. • Improves `codex doctor` network diagnostics, including proxy environment details, macOS system proxy configuration detection, and rejection of proxy authentication challenges (HTTP 407). • Adds `CodexOptions.configOverrides` to the TypeScript SDK for passing ordered `--config key=value` arguments to Codex CLI unchanged, enabling TOML permission maps with literal path keys. • Adds working-directory commands to the TUI. • Supports per-environment shell variable policies and environment-specific command policies. • Adds experimental app-server project APIs. • Adds a configurable skill catalog token budget. • Compacts successful command activity in the TUI for a cleaner history view. • Enables editing queued messages with Vim history-up keybinding in the TUI composer. • Removes the workspace settings gate for apps and plugins.

OpenAI Codex CLI rust-v0.148.0-alpha.21

Mon, 17 Aug 2026 19:27:11 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.20

Sun, 16 Aug 2026 00:21:59 GMT

Codex CLI gains disk-space diagnostics in `codex doctor`, MCP tool handler hooks, and live hook refresh after plugin changes. • Adds storage diagnostics to `codex doctor`, reporting free space for both `CODEX_HOME` and the worktree with warning (5 GiB) and failure (1 GiB) thresholds; on Windows, also checks Dev Drive health. • Propagates W3C `traceparent` and `tracestate` trace context through exec-server relay frames, including fragmented encrypted Noise-protocol requests. • Supports pending environment attachment configuration so threads start immediately without blocking while attachment configuration is not yet available, with a new failed-attachment state that recovers on a ready update. • Uses paginated history for persistent exec threads to keep memory usage bounded across long sessions. • Shows resume and fork status indicators during TUI startup.

OpenAI Codex CLI rust-v0.148.0-alpha.20

Sun, 16 Aug 2026 00:21:59 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.18

Fri, 14 Aug 2026 21:58:41 GMT

Codex CLI alpha.18 enables unified exec on Windows by default, makes Guardian v2 risk classification configurable, and removes the gRPC code-mode session limit. • Makes `features.guardianv2` in config accept either a boolean toggle or a structured object specifying classifier instructions, review threshold, reasoning effort, action/instruction token limits, transcript source controls, per-entry and total token budgets, and the number of recent non-user entries. • Adds an override to skip project configuration at startup. • Enables `unified_exec` by default on Windows, exposing `exec_command` and `write_stdin` instead of `shell_command` on that platform. • Removes the gRPC code-mode open session limit, allowing more than `MAX_IN_FLIGHT_REQUESTS` concurrent sessions. • Adds MCP protocol discovery metrics: records a counter and duration per discovery attempt, tagged with `legacy` or `auto` mode and classified as `modern`, `legacy`, or `failure`. • Routes 'None of the above' selection in request input prompts to the notes editor on Enter (in addition to Tab), preventing accidental submission.

OpenAI Codex CLI rust-v0.148.0-alpha.18

Fri, 14 Aug 2026 21:58:41 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.16

Fri, 14 Aug 2026 17:18:40 GMT

Codex CLI alpha.16 adds Guardian V2 risk scoring, parallel tool calls for all models, and stricter MCP auto-review enforcement. • Enforces strict auto-review for MCP tool calls even when the approval policy, tool annotations, or a remembered session decision would otherwise skip review. • Adds Guardian V2 risk scoring: initializes per-thread samplers, records risk scores as snapshots on threads, preserves transcript boundaries in sampling input, and requires automatic review for high-risk actions. • Installs Guardian V2 in the app server and isolates Guardian reviewer sessions from parent extensions. • Reuses pending MCP server connections during reconciliation when identity, catalog limit, and protocol mode still match, avoiding duplicate startups. • Adds `agent_name` field to Responses API turn metadata, falling back to `/root` when no canonical agent path exists, and reserves the key from client metadata overrides. • Instructs the model to use `tool_search` to discover relevant tools when an explicitly selected plugin has apps available, before falling back to built-in tools. • Restricts filesystem helper sandbox access for tighter isolation. • Honors cloud-managed requirements in feature listings.

OpenAI Codex CLI rust-v0.148.0-alpha.16

Fri, 14 Aug 2026 17:18:40 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.15

Fri, 14 Aug 2026 03:00:20 GMT

Codex CLI adds an Amazon Bedrock Runtime provider and skill-level model annotations with Luna delegation support. • Adds the built-in `amazon-bedrock-runtime` provider for regional OpenAI-compatible Bedrock endpoints, with SigV4 auth, per-provider AWS profile/region/transport overrides, global and US cross-region model variants, and web search disabled. • Adds an optional `model` field to skill frontmatter (e.g. `model: luna`), enabling per-skill model annotations while silently ignoring unsupported values. • Adds `SkillModelDelegationInstruction` so skills requesting Luna can delegate to it when Luna is available in the current provider namespace, with bounded/validated model identifiers and instruction size limits.

OpenAI Codex CLI rust-v0.148.0-alpha.15

Fri, 14 Aug 2026 03:00:20 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.14

Fri, 14 Aug 2026 01:37:45 GMT

Codex CLI gains per-server MCP OAuth callback ports, running-task exit menu, and experimental thread queue APIs. • Adds `oauth.callback_port` to MCP server configuration, letting each server override the global `mcp_oauth_callback_port` for CLI login, app-server, plugin installation, executor, and skill dependency OAuth flows. • Adds experimental thread queue APIs to the app server. • Adds a running-task exit menu to local daemon sessions: pressing Ctrl-C with an empty composer while a task runs now offers choices to cancel and stay, exit while leaving the task running, or stop and exit. • Exposes model upgrade retirement times in the model context. • Preserves client-authored developer messages across context compaction when `retain_client_developer_messages` is enabled. • Provides Guardian V2 with full tool action context — conversation transcript and a structured planned-action object containing tool name and arguments — for more accurate risk classification. • Wraps injected current-time reminders in `` tags in model context. • Deduplicates current-time reminders when spawning full-history subagents, replacing inherited parent reminders with a single fresh reminder. • Adds structured telemetry for response retries. • Includes node_repl images in Guardian review evidence.

OpenAI Codex CLI rust-v0.148.0-alpha.14

Fri, 14 Aug 2026 01:37:45 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.12

Thu, 13 Aug 2026 06:43:33 GMT

Codex CLI alpha.12 adds interrupted turn recovery, unified network approval pipeline, and sandboxed inline visualization protection. • Adds `RecoverTurnRequest` and `CodexThread::recover_turn_if_idle` to resume an interrupted regular turn using its existing turn ID and updated thread settings, including Plan-mode recovery without injecting an empty user message. • Routes blocked network requests through the shared approval pipeline so permission hooks, automatic review, and user review all use the common approval flow — including for background terminals started by an earlier turn. • Materializes inline visualization viewer documents in a dedicated cache under `CODEX_HOME`, keyed by source and artifact thread IDs, so sandboxed sessions cannot overwrite viewer files before they are opened in a browser. • Persists deny amendments for blocked network requests and keeps denied requests denied across turns. • Records the final applied network decision in tool telemetry without exposing the destination or assigning an approval source. • Disables visualization links for full-disk-write sessions and rejects viewer cache paths containing symbolic links; reuses materialized viewer documents in memory when the source is unchanged.

OpenAI Codex CLI rust-v0.148.0-alpha.12

Thu, 13 Aug 2026 06:43:33 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.11

Thu, 13 Aug 2026 04:11:00 GMT

Codex CLI alpha.11 adds thread usage displays, `thread-credits` and `estimated-thread-cost` terminal title items, and improved MCP tool-call approval routing. • Adds `thread-credits` and `estimated-thread-cost` as configurable terminal title items, letting practitioners track per-thread quota consumption at a glance. • Shows estimated thread usage in the `/status` command and TUI status surfaces. • Adds dynamic HTTP header helpers for MCP servers. • Integrates workload identity with Codex authentication. • Supports gRPC code-mode hosts in the app server via `--code-mode-host`. • Enables executor skill packages to be passed directly to `skills.read` without a preceding `skills.list` lookup, including support for skill root aliases. • Enforces non-interactive approval policy for Codex delegate sessions. • Reconnects gRPC code-mode sessions automatically after host restarts. • Adds per-thread usage queries to the backend client. • Stamps conversation history items with creation times. • Adds durable reverts for paginated threads. • Adds manifest-defined metrics and bounded measurement analytics for trusted plugin scripts. • Attaches connector ID, action name, and model to file creation requests for hosted app tool calls.

OpenAI Codex CLI rust-v0.148.0-alpha.11

Thu, 13 Aug 2026 04:11:00 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.7

Tue, 11 Aug 2026 15:29:55 GMT

Codex CLI alpha.7 adds configurable goal token budget limits, session ID exposure to shell commands, and configurable Responses API request metadata. • Adds configurable goal token budget limits via PR #37878 (`Add configurable goal token budget limits`). • Exposes the session ID to shell commands, enabling scripts and tools to reference the current session context. • Adds configurable Responses API request metadata, allowing custom metadata to be attached to API requests. • Supports MCP form input in full-access user threads, expanding interactive MCP workflows. • Adds `packagedDefaults` as a new lowest-precedence configuration layer, with its source path reported through config diagnostics and the app-server protocol; returns an error when a configured packaged defaults file is missing. • Caches tool catalogs for streamable HTTP MCP servers, reducing repeated catalog fetches. • Speeds up MCP OAuth credential reads. • Exposes plugin ownership in MCP server status. • Honors per-directory bundled skill settings in `skills/list` requests. • Simplifies `skills.read` so that `package` is the only required argument, resolving the owning orchestrator or executor catalog automatically and defaulting omitted `resource` values to the package's main `SKILL.md`. • Adds the `codex.turn.unified_exec.running_processes` counter to track background terminal processes remaining at turn completion. • Validates images before returning `view_image` output. • Honors the configured Windows sandbox level for managed networking. • Runs plugin and skill tests on Windows, extending platform coverage. Breaking changes: • Config lockfile support has been removed (`Remove config lockfile support`).

OpenAI Codex CLI rust-v0.148.0-alpha.7

Tue, 11 Aug 2026 15:29:55 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.6.6

Mon, 10 Aug 2026 21:52:42 GMT

Codex CLI alpha.6.6 adds Amazon Bedrock web search, expanded MCP namespace descriptions, and Agent Plugin runtime isolation. • Raises the MCP namespace tool-spec description limit from 1,000 bytes to 512 KiB, truncating only at a UTF-8 character boundary, so complete server instructions are preserved in tool-search source metadata. • Enables cached web search for Amazon Bedrock: advertises hosted text web search while marking external live and indexed web access as unsupported, and resolves those modes to cached search (or disables the tool when cached search is prohibited by managed requirements). • Bounds model-visible skill instructions, plugin instructions, MCP descriptions, schemas, individual tools, and the aggregate Agent Plugin MCP tool set within plugin manifests. • Gives `externalAgentConfig/detect` its own global serialization queue so configuration reads, writes, and external agent imports remain responsive while detection is running. • Skips symbolic links (and other non-file, non-directory entries) when copying a plugin into the store, allowing plugin installation to proceed without failing on symlinked skill files or executables. • Bounds Cursor project path resolution to a set of 128 path candidates using common filename separators instead of walking the full directory tree, rejecting ambiguous matches and unsafe encoded components.

OpenAI Codex CLI rust-v0.147.0-alpha.6.6

Mon, 10 Aug 2026 21:52:42 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.6

Mon, 10 Aug 2026 10:17:08 GMT

Codex CLI adds paginated TUI history, dual-WebSocket code-mode transport, cached web search for Amazon Bedrock, and tool registry collision policies. • Adds `--psp` flag to `app-server` for process-scoped PSP routing of first-party ChatGPT requests. • Adds tool registry collision policy configuration (`#36954`) and enforces strict tool name collision errors. • Adds `includeTurns` reads for paginated threads to support incremental transcript access. • Adds a dual-WebSocket transport for code mode, enabling a new host-communication path. • Enables cached web search for Amazon Bedrock. • Enables remote compaction for Amazon Bedrock. • Adds paginated transcript history in the TUI, allowing large session histories to load incrementally. • Supports deferred loading for freeform tools and deferred custom tools in tool search. • Supports custom tools in namespaces. • Supports leaf models in multi-agent v2. • Adds opt-in concurrent exec-server request dispatch. • Adds durable per-thread user submission queues. • Adds host skill root loading and moves host skills service into the skills extension. • Prompts before trusting local project directories and rejects implicitly discovered bare Git repositories. • Adds Codex attribution links in pull request bodies. • Allows disabling the built-in image viewer. • Redacts secrets from app-server command execution items and improves bearer token secret redaction. • Negotiates MCP extensions per app-server session and handles late MCP startup results after lag timeout. • Preserves complete MCP namespace descriptions. • Identifies agents by name in token budget context and makes token budget context identity configurable. • Includes policy approval reasons in Guardian reviews.

OpenAI Codex CLI rust-v0.148.0-alpha.6

Mon, 10 Aug 2026 10:17:08 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.5

Sat, 08 Aug 2026 02:26:13 GMT

Codex CLI adds `migrate-rollouts` subcommand, Markdown conversation export, session forking in `codex exec`, and a Guardian circuit-breaker for cyber models. • Adds `migrate-rollouts` subcommand to inspect or migrate legacy local sessions to paginated thread history. • Adds Markdown conversation export to the TUI. • Adds session forking to `codex exec`. • Adds session archiving and restore to the resume picker. • Adds MCP event discovery and subscriptions. • Mounts a minimal `/dev` in full-filesystem Bubblewrap sandboxes. • Tracks context windows per agent. • Exposes multi-agent versions in `model/list`. • Exposes app-server diagnostics through the experimental API. • Adds process diagnostics snapshots. • Fetches remote installed plugins across all scopes. • Recovers MCP servers after OAuth reauthentication. • Starts cached MCP servers lazily for subagents. • Adds tool namespace metadata configuration. • Includes call IDs in MCP requests.

OpenAI Codex CLI rust-v0.148.0-alpha.5

Sat, 08 Aug 2026 02:26:13 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.4

Sat, 08 Aug 2026 00:43:56 GMT

Codex CLI alpha adds multi-agent version metadata in model/list, MCP event discovery, process diagnostics, and a shared project-instruction byte budget. • Adds nullable `multiAgentVersion` field to `v2` `model/list` responses, with supported values `disabled`, `v1`, or `v2`, exposing multi-agent capability metadata for each model. • Adds `codex-diagnostics` crate that snapshots process ID, resident-memory measurements, and registered process-wide gauges; tracks live `CodexThread` instances via the `core.threads.live` gauge. • Adds MCP event discovery and subscriptions, enabling clients to subscribe to server-side events over MCP. • Includes call IDs in MCP requests for end-to-end traceability. • Treats `project_doc_max_bytes` as a single shared byte budget across all selected environments, truncating at the limit and skipping later environments once exhausted, capping total project instruction payload size. • Exposes app-server and runtime activity diagnostics through the experimental API. • Includes sandbox mode in response metadata. • Keeps response streams alive through connection failures, improving resilience for long-running agent turns. • Disables Nagle's algorithm for code-mode WebSockets, reducing latency for interactive sessions. • Reports temporary directories in exec-server environment info. • Includes tool namespace inventory in turn metadata. • Generalizes skill locator aliases across providers and aliases resource-backed skill locators under context pressure.

OpenAI Codex CLI rust-v0.148.0-alpha.4

Sat, 08 Aug 2026 00:43:56 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.2

Fri, 07 Aug 2026 09:23:15 GMT

Codex CLI gains session forking, Markdown conversation export, session archiving, MCP tool hook config, and agent identity endpoint overrides. • Adds `fork` subcommand to `codex exec` that forks a previous session by UUID or thread name into a new session, with optional `--image`/`-i` flag for attachments and an optional prompt argument. • Adds `/export` TUI command to export the complete conversation history as structured Markdown, with clipboard and file destinations (including default filename prompt and support for an explicit path argument). • Supports `CODEX_AGENT_IDENTITY_AUTHAPI_BASE_URL` and `CODEX_AGENT_IDENTITY_JWKS_BASE_URL` environment variables to override agent identity registration and verification endpoints. • Adds session archiving to the resume picker, allowing sessions to be archived and restored from within the TUI. • Recognizes `mcp_tool` hook handler configurations (with server, tool, JSON input, and optional timeout and status message fields) and returns them from `configRequirements/read`. • Adds executor-local config layer loading for the exec server, enabling per-executor configuration overrides.

OpenAI Codex CLI rust-v0.148.0-alpha.2

Fri, 07 Aug 2026 09:23:15 GMT

OpenAI Codex CLI rust-v0.148.0-alpha.1

Fri, 07 Aug 2026 03:20:28 GMT

Codex CLI adds `migrate-rollouts` subcommand, Guardian circuit-breaker for cyber models, and a durable user-message queue. • Adds `migrate-rollouts` subcommand with `--apply`, `--thread `, `--max-mib-per-second `, `--json`, and `--verbose` flags to inspect or migrate legacy local sessions to paginated thread history. • Adds a Guardian circuit-breaker policy that interrupts model turns after the first Guardian denial for models whose catalog specialty is `cyber`, while retaining existing denial thresholds for all other models. • Mounts a minimal `/dev` inside full-filesystem Bubblewrap sandboxes. • Starts cached MCP servers lazily for subagents, and recovers MCP servers automatically after OAuth reauthentication. • Fetches remote installed plugins across all scopes and supports plugin roots in the host skill loader. • Sends model routing hints to the Codex backend to improve model selection.

OpenAI Codex CLI rust-v0.148.0-alpha.1

Fri, 07 Aug 2026 03:20:28 GMT

OpenAI Codex CLI rust-v0.147.0

Fri, 07 Aug 2026 01:41:49 GMT

Codex CLI v0.147.0 adds `--approve-for-me` auto-approval, portable Agent Plugins, MCP 2026-07-28 protocol support, and Bedrock cached web search. • Adds `--approve-for-me` CLI flag to enable automatically reviewed approvals without manual confirmation prompts. • Removes the deprecated `codex exec --full-auto` flag; `--sandbox workspace-write` is now the required replacement. • Supports the opt-in MCP 2026-07-28 protocol, including paginated discovery, multi-round requests, and non-blocking server startup. • Installs portable Agent Plugins and searches across local, personal, workspace, and remote plugin catalogs. • Enables cached web search and remote conversation compaction for Amazon Bedrock. • Organizes conversations into persistent, manually ordered sections with incremental browsing of long transcripts. • Imports Cursor-managed skills and synchronizes changes to imported Claude and Cursor conversations without creating duplicates. Breaking changes: • The `codex exec --full-auto` flag has been removed; use `--sandbox workspace-write` instead. • Redundant Linux bundle archives are no longer published; use the standard `codex-package-` release archives instead.

OpenAI Codex CLI rust-v0.147.0

Fri, 07 Aug 2026 01:41:49 GMT

Codex CLI v0.147.0 adds `--approve-for-me`, portable Agent Plugins, MCP 2026 protocol support, and Amazon Bedrock cached web search. • Adds `--approve-for-me` CLI flag to `codex` to enable automatically reviewed approvals without manual confirmation prompts. • Adds support for the opt-in MCP 2026-07-28 protocol, including paginated discovery, multi-round requests, and non-blocking server startup. • Replaces the removed `codex exec --full-auto` flag with `--sandbox workspace-write` as the supported equivalent. • Introduces installable portable Agent Plugins with search across local, personal, workspace, and remote plugin catalogs. • Enables cached web search and remote conversation compaction for Amazon Bedrock backends. • Adds persistent, manually ordered conversation sections and incremental browsing of long transcripts in the TUI. • Supports importing Cursor-managed skills and synchronizing changes to imported Claude and Cursor conversations without duplicates. • Standardizes Linux release artifacts to `codex-package-` archives, dropping the previously published redundant bundle archives. Breaking changes: • The `--full-auto` flag on `codex exec` has been removed; use `--sandbox workspace-write` instead. • Redundant Linux bundle archives are no longer published; use the standard `codex-package-` release archives.

OpenAI Codex CLI rust-v0.147.0-alpha.13

Thu, 06 Aug 2026 01:12:59 GMT

Codex CLI alpha adds thread section ordering, `thread/section/move` API, named forked chats, and MCP OAuth credential isolation. • Adds `--psp` flag to the app-server to enable process-only PSP routing for first-party ChatGPT requests. • Enables naming forked chats from the TUI. • Loads cloud-managed servers in MCP CLI commands. • Isolates MCP OAuth credentials by environment and restricts hosted MCP credentials to local environments. • Exposes MCP read-only hints in tool call items. • Distinguishes unknown MCP authentication status as a separate state. • Enables skills in the MCP server. • Supports Enterprise automation account plans. • Denies network access when an allow amendment fails, tightening sandbox enforcement. • Requires explicit sandbox permissions with shell justifications. • Restricts `shell_command` to a single local environment. • Detects connectors used in external agent sessions. • Records attempted tool calls in response metadata. Breaking changes: • Legacy `--full-auto` handling is removed from `codex exec`. • Legacy Linux bundle archives are no longer published.

OpenAI Codex CLI rust-v0.147.0-alpha.13

Thu, 06 Aug 2026 01:12:59 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.12

Wed, 05 Aug 2026 20:38:23 GMT

Adds disabled-by-default image resize notices, local auth requirement enforcement, and symlinked skill discovery path tracking. • Adds the disabled-by-default `image_resize_notice` feature: when enabled, appends a developer message after resized images reporting each image's original and prepared dimensions, for both user messages and tool outputs. • Adds local `requirements.toml` allowlists for login methods and ChatGPT workspaces, enforced before stored or environment-provided credentials are used — including during bootstrap before cloud requirements are fetched. • Makes Windows `PathUri` equality and hashing ASCII-case-insensitive for drive and UNC paths while preserving case-sensitive POSIX behavior, including `starts_with` and `relative_path_from` comparisons.

OpenAI Codex CLI rust-v0.147.0-alpha.12

Wed, 05 Aug 2026 20:38:23 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.6.5

Wed, 05 Aug 2026 19:45:48 GMT

Codex CLI alpha.6.5 adds Amazon Bedrock cached web search, tightened Agent Plugin runtime boundaries, and fuller MCP namespace descriptions. • Raises the MCP namespace tool-spec description limit from 1,000 bytes to 512 KiB, truncating only at a UTF-8 character boundary, so complete server instructions are preserved in tool-search metadata. • Enables cached web search for Amazon Bedrock: advertises hosted web search while marking external live/indexed access unsupported, and resolves unsupported modes to cached search or disables the tool when managed requirements prohibit it. • Skips symbolic links and other non-file, non-directory entries when installing a plugin into the store, allowing installations that include symlinked skill files or executables to succeed.

OpenAI Codex CLI rust-v0.147.0-alpha.6.5

Wed, 05 Aug 2026 19:45:48 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.11

Wed, 05 Aug 2026 17:03:09 GMT

Codex CLI alpha.11 adds per-session code-mode execution limits and switches API-key Guardian reviews to gpt-5.6-luna. • Adds `create_session_with_limits` and session-scoped cell execution limits via `CodeModeSessionCellExecutionLimits`, clamping execute and wait yield times to `max_yield_time_ms` without terminating the running cell; limits are negotiated with remote code-mode hosts and included in `session/open` only when non-default. • Switches Guardian approval reviews for API-key authenticated sessions to the `gpt-5.6-luna` model (retaining `codex-auto-review` for ChatGPT authentication), routing API-key reviews through Responses Lite with fallback to the bundled Guardian policy. • Caches `McpBinding` per published MCP runtime once the tool catalog revision is stable, reusing the binding across sampling steps and rebuilding only after a runtime publish or catalog change. • Bounds interactive TUI telemetry shutdown to a 500 ms budget via `OtelProvider::shutdown_with_timeout`, preventing a stalled OTLP exporter from blocking exit indefinitely.

OpenAI Codex CLI rust-v0.147.0-alpha.11

Wed, 05 Aug 2026 17:03:09 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.10

Wed, 05 Aug 2026 10:53:31 GMT

Codex CLI alpha adds concurrent exec-server dispatch, tool registry collision policy, paginated TUI history, and leaf model support for multi-agent v2. • Adds `--concurrent-requests` flag (alias `--concurrent-requests COUNT`, default `1`) to the exec-server subcommand for opt-in concurrent request dispatch across connections. • Adds `--psp` global flag to enable process-scoped PSP routing for first-party ChatGPT requests. • Adds tool registry collision policy configuration with strict tool name collision errors enforced under a new canonical `functions` namespace. • Adds paginated transcript history loading in the TUI, enabling navigation of long session histories. • Enables cached web search for Amazon Bedrock. • Enables remote compaction for Amazon Bedrock. • Prompts before trusting local project directories, and rejects implicitly discovered bare Git repositories. • Adds durable per-thread user submission queues. • Links Codex attribution in pull request bodies. • Allows disabling the built-in image viewer. • Skips symlinks when installing plugins. • Limits RMCP logs persisted to SQLite. • Negotiates MCP extensions per app-server session. • Makes token budget context identity configurable. • Supports configured ChatGPT cookies in HTTP clients. • Adds safer TUI defaults for cyber models. Breaking changes: • Legacy collaboration mode variants have been removed (`Remove legacy collaboration mode variants`).

OpenAI Codex CLI rust-v0.147.0-alpha.10

Wed, 05 Aug 2026 10:53:31 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.6.4

Tue, 04 Aug 2026 21:02:39 GMT

Codex CLI now enables cached web search for Amazon Bedrock, falling back from unsupported live/indexed modes automatically. • Adds hosted web search support for Amazon Bedrock, advertising cached web search while marking external live and indexed web access as unsupported — unsupported modes resolve to cached search, or the tool is disabled when cached search is prohibited by managed requirements. • Normalizes built-in and configured Bedrock model catalogs to text-only web search payloads, removing the `search_content_types` field that Bedrock rejects for multimodal search. • Retains the runtime provider in session configuration so per-turn setup can apply provider-specific capabilities (e.g. text-only search for Bedrock).

OpenAI Codex CLI rust-v0.147.0-alpha.6.4

Tue, 04 Aug 2026 21:02:39 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.6.3

Tue, 04 Aug 2026 19:36:48 GMT

Codex CLI raises MCP namespace tool-spec description limit from 1,000 bytes to 512 KiB, preserving complete server instructions. • Raises the MCP namespace tool-spec description limit from 1,000 bytes to 512 KiB, truncating only at a UTF-8 character boundary when the new limit is exceeded — preserving complete server instructions and preventing tools from being hidden. • Keeps complete MCP namespace descriptions in tool-search source metadata.

OpenAI Codex CLI rust-v0.147.0-alpha.6.3

Tue, 04 Aug 2026 19:36:48 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.7

Tue, 04 Aug 2026 11:50:52 GMT

Codex CLI alpha.7 adds dual-WebSocket transport for code mode, MCP conformance regression gates, and per-environment login shell policy. • Adds `exec resume --last` performance improvement by querying the state database first, avoiding a full rollout scan; falls back to scanning only on a complete database miss. • Supports per-environment `allow_login_shell` policy, exposing the `login` argument for shell tools when any selected environment permits login shells and validating each command against its own environment's policy. • Adds a dual-WebSocket transport for code mode, routing frames to the appropriate transport lane via transport_lane(). • Adds MCP client conformance regression gates covering HTTP and stdio transports, OAuth scenarios, shipping/intermediate/modern protocol versions, and an app-server regression matrix for transport, security, schema, pagination, SSE, multi-round, and catalog-boundary behavior. • Adds `codex-utils-audio` workspace crate for canonicalizing audio inputs and estimating token usage. • Supports deferred loading for freeform tools and custom tools in namespaces. • Adds timeout handling for stalled code-mode host requests. • Identifies agents by name in token budget context. • Prefers SQLite-backed names when resolving local `archive`, `delete`, and `unarchive` session targets before falling back to rollout scanning.

OpenAI Codex CLI rust-v0.147.0-alpha.7

Tue, 04 Aug 2026 11:50:52 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.2

Thu, 30 Jul 2026 01:04:28 GMT

Codex CLI adds MCP 2026 protocol support, cloud-managed sandbox profiles, non-blocking MCP startup, and concurrent tool resolution. • Adds MCP 2026-07-28 discovery support and completes full MCP 2026 client support. • Loads cloud-managed profiles for `codex sandbox`, enabling centrally provisioned sandbox configurations. • Routes MCP OAuth through configured HTTP clients, unifying network proxy handling for MCP authentication flows. • Adds configurable developer instructions for v2 subagents. • Supports model-owned token budget defaults, applying model-catalog-supplied budgets when no explicit token-budget configuration is set. • Routes WebRTC sideband joins to the Realtime API. • Adds persisted thread sections for organizing conversation threads. • Enables network policy callbacks for remote exec. • Terminates Windows non-TTY processes on interrupt, improving Ctrl-C behavior on Windows. • Loads thread titles concurrently during session startup. • Supports self-serve Business ProLite accounts. • Supports plaintext collaboration tool messages. • Honors the configured SQLite home in the logs client.

OpenAI Codex CLI rust-v0.147.0-alpha.2

Thu, 30 Jul 2026 01:04:28 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.9.1

Wed, 29 Jul 2026 22:56:59 GMT

Codex CLI adds managed in-app updates so the tool can keep itself current without manual reinstallation. • Adds managed in-app updates, allowing Codex CLI to update itself automatically from within the application.

OpenAI Codex CLI rust-v0.146.0-alpha.9.1

Wed, 29 Jul 2026 22:56:59 GMT

OpenAI Codex CLI rust-v0.147.0-alpha.1

Wed, 29 Jul 2026 09:13:56 GMT

Codex CLI adds `features.code_mode_host` table config, MCP 2026 support, cloud-managed sandbox profiles, and exec-server network policy callbacks. • Adds MCP 2026-07-28 discovery support and completes the full MCP 2026 client specification. • Raises the MCP server recursion limit to unblock deeper tool-call chains. • Exposes cached MCP tools before the MCP server finishes starting up, reducing turn latency at session start. • Routes MCP OAuth flows through the configured HTTP clients, ensuring proxy and routing settings apply to all authentication requests. • Adds persisted sections for organizing threads in the TUI. • Adds configurable developer instructions for v2 subagents. • Supports model-owned token budget defaults. • Routes curated plugins by authentication mode. • Supports self-serve Business ProLite accounts. • Scales skill metadata budgets with context windows. • Adds bounded metadata for executed tool calls. • Adds managed policy support for in-app updates. • Terminates Windows non-TTY processes on interrupt, improving Ctrl-C behavior in non-interactive pipelines. • Raises the Windows exec yield floor to 10 seconds for more reliable subprocess scheduling.

OpenAI Codex CLI rust-v0.147.0-alpha.1

Wed, 29 Jul 2026 09:13:56 GMT

OpenAI Codex CLI rust-v0.146.0

Wed, 29 Jul 2026 01:42:51 GMT

Codex CLI gains session naming, thread pinning, fork history, Agent Plugins with Bedrock/Claude marketplaces, WebSocket Code Mode, and standalone web search. • Enables naming new sessions directly from the `/new` or `/clear` commands and pinning important threads for persistent access. • Supports Agent Plugins manifests, workspace plugin publishing, and additional plugin marketplaces for Amazon Bedrock and Claude Code. • Adds thread forking with paginated history, including temporary forks that do not appear in thread listings. • Connects app-server to remote Code Mode hosts over WebSocket. • Enables standalone web search for compatible custom model providers. • Discovers executor-provided skills and securely reads their associated resources, including explicitly selected skills. • Adds enterprise-plan recognition and administrator controls for in-app updates.

OpenAI Codex CLI rust-v0.146.0

Wed, 29 Jul 2026 01:42:51 GMT

Codex CLI v0.146.0 adds named sessions, thread pinning, thread forking, WebSocket Code Mode, web search for custom providers, and Agent Plugin marketplace support. • Enables standalone web search for compatible custom model providers via the `allow custom providers to opt into standalone web search` capability (PR #34846). • Supports `CODEX_INSTALLER_USE_RELEASES_OPENAI_COM` environment variable to control whether the installer pulls from `https://releases.openai.com/codex` or falls back to GitHub Releases. • Name new sessions using `/new` or `/clear` slash commands inside the TUI. • Pin important threads and switch between side conversations without closing them. • Fork threads with paginated history, including temporary forks that do not appear in thread listings. • Connects app-server to remote Code Mode hosts over WebSocket. • Adds support for Agent Plugins manifests, workspace plugin publishing, and additional plugin marketplaces for Amazon Bedrock and Claude Code. • Discovers executor-provided skills and securely reads their associated resources, including explicitly selected skills. • Adds enterprise-plan recognition and administrator controls for in-app updates.

OpenAI Codex CLI rust-v0.146.0-alpha.10

Sat, 25 Jul 2026 02:18:34 GMT

Codex CLI alpha adds configurable code-mode host fallback, hardened network approval concurrency, and richer Responses Lite metadata. • Adds `disable_in_process_fallback` key inside a `features.code_mode_host` configuration table, letting operators suppress the embedded-V8 fallback so that a failed standalone host surfaces as tool output instead of silently falling back. • Preserves backward compatibility: `features.code_mode_host` still accepts a plain boolean toggle in addition to the new table form. • Adds `code_mode_tool_names` field to Responses Lite turn metadata, mapping each normalized code-mode identifier to its structured `ToolName` (omitted from external MCP server metadata and non-Lite requests). • Scopes pending network approvals to a turn and execution, coalesces duplicate requests within one execution, and cancels in-flight Guardian reviews when their owner is dropped — eliminating races between concurrent allow/deny decisions.

OpenAI Codex CLI rust-v0.146.0-alpha.10

Sat, 25 Jul 2026 02:18:34 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.8

Fri, 24 Jul 2026 23:23:37 GMT

Codex CLI alpha adds ent26 enterprise plan support, MCP OAuth proxy routing, ephemeral thread forks, and workspace plugin publish capability. • Adds `canPublishToWorkspace` nullable metadata to plugin share contexts and `plugin/share/save` responses, letting clients surface workspace-directory publishing only when the capability is available. • Supports `excludeTurns: true` in `thread/fork` to create ephemeral forks from paginated thread history without creating a rollout path or exposing the fork via `thread/list`. • Routes MCP OAuth discovery and authentication status through each server's runtime HTTP client so MCP servers behind configured proxies are reliably discovered; caps local discovery at five seconds while preserving explicit login timeouts. • Adds recognition of the `ent26` enterprise plan across authentication, account protocol, backend rate-limit payloads, and app-server schemas, treating it as an enterprise workspace plan for cloud-config eligibility and usage-limit guidance.

OpenAI Codex CLI rust-v0.146.0-alpha.8

Fri, 24 Jul 2026 23:23:37 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.7

Fri, 24 Jul 2026 18:24:41 GMT

Codex CLI gains Agent Plugins manifest support, MCP runtime prewarming, and background MCP refresh coordination. • Supports Agent Plugins 1.0 schema: recognizes root `plugin.json` files and maps their portable metadata, `skills/`, and `mcp.json` into Codex plugin manifests, with `.codex-plugin/plugin.json` as a fallback overlay. • Adds `WaitForEnvironmentToolConfig` as thread extension data, letting hosts override the model-visible `wait_for_environment` tool and `environment_id` descriptions. • Adds background MCP runtime prewarming — a per-session worker eagerly rebuilds dirty MCP state after configuration, authentication, or explicit refresh changes, coalescing queued refreshes. • Refreshes MCP runtimes automatically when session auth changes (auth mode, account details, or token), and rebuilds the initial MCP projection if authentication changes during session startup. • Adds explicit `RefreshMcpServers` behavior that forces reconnection to every configured MCP server rather than reusing existing connections. • Refreshes MCP runtimes across thread startup and independently across active threads when managed MCP requirements change. • Supports paginated thread forks. • Exposes executor skills through skill tools and enables resource reads for explicit executor skills. • Preserves output from hooks that exit before reading stdin (fast-exiting hooks no longer lose stdout when stdin is not consumed).

OpenAI Codex CLI rust-v0.146.0-alpha.7

Fri, 24 Jul 2026 18:24:41 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.6

Fri, 24 Jul 2026 05:31:18 GMT

Codex CLI alpha.6 adds remote code-mode host support via `--code-mode-host`, skill catalog context warnings, and nonblocking TUI turn interrupts. • Adds `--code-mode-host` flag to `codex-app-server`, accepting a `wss://` WebSocket URL to connect the app server to a remote code-mode host (invalid schemes such as `http://` or bare `ws://` are rejected at parse time). • Adds WebSocket transport to the code-mode host, enabling remote code-mode host connections through the app server. • Exposes Browser Use requirements and remote skill icon URLs through the app server for downstream consumers. • Attributes command executions to trusted plugin scripts, with attribution preserved across command approvals. • Routes exec-server HTTP and WebSocket traffic through the configured proxy policy. • Preserves refreshed Apps tools across MCP runtime updates and keeps side conversations open when switching threads. • Enforces writer ownership for thread archive and deletion operations. • Supports incremental replay of updated thread items. • Honors the configured SQLite home directory consistently across all state consumers, including startup backfill, thread listing, and paginated history.

OpenAI Codex CLI rust-v0.146.0-alpha.6

Fri, 24 Jul 2026 05:31:18 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.3.1

Thu, 23 Jul 2026 23:26:55 GMT

Codex CLI adds `supports_standalone_web_search` setting so custom model providers can opt into the standalone `web.run` tool. • Adds `supports_standalone_web_search` model-provider setting (defaults to `false`) that lets custom Responses API providers opt into the standalone `web.run` web-search tool when web search is enabled. • Routes standalone web search requests through the custom provider's own endpoint and authentication when `supports_standalone_web_search` is enabled.

OpenAI Codex CLI rust-v0.146.0-alpha.3.1

Thu, 23 Jul 2026 23:26:55 GMT

OpenAI Codex CLI rust-v0.146.0-alpha.5

Thu, 23 Jul 2026 20:02:57 GMT

Codex CLI alpha.5 adds thread pinning, MCP tool prefix control, custom provider web search, and MCP connection reuse. • Adds `isPinned` field to thread responses and allows `thread/metadata/update` to pin or unpin stored threads. • Adds `isPinned` filter to `thread/list`, supporting cursor-based pagination and combinations with relationship filters. • Allows omitting MCP tool prefixes per server, reducing namespace clutter in multi-server setups. • Allows custom providers to opt into standalone web search. • Allows disabling the multi-agent wait tool. • Sets a default user agent for MCP HTTP requests. • Reuses MCP connections across runtime refreshes and replaces closed MCP connections during reconciliation, reducing reconnect overhead. • Caches remote plugin catalogs by scope for faster plugin resolution. • Tracks `compaction_ms` in turn profile facts and analytics events as a dedicated profile phase. • Preserves user input in conversation history when MCP startup is interrupted mid-turn. • Infers the bundled Claude Code plugin marketplace automatically. • Uses the API plugin marketplace for Amazon Bedrock. • Preserves timestamps when importing external agent sessions. • Standalone installers now prefer `releases.openai.com` by default and fall back to GitHub Releases; set `CODEX_INSTALLER_USE_RELEASES_OPENAI_COM=false` to force GitHub Releases.

OpenAI Codex CLI rust-v0.146.0-alpha.5

Thu, 23 Jul 2026 20:02:57 GMT

OpenAI Codex CLI rust-v0.145.0-alpha.30

Wed, 22 Jul 2026 01:18:32 GMT

Codex CLI alpha.30 adds Esc-key session interruption and parallel stdin writes across unified-exec sessions. • Adds Esc key as an interrupt mechanism to cancel a running agent task mid-session, now documented in the status indicator. • Runs `write_stdin` in parallel across unified-exec sessions, improving throughput when multiple shell sessions are active. • Updates bundled GPT-5.6 model variants with 272,000-token context windows and adds personality instruction variables. • Adds GPT-5.5 availability notice to the bundled model catalog. Breaking changes: • The `auto_review` and `permissions` message fields and the legacy `supports_reasoning_summary_parameter` flag are removed from the bundled model catalog.

OpenAI Codex CLI rust-v0.145.0-alpha.30

Wed, 22 Jul 2026 01:18:32 GMT

OpenAI Codex CLI rust-v0.145.0

Tue, 21 Jul 2026 18:21:04 GMT

Codex CLI gains paginated thread history, Amazon Bedrock support, audio I/O, multi-agent V2 stability, and expanded /import migration. • Adds `GPT-5.6 Sol` as the default Amazon Bedrock model, with experimental managed Bedrock login, custom endpoint, and custom authentication support. • Expands `/import` to migrate settings, MCP servers, plugins, sessions, commands, and project-scoped memories from Cursor and Claude Code. • Adds experimental paginated thread history with efficient resume, search, persisted names, sub-agent support, and memories backed by a dedicated SQLite store. • Adds audio inputs and tool outputs supporting common local audio formats, and introduces streaming realtime V3 conversations. • Adds secure, clickable inline visualization links in the terminal UI.

OpenAI Codex CLI rust-v0.145.0

Tue, 21 Jul 2026 18:21:04 GMT

Codex CLI v0.145.0 adds paginated thread history, Bedrock login, audio inputs, stabilized multi-agent V2, and expanded /import migration. • Adds experimental Amazon Bedrock login with managed authentication support, custom endpoint configuration, and GPT-5.6 Sol as the default Bedrock model. • Expands `/import` to migrate Cursor and Claude Code settings, MCP servers, plugins, sessions, commands, and project-scoped memories. • Adds experimental paginated thread history with efficient resume, search, persisted names, sub-agent support, and memories. • Adds audio inputs and tool outputs supporting common local audio formats, and introduces streaming realtime V3 conversations. • Adds secure, clickable inline visualization links rendered directly in the terminal UI.

OpenAI Codex CLI rust-v0.145.0-alpha.29

Tue, 21 Jul 2026 11:49:09 GMT

Codex CLI adds route-aware HTTP client pooling, system proxy support across all subsystems, and configurable external session detection limits. • Adds `maxSessionAgeDays` and `maxSessions` fields to the external-agent config detection request, making session discovery limits configurable (defaults remain 30-day max age and 50 sessions). • Adds `CARGO_HTTP_CAINFO` to the curated custom CA environment variables so Cargo inherits the managed MITM trust bundle in proxy environments. • Adds an optional opaque `providerId` field to `externalAgentConfig/import` for analytics attribution of external agent imports, independently of the `migrationSource` selector. • Introduces a route-aware HTTP client pool (`RouteAwareClientPool`) that resolves the outbound proxy route per request URL, with a bounded cache of 16 routes — enabling correct PAC and system-proxy handling across redirects. • Extends system proxy settings to cover the daemon updater, remote plugins, plugin startup sync, and cloud environment discovery. • Preserves thread settings for goal-first and forked threads on restart, so resumed threads use the configuration active when they were created rather than current config. • Adds an optional `releases.openai.com` installer source, with `CODEX_INSTALLER_USE_RELEASES_OPENAI_COM` controlling fallback to GitHub Releases. • Mirrors Rust release artifacts and metadata to Cloudflare R2 as an additional distribution channel. • Supports alpha hotfix release versions in the version scheme (mapping Python `aN.postM` to `-alpha.N.M` tags) across installers, npm publishing, and release validation.

OpenAI Codex CLI rust-v0.145.0-alpha.29

Tue, 21 Jul 2026 11:49:09 GMT

OpenAI Codex CLI rust-v0.145.0-alpha.28

Tue, 21 Jul 2026 03:01:52 GMT

Codex CLI alpha.28 adds concurrent terminal stdin, Amazon Bedrock custom transports, audio I/O, and incremental Markdown streaming. • Supports custom transports for Amazon Bedrock, enabling non-default network or proxy configurations when connecting to Bedrock-backed models. • Adds an app-server API for reading installed app runtime state. • Adds audio input and output support: audio variants in user input protocols, audio inputs forwarded to the Responses API, audio output in dynamic tools and code mode, and audio history gated by model input modalities. • Adds `SessionEnd` hooks for thread teardown, enabling cleanup logic when a session ends. • Adds batched executor capability discovery. • Adds occurrence search for paginated threads. • Renders inline visualization links in the TUI. • Renders streamed Markdown incrementally in the TUI, reducing layout work and redundant redraws while streaming. • Allows users to remember the working directory for resumed sessions. • Allows publishing plugins through share updates. • Allows selecting path-backed agents in the TUI agent picker. • Confirms usage-limit resets before redemption, preventing accidental redemption. • Suppresses empty multi-agent mode messages in the TUI. • Reports detailed session import error types. • Tracks collaboration mode instructions and permission instructions in world state. • Centralizes thread MCP connections in `McpRuntime`. • Supports ChatGPT-branded Desktop app builds. • Adds bounded batch lookups and batched persistent history reads for message history, improving reverse-search performance. • Launches managed network proxies on remote executors. • Makes parent-owned sub-agent threads read-only in the TUI. • Exposes plugin installation interstitial requirements. • Records web search result payload sizes. • Seeds realtime V3 sessions with initial text items and streams realtime V3 Codex handoff output.

OpenAI Codex CLI rust-v0.145.0-alpha.28

Tue, 21 Jul 2026 03:01:52 GMT

OpenAI Codex CLI rust-v0.145.0-alpha.27

Tue, 21 Jul 2026 01:59:04 GMT

Codex CLI alpha.27 lets Esc interrupt a running session and updates bundled model metadata for GPT-5.6 and GPT-5.5. • Allows pressing Esc to interrupt the current agent session while a task is running, with Esc now documented as an interrupt key in the status indicator. • Updates bundled GPT-5.6 model variant context windows to 272,000 tokens and refreshes model instructions, message configuration, and reasoning-summary support across the model catalog. • Adds personality instruction variables for GPT-5.6 model variants and adds a GPT-5.5 availability notice to the bundled catalog. • Runs `write_stdin` in parallel across unified-exec sessions, improving throughput for multi-session workloads. Breaking changes: • The `auto_review` and `permissions` message fields and the legacy `supports_reasoning_summary_parameter` flag are removed from the bundled model catalog.

OpenAI Codex CLI rust-v0.145.0-alpha.27

Tue, 21 Jul 2026 01:59:04 GMT

OpenAI Codex CLI rust-v0.144.0

Thu, 09 Jul 2026 16:47:12 GMT

Codex CLI adds a `writes` approval mode, interactive MCP auth by default, and Ultra concurrency warnings in v0.144.0. • Adds a `writes` app-approval mode that allows declared read-only actions without prompting while still requiring approval for write operations. • Enables MCP tool interactive authentication by default — no experimental opt-in required. • Usage-limit reset credits now display their type and expiration date, with an interactive picker to choose which credit to redeem. • App-server hosts can now supply Codex authentication at runtime and redirect users to a hosted page after successful login. • Selecting Ultra reasoning now triggers a warning when high multi-agent concurrency is configured, alerting users to potential rapid usage increases.

OpenAI Codex CLI rust-v0.143.0

Wed, 08 Jul 2026 01:31:10 GMT

Codex CLI gains system proxy routing, Amazon Bedrock new models, MCP session auth, and a remote-control pairing command. • Enables remote plugins by default, with richer catalog rows, npm marketplace sources, and visible remote/local version info. • Routes authentication and Responses API traffic through macOS and Windows system proxies, including PAC and WPAD configurations. • Adds `codex remote-control pair` subcommand for generating manual pairing codes from a running daemon. • Adds Amazon Bedrock GPT-5.6 Sol, Terra, and Luna models with first-class support for `max` reasoning effort. • Enables MCP tool search by default; ChatGPT-hosted MCP servers can now explicitly use session authentication. • App-server clients can inspect environments, list descendant threads, and fork history through a specific turn.

OpenAI Codex CLI rust-v0.142.2

Thu, 25 Jun 2026 07:32:07 GMT

Codex CLI gains default MCP tool search, macOS system proxy support, and dark-mode plugin logos. • Enables tool search for MCP tools by default when the model/provider supports it, improving tool discovery while staying compatible with older models. • Adds macOS system proxy, PAC, and WPAD resolution when `respect_system_proxy` is enabled, letting the CLI route through corporate proxies automatically. • Supports dark-mode logos for plugins via local manifests and remote catalogs. • Surfaces richer safety-buffering UI using server-provided visibility and faster-model metadata.

OpenAI Codex CLI rust-v0.142.1

Thu, 25 Jun 2026 00:36:09 GMT

OpenAI Codex CLI adds opt-in Windows system proxy support including PAC, WPAD, static proxies, and bypass rules. • Adds opt-in Windows system proxy support for authentication, covering PAC, WPAD, static proxies, and bypass rules.

OpenAI Codex CLI rust-v0.142.0

Mon, 22 Jun 2026 22:19:53 GMT

Codex CLI gains indexed web search, rollout token budgets, multi-agent delegation controls, plugin sections, and scheduled time reminders. • Adds `/usage` command support for viewing and redeeming earned usage-limit reset credits, with confirmation, retry, and refreshed availability states. • Organizes `/plugins` remote plugins into OpenAI Curated, Workspace, and Shared with me sections; eligible turns can now recommend and install relevant plugins. • Introduces configurable rollout token budgets that track usage across agent threads, surface remaining-budget reminders, and abort turns when the budget is exhausted. • Enables app-server clients to configure multi-agent delegation as disabled, explicit-request-only, or proactive at both the thread and turn level. • Adds an indexed web-search mode that allows live searches while restricting direct page access to server-approved URLs. • Supports scheduled UTC time reminders and direct current-time queries, including through client-provided app-server clocks.

OpenAI Codex CLI rust-v0.141.0

Thu, 18 Jun 2026 04:43:06 GMT

Codex CLI gains Noise-encrypted remote execution, per-thread MCP servers, auto-resolving TUI prompts, and richer app-server APIs. • Adds authenticated, end-to-end encrypted Noise relay channels for remote executors. • Cross-platform remote execution now preserves executor-native working directories and shells, including filesystem permission paths across app-server and exec-server boundaries. • Selected executor plugins can activate their stdio MCP servers per thread; plugin discovery adds a created-by-me marketplace and auth-specific curated catalogs. • App-server clients can list immediate child threads, correlate external-agent import results, and read or redeem rate-limit reset credits. • Realtime clients can explicitly append speech, control how Codex responses enter conversations, and omit startup context.

OpenAI Codex CLI rust-v0.140.0

Mon, 15 Jun 2026 21:06:37 GMT

Codex CLI v0.140.0 adds usage dashboards, session deletion, Claude Code import, @-mentions menu, and managed Bedrock auth. • Adds `/usage` command with daily, weekly, and cumulative account token activity views. • Adds `codex delete`, `/delete`, and app-server `thread/delete` for permanent session deletion with confirmation safeguards and subagent cleanup. • Adds `/import` for selectively importing setup, project configuration, and recent chats from Claude Code. • Typing `@` now opens a unified mentions menu for files, plugins, and skills by default. • Adds managed Amazon Bedrock API-key authentication with encrypted local storage for CLI and MCP OAuth credentials. • Preserves oversized text, large pasted blocks, and image attachments in `/goal`, including in remote app-server sessions.

OpenAI Codex CLI rust-v0.139.0

Tue, 09 Jun 2026 20:13:29 GMT

Codex CLI adds standalone web search in code mode, richer MCP schema support, and improved plugin marketplace JSON output. • Enables standalone web search in code mode, including from nested JavaScript tool calls, returning plaintext results. • Tool and connector input schemas now preserve `oneOf` and `allOf`, and large schemas retain more shallow structure when compacted for better MCP tool compatibility. • `codex doctor` now includes editor and pager environment details in the local report, with raw values redacted in JSON output. • `codex plugin marketplace list --json` now includes each marketplace source per entry. • Plugin lists can now return from the cached remote catalog before refreshing in the background, improving responsiveness. • Adds `-P` as a sandbox permissions profile alias flag. • Shows effective sandbox modes in `/debug-config`.

OpenAI Codex CLI rust-v0.138.0

Mon, 08 Jun 2026 23:00:27 GMT

Codex CLI gains Desktop handoff, richer plugin JSON output, image path exposure, PAT v2 auth, and flexible reasoning effort selection. • Adds `/app` command to hand off the current CLI thread into Codex Desktop on macOS and native Windows, with Windows workspace launches opening directly into Desktop. • Exposes saved file paths for local image attachments and standalone image generations to the model, enabling more reliable follow-up edits and file references. • Adds fallback keyboard shortcuts in the TUI for reasoning effort selection on terminals missing `Alt` bindings, and supports model-defined effort levels in model-advertised order. • App-server integrations can now read account token usage via the API. • Adds support for v2 personal access tokens in CLI and app-server authentication flows. • Adds `--json` output to plugin add/remove and marketplace commands; plugin list JSON now includes marketplace source; plugin detail data exposes default prompts, remote MCP servers, and unavailable app templates.

OpenAI Codex CLI rust-v0.137.0

Thu, 04 Jun 2026 01:17:20 GMT

Codex CLI gains F13-F24 keybindings, `codex plugin list --json`, remote-control pairing RPCs, and multi-agent v2 per-thread runtimes. • Adds F13-F24 function key support in TUI keymaps for extended keyboard bindings. • Enables paste in searchable selection menus within the TUI. • Adds a compact reasoning-only status/title item to the TUI status surface. • Adds `codex plugin list --json` for machine-readable plugin inventory output. • Caches remote plugin catalog suggestions for faster plugin discovery. • Adds remote-control pairing start and client management RPCs (list/revoke controller grants) via app-server v2. • Shows enterprise monthly credit limits in the status display for admin/enterprise flows. • Supports applying cloud-managed config bundles, including EDU workspace accounts. • Enables parallel standalone web search calls in code-mode flows. • Exposes standalone image generation and hosted web/image tools in code-only mode. • Multi-agent v2 keeps runtime choice per-thread and exposes cleaner follow-up and metadata defaults for spawned agents. • Adds skills extension scaffold with per-turn catalog resolution and v1 prompt injection. • Keys request-permission grants by environment identity for scoped approvals. • Exports readable CA bundles to child commands when managed MITM proxying is active. Breaking changes: • The `persist_extended_history` bool flag is removed from app-server (the experimental flag no longer exists). • The multi-agent v2 `assign_task` field is renamed to `followup_task`. • `hide_spawn_agent_metadata` now defaults to `true`, changing the default metadata visibility for spawned agents.

OpenAI Codex CLI rust-v0.136.0

Mon, 01 Jun 2026 17:49:22 GMT

Codex CLI v0.136.0 adds session archiving, OSC 8 clickable links, stdio app-server mode, Windows sandbox provisioning, and a standalone image generation extension. • Adds `/archive` slash command in the TUI and `codex archive` / `codex unarchive` CLI commands to protect sessions from accidental resume or fork until restored. • TUI markdown now renders clickable web links via OSC 8 metadata, and cramped tables automatically reformat as readable key/value records while preserving link targets. • Launches app-server in stdio mode with `codex app-server --stdio` for easier process-level integrations. • Supports `CODEX_API_KEY` registration for approved OpenAI hosts in remote execution setup; remote-control websockets now use short-lived server tokens instead of ChatGPT access tokens. • Adds alpha `codex sandbox setup --elevated` provisioning path for Windows admins, plus constrained requirements support for allowed Windows sandbox implementations. • Adds a feature-gated standalone image generation extension that runs through the native Codex image artifact completion pipeline. • Exposes richer MCP server status information in app-server integrations. • Adds focused diagnostics for MCP HTTP send failures. • Adds `experimental_request_user_input` toggle in config.

OpenAI Codex CLI rust-v0.135.0

Thu, 28 May 2026 17:31:35 GMT

Codex CLI gains richer `doctor` diagnostics, Vim text-object editing, named permission profiles, and non-interactive install support. • Adds richer environment, Git, terminal, app-server, and thread inventory diagnostics to `codex doctor` for support cases. • New `/status` command shows remote connection details and server version when connected over a remote transport. • Vim mode gains text-object editing, improved word/line-end behavior, and a configurable turn-interruption keybind. • Adds named permission profile picker to `/permissions`, which now displays configured custom profiles. • Packaged Codex builds can discover and use the bundled patched zsh helper on supported macOS and Linux targets. • Supports non-interactive installation mode via `install.sh`/`install.ps1` when `CODEX_NON_INTERACTIVE=1` is set.

OpenAI Codex CLI rust-v0.134.0

Tue, 26 May 2026 19:13:26 GMT

Codex CLI gains conversation history search, concurrent read-only MCP tools, OAuth for MCP servers, and richer extension/hook context. • Adds search across local conversation history with case-insensitive content matching and result previews. • Makes `--profile` the primary profile selector across CLI, TUI permissions, and sandbox flows; legacy profile configs now rejected with migration guidance. • Supports per-server environment targeting and OAuth options for streamable HTTP MCP servers via `codex mcp add`. • Enables concurrent execution of read-only MCP tools that advertise `readOnlyHint`. • Preserves local `$ref`/`$defs` structures and compacts oversized schemas for more reliable connector tool schemas. • Exposes conversation history to extension tools and adds subagent identity to hook inputs for richer extension and hook context. Breaking changes: • Legacy profile v1 config selectors are now rejected; `--profile` is the required flag and legacy profile configs must be migrated.

OpenAI Codex CLI rust-v0.133.0

Thu, 21 May 2026 16:48:03 GMT

Codex CLI gains always-on goal tracking, improved remote-control UX, richer extension lifecycle hooks, and smarter plugin discovery. • Enables Goals by default with dedicated storage and cross-turn progress tracking. • Permission profiles gain a list API, inheritance resolution, managed `requirements.toml` support, runtime refresh, and deeper Windows sandbox integration. • Plugin list output is now tabulated and marketplace-aware, showing installed versions, visible marketplace roots, and remote collection support. • Extensions can now observe SubagentStart/SubagentStop lifecycle hooks, tool execution events, turn-start metadata, and async approval/turn processing. • Adds a `/btw` alias for the side slash command. • Adds `turn_id` and `truncation_policy` fields to extension tool calls. • Adds a standalone web-search API client. • Adds MITM hook config model and wires MITM hooks into runtime enforcement with named permissions config. • Adds `thread/settings/update` app-server API for syncing TUI thread settings. • Exposes a `--version` flag on `codex-app-server`.

OpenAI Codex CLI rust-v0.132.0

Wed, 20 May 2026 01:52:52 GMT

Codex CLI gains `--output-schema` for resumed execs, faster TUI startup, and auth-backed remote executor registration. • Adds `--output-schema` flag to `codex exec resume`, enabling resumed automations to enforce structured JSON output while preserving session context. • Enables remote executor registration via standard Codex auth, eliminating the need for a separate registry credential flow. • Optimizes TUI startup by batching terminal capability probes, reducing time to first interactive frame. • Supports preserving requested image fidelity — including original-resolution local images — across user inputs and image-producing tools in app-server turns.

OpenAI Codex CLI rust-v0.131.0

Mon, 18 May 2026 17:39:34 GMT

Codex CLI v0.131.0 adds `codex doctor`, unified `@` mention picker, remote daemon control, marketplace plugin commands, and a richer TUI. • Adds `codex doctor` command for support-ready diagnostics covering runtime, auth, terminal, network, config, and local state. • Unified `@` mention picker now searches files, directories, plugins, and skills in a single interface backed by app-server plugin metadata. • Remote workflows gain `codex remote-control` daemon management, runtime enable/disable APIs, status reads, and registry-backed remote environments. • Plugin system adds marketplace CLI commands, version-aware sharing, share checkout, shared-workspace buckets, and default-enabled plugin hooks. • TUI gains data-driven service-tier slash commands, blended token usage display, permissions/approval mode visibility, effective workspace roots, and responsive Markdown tables. • Python SDK renamed to `openai-codex` / `openai_codex`, with pinned runtime-generated types, concurrent turn routing by ID, and approval modes. • Adds Windows deny-read sandbox parity matching existing macOS/Linux sandbox behavior. • Adds Windows hook command overrides for customizing hook behavior per-platform. • Supports `PreToolUse` `updatedInput` rewrites, allowing hooks to modify tool inputs before execution. • Supports multi-environment `apply_patch` selection for applying patches across multiple configured environments. • TUI keymap config now accepts `minus` as a key binding value. • Adds ambient terminal pets to the TUI. • Exec-server now uses protobuf relay frames for transport.

OpenAI Codex CLI rust-v0.130.0

Fri, 08 May 2026 23:09:55 GMT

Codex CLI gains `codex remote-control`, AWS Bedrock console-login auth, thread pagination, and plugin sharing controls. • Adds `codex remote-control` as a top-level command for starting a headless, remotely controllable app-server. • Bedrock auth now supports AWS console-login credentials from `aws login` profiles, enabling SSO-based access. • App-server clients can page large threads with unloaded, summary, or full turn item views via new thread pagination APIs. • Plugin details now display bundled hooks, and plugin sharing exposes link metadata plus discoverability controls.

OpenAI Codex CLI rust-v0.129.0

Thu, 07 May 2026 17:02:13 GMT

Codex CLI v0.129.0 adds Vim composer mode, /hooks browser, /ide context injection, workspace-aware /diff, and a /keymap debug inspector. • Adds modal Vim editing in the TUI composer via `/vim` command, configurable default mode, and Vim-specific keymap contexts. • Adds `/hooks` browser for browsing and toggling lifecycle hooks, with support for pre/post-compaction hooks and `PreToolUse` context. • Adds `/ide` context injection so TUI workflows can pull in IDE-side context directly. • Adds workspace-aware `/diff` command for comparing workspace state within TUI sessions. • Adds `/keymap debug` inspector to inspect and diagnose terminal key events. • Adds PR summary and branch-change summaries to the status line, with theme-aware colors. • Adds redesigned resume/fork picker with raw scrollback mode for easier workflow resumption and copying. • Adds plugin marketplace upgrade flow (`/plugins` upgrade) and marketplace removal support. • Adds workspace plugin sharing, share access controls, source filtering, local share path tracking, and admin-disabled status handling for plugins. • Adds remote plugin bundle sync and refresh on auth changes. • Experimental goals now stay paused across thread resumes unless the user opts back in, with clearer validation and multi-day duration display. • Enforces `animations = false` setting for screen readers in the TUI. • Retires `/approvals` and renames `/autoreview` to `/approve`. • Adds Codex Apps auth and eligible MCP elicitations surfaced through TUI/Guardian flows. • Linux releases now bundle and verify a standalone `bwrap` fallback for npm and DotSlash installs. Breaking changes: • The `/autoreview` command is renamed to `/approve`; any scripts or muscle memory invoking `/autoreview` will no longer work.

OpenAI Codex CLI rust-v0.128.0

Thu, 30 Apr 2026 16:40:28 GMT

Codex CLI gains persisted /goal workflows, codex update, configurable keymaps, plugin marketplace, and richer MultiAgentV2 controls. • Adds persisted `/goal` workflows with app-server APIs, model tools, runtime continuation, and TUI controls for create, pause, resume, and clear. • Adds `codex update` command for in-place CLI self-update. • Adds configurable TUI keymaps, plan-mode nudges, and action-required terminal titles. • Enables `/statusline` and `/title` slash commands during active turns. • Expands permission profiles with built-in defaults, sandbox CLI profile selection, cwd controls, and active-profile metadata for clients. • Adds plugin marketplace installation, remote bundle caching, remote uninstall, plugin-bundled hooks, hook enablement state, and external-agent config import. • Adds external agent session import, including background imports and imported-session title handling. • Makes MultiAgentV2 configuration more explicit with thread caps, wait-time controls, root/subagent context hints, and v2-specific depth handling. Breaking changes: • `--full-auto` is deprecated; users must migrate to explicit permission profiles and trust flows. • GNU Linux binaries are no longer published as release artifacts.

OpenAI Codex CLI rust-v0.125.0

Fri, 24 Apr 2026 18:00:38 GMT

Codex CLI v0.125.0 adds Unix socket transport, remote plugin installs, reasoning-token reporting, and sticky environments for app-server workflows. • Adds Unix socket transport for app-server integrations alongside existing transports. • Adds `excludeTurns` parameter to `thread/resume` and `thread/fork` endpoints for pagination-friendly session management. • Adds remote thread config/store plumbing and a remote thread config endpoint to app-server. • Adds sticky environment API and thread state to app-server integrations. • Enables remote plugin install writes and marketplace upgrade via a new `app-server` marketplace upgrade RPC. • Permission profiles now round-trip across TUI sessions, user turns, MCP sandbox state, shell escalation, and app-server APIs. • Model providers now own model discovery; AWS/Bedrock account state is exposed to app clients via `account/read`. • `codex exec --json` now surfaces reasoning-token usage in its JSON output. • Rollout tracing now records tool, code-mode, session, and multi-agent relationships, with a debug trace reduction command for inspection. • App-server persists device key bindings in SQLite.

OpenAI Codex CLI rust-v0.124.0

Thu, 23 Apr 2026 18:29:40 GMT

Codex CLI v0.124.0 adds Amazon Bedrock support, stable hooks, quick TUI reasoning controls, and remote plugin marketplace access. • Adds `Alt+,` / `Alt+.` keyboard shortcuts in the TUI to lower or raise reasoning level on the fly; model upgrades now reset reasoning to the new model's default. • Adds first-class Amazon Bedrock support for OpenAI-compatible providers, including AWS SigV4 signing and AWS credential-based authentication. • Hooks are now stable: configurable inline in `config.toml` and `requirements.toml`, and can observe MCP tools, `apply_patch` edits, and long-running Bash sessions. • App-server sessions can now manage multiple environments and select an environment and working directory per turn, enabling precise multi-workspace and remote targeting. • Remote plugin marketplaces can now be listed and read directly, with larger result pages and more reliable detail lookups. • Eligible ChatGPT plans now default to the Fast service tier unless explicitly opted out.

OpenAI Codex CLI rust-v0.123.0

Thu, 23 Apr 2026 01:26:06 GMT

Codex CLI gains native Amazon Bedrock support, verbose MCP diagnostics, and flexible .mcp.json plugin loading. • Adds built-in `amazon-bedrock` model provider with configurable AWS profile support. • Adds `/mcp verbose` subcommand for full MCP server diagnostics, resources, and resource templates without slowing down plain `/mcp`. • Supports both `mcpServers` and top-level server maps in `.mcp.json` for plugin MCP loading. • Improves realtime handoffs so background agents receive transcript deltas and can explicitly stay silent. • Adds `remote_sandbox_config` requirements for host-specific remote environment configuration. • Refreshes bundled model metadata, including `gpt-5.4` as the current default.

OpenAI Codex CLI rust-v0.122.0

Mon, 20 Apr 2026 18:38:40 GMT

Codex CLI v0.122.0 adds side conversations, Plan Mode context control, plugin tabbed browsing, and deny-read glob sandbox policies. • New `/side` command in the TUI opens a side conversation for quick questions without interrupting the main session. • Queued input now accepts slash commands and `!` shell prompts while work is already running. • Plan Mode can start implementation in a fresh context, with context-usage displayed before deciding whether to carry the planning thread forward. • Plugin workflows gain tabbed browsing, inline enable/disable toggles, marketplace removal, and support for remote, cross-repo, or local marketplace sources. • Filesystem permissions support new deny-read glob policies, managed deny-read requirements, and platform sandbox enforcement. • `codex exec` runs can now be isolated to ignore user config or rules. • Tool discovery (ToolSearch) and image generation are now enabled by default. • Image handling adds higher-detail support and original-detail metadata for MCP and `js_repl` image outputs. • Image resizing updated to fit within 2048-square bounds. • New `codex app` command correctly opens or installs the Desktop app on Windows and Intel Macs. • Standalone installs are now more self-contained. • New `thread/turns/list` API and sorting/backwards-cursor support added to `thread/list`. • Default reasoning effort is now shown in `/status`. • Adds MCP server environment config support. • Adds piped stdin support in the exec process API. • Remote compaction now supported for Azure responses providers. • Adds server-level approval defaults for custom MCP servers.

OpenAI Codex CLI rust-v0.121.0

Wed, 15 Apr 2026 20:45:18 GMT

Codex CLI gains plugin marketplace install, Ctrl+R history search, memory controls, expanded MCP support, and secure devcontainer/bubblewrap sandboxing. • Adds `codex marketplace add` command to install plugin marketplaces from GitHub, git URLs, local directories, and direct `marketplace.json` URLs. • Adds `Ctrl+R` reverse search in the TUI composer for prompt history, plus local recall for accepted slash commands. • Adds TUI and app-server controls for memory mode, memory reset/deletion, and memory-extension cleanup, including a dedicated endpoint to delete memories. • Expands MCP/plugin support with MCP Apps tool calls, namespaced MCP tool registration, `supports_parallel_tool_calls` opt-in flag, and sandbox-state metadata sent through MCP tool metadata. • Adds realtime and app-server APIs for output modality, transcript completion events, and raw turn item injection. • Adds symlink-aware filesystem metadata flag to `fs` API. • Adds a secure devcontainer profile with bubblewrap sandboxing support. • Adds Unix socket allowlists for the macOS sandbox. • Adds context percentage indicator to the TUI status line. • Adds WebSocket capability token-hash support in the app-server. • Exposes instruction sources (AGENTS.md) via the app server. • Adds a CLI update announcement notification.

OpenAI Codex CLI rust-v0.120.0

Sat, 11 Apr 2026 02:53:49 GMT

Codex CLI v0.120.0 adds Realtime V2 background agent streaming, improved hook TUI, MCP outputSchema support, and richer SessionStart context. • Streams Realtime V2 background agent progress live while work is still running, and queues follow-up responses until the active response completes. • Improves TUI hook activity display: live running hooks shown separately, completed hook output retained only when useful. • Adds thread title as a variable available in custom TUI status line configurations. • Includes MCP `outputSchema` details in Code-mode tool declarations so structured tool results carry precise typing. • Enables SessionStart hooks to distinguish sessions created by `/clear` from fresh startup or resume sessions.

OpenAI Codex CLI rust-v0.119.0

Fri, 10 Apr 2026 22:44:21 GMT

Codex CLI v0.119.0 adds voice v2 WebRTC, `codex exec-server`, `Ctrl+O` copy, `/resume` by ID, and richer MCP server support. • Realtime voice sessions now default to the v2 WebRTC path with configurable transport, voice selection, and native TUI media support. • New experimental `codex exec-server` subcommand for remote/app-server workflows. • Remote app-server sessions now support egress WebSocket transport and remote `--cd` forwarding. • Press `Ctrl+O` in the TUI to copy the latest agent response to the clipboard, with improved SSH and cross-platform clipboard behavior. • `/resume` can now jump directly to a session by ID or name from the TUI session picker. • TUI notifications are more configurable, adding Warp OSC 9 support and an opt-in mode for notifications even while the terminal is focused. • MCP Apps and custom MCP servers gain support for resource reads, tool-call metadata, custom-server tool search, server-driven elicitations, and file-parameter uploads. • Runtime remote-control enablement and sandbox-aware filesystem APIs added for app-server workflows. • Enables disabling prompt instruction blocks and environment context injection via config. • Fuzzy file search is now case-insensitive in the TUI. Breaking changes: • The `OPENAI_BASE_URL` config fallback has been removed.

OpenAI Codex CLI rust-v0.118.0

Tue, 31 Mar 2026 17:02:18 GMT

Codex CLI gains Windows proxy-only egress enforcement, piped stdin for `codex exec`, dynamic bearer tokens for custom model providers, and device-code ChatGPT login. • Enforces proxy-only networking on Windows sandboxes with OS-level egress rules, replacing environment-variable-only controls. • Adds ChatGPT device-code sign-in flow for app-server clients when browser-callback login is unavailable. • Supports prompt-plus-stdin piping in `codex exec`, letting you pipe input while passing a separate prompt on the command line. • Enables custom model providers to fetch and refresh short-lived bearer tokens dynamically instead of relying on static config or environment credentials.

OpenAI Codex CLI rust-v0.117.0

Thu, 26 Mar 2026 22:27:39 GMT

Codex CLI gains first-class plugin management, path-based multi-agent addressing, and richer app-server capabilities in v0.117.0. • Adds first-class plugin workflow: Codex syncs product-scoped plugins at startup, lets you browse them via `/plugins`, and install or remove them with auth/setup handling built in. • Introduces path-based sub-agent addressing (e.g. `/root/agent_a`) with structured inter-agent messaging and agent listing for multi-agent v2 workflows. • Adds `/title` terminal-title picker to both the classic TUI and the app-server TUI, making parallel sessions easier to distinguish. • App-server clients can now send `!` shell commands, watch filesystem changes, and connect to remote WebSocket servers with bearer-token authentication. • Enables prompt history recall in the app-server TUI, persisting across sessions. • `view_image` now returns image URLs for code mode, generated images are reopenable from the TUI, and image-generation history survives session resume. Breaking changes: • The legacy artifact tool has been removed, and the old `read_file` and `grep_files` handlers have been retired — any workflow relying on these tool surfaces will break on upgrade. • The app-server-backed TUI is now enabled by default, and plugin/app rollout flags have been flipped on in normal builds — setups that depended on the previous defaults may behave differently.

OpenAI Codex CLI rust-v0.116.0

Thu, 19 Mar 2026 17:51:35 GMT

Codex CLI gains ChatGPT device-code sign-in, a userpromptsubmit hook, smarter plugin management, and richer realtime sessions. • Adds device-code ChatGPT sign-in during onboarding and token refresh support in the app-server TUI. • New `userpromptsubmit` hook lets users block or augment prompts before execution and before they enter history. • Plugin setup now prompts to install missing plugins/connectors, honors a configured suggestion allowlist, and syncs install/uninstall state remotely. • Realtime sessions start with recent thread context and are less likely to self-interrupt during audio playback.

OpenAI Codex CLI rust-v0.115.0

Mon, 16 Mar 2026 19:37:37 GMT

Codex CLI gains full-resolution image inspection, realtime transcription, filesystem RPCs, Smart Approvals guardian routing, and a new Python app-server SDK. • Adds full-resolution image inspection: models can now opt into `detail: "original"` via `view_image` and codex.emitImage(..., detail: "original") for precision visual tasks. • Exposes `codex.cwd` and `codex.homeDir` inside `js_repl`, and persists codex.tool(...) / codex.emitImage(...) references across cells. • Adds a dedicated transcription mode for realtime WebSocket sessions, plus v2 handoff support via the `codex` tool, with a unified `[realtime]` session config block. • New v2 app-server filesystem RPCs cover file reads, writes, copies, directory operations, and path watching. • New Python SDK for integrating with the v2 app-server filesystem API. • Smart Approvals can now route review requests through a guardian subagent in core, app-server, and TUI, reusing the same guardian session across follow-up approvals. • App integrations now use the Responses API tool-search flow, can suggest missing tools (`tool_suggest`), and fall back gracefully when the active model lacks search support. • Adds `openai_base_url` config override for the built-in provider. • The multi-agent wait tool is now consistently named `wait_agent`, aligning with `spawn_agent` and `send_input`. Breaking changes: • The multi-agent wait tool is renamed to `wait_agent`; any configuration or prompts referencing the old name will break.

OpenAI Codex CLI rust-v0.114.0

Wed, 11 Mar 2026 00:28:42 GMT

Codex CLI gains experimental code mode, a hooks engine with SessionStart/Stop events, health endpoints, and skill-disabling config. • Adds experimental code mode for more isolated coding workflows. • Adds experimental hooks engine with `SessionStart` and `Stop` hook events. • Adds `GET /readyz` and `GET /healthz` health-check endpoints to WebSocket app-server deployments. • Adds a config switch to disable bundled system skills entirely. • Handoffs now carry realtime transcript context for improved continuity across turns. • Improves the `$` mention picker with category labels (Skills, Apps, Plugins) and plugins surfaced first.

OpenAI Codex CLI rust-v0.113.0

Tue, 10 Mar 2026 05:24:30 GMT

Codex CLI gains runtime permission requests, a plugin marketplace, full web search config, and split sandbox policies. • Adds built-in `request_permissions` tool so a running turn can request additional permissions at runtime, with new TUI rendering for those approval prompts. • Introduces a curated plugin marketplace with `plugin/list` metadata discovery, install-time auth checks, and a `plugin/uninstall` endpoint. • Upgrades app-server command execution with streaming stdin/stdout/stderr and TTY/PTY support; wires `exec` to the new in-process app-server path. • Expands web search tool configuration beyond on/off to support full options such as filters and location. • Adds a new permission-profile config language and splits filesystem/network sandbox policies for more precise per-policy control. • Image generation now saves output files into the current working directory automatically.

OpenAI Codex CLI rust-v0.112.0

Sun, 08 Mar 2026 20:44:14 GMT

Codex CLI gains @plugin mentions in chat, a refreshed model picker, and safer per-turn sandbox privilege merging. • Adds `@plugin` mentions so users can reference plugins directly in chat and auto-include their associated MCP/app/skill context. • Updates the model-selection surface so the latest model catalog changes are surfaced in the TUI picker flow. • Merges executable permission profiles into per-turn sandbox policy for zsh-fork skill execution, enabling safer additive privilege handling for tool runs.

OpenAI Codex CLI rust-v0.111.0

Thu, 05 Mar 2026 19:12:13 GMT

Codex CLI rust-v0.111.0 enables Fast mode by default, adds local ESM imports in js_repl, and exposes MCP elicitation as structured flows. • Enables Fast mode by default for all sessions; TUI session header now displays whether the session is running in Fast or Standard mode. • Adds dynamic import of local `.js` and `.mjs` files in `js_repl`, allowing workspace scripts to be reused directly from the REPL. • Codex now reports enabled plugins (MCPs, apps, skills) to the model at session start, improving discovery of installed integrations. • App-server v2 exposes MCP elicitation as a structured request/response flow instead of raw events, simplifying client integrations. • Expands image workflow support for clients with client-side handling of image-generation events and model metadata for image-capable web search.

OpenAI Codex CLI rust-v0.110.0

Thu, 05 Mar 2026 02:22:46 GMT

Codex CLI gains a plugin system, multi-agent TUI upgrades, a /fast toggle, workspace-scoped memories, and a Windows installer. • Adds a plugin system that loads skills, MCP entries, and app connectors from config or a local marketplace, with an install endpoint for enabling plugins from the app server. • Expands TUI multi-agent flow with approval prompts, `/agent`-based enablement, ordinal nicknames, role-labeled handoff context, and clearer prompts. • Adds a persisted `/fast` toggle in the TUI plus app-server support for `fast` and `flex` service tiers. • Improves memories with workspace-scoped writes, renamed memory settings, and guardrails against saving stale or polluted facts. • Adds a direct Windows installer script to published release artifacts.

OpenAI Codex CLI rust-v0.107.0

Mon, 02 Mar 2026 18:00:16 GMT

Codex CLI gains thread forking for sub-agents, configurable memories, multimodal custom tools, and richer voice device controls. • Adds thread forking into sub-agents, letting you branch work from the current conversation without losing context. • Enables microphone and speaker device selection for realtime voice sessions, with persistent device preferences and improved transcription-aligned audio format. • Supports multimodal output (including images and structured content) from custom tools, beyond plain text. • Introduces configurable memories and a new `codex debug clear-memories` command to fully reset saved memory state. • Exposes richer model availability and plan-upgrade metadata in the app server, surfacing plan-gated models with tooltips in the TUI. • Adds an `ephemeral` field to the `Thread` object in the app-server API.

OpenAI Codex CLI rust-v0.106.0

Thu, 26 Feb 2026 23:11:50 GMT

Codex CLI gains a direct install script, js_repl promotion, user-input in Default mode, and smarter memory management. • Adds a direct install script for macOS and Linux, published as a GitHub release asset alongside the `codex` and `rg` binaries. • Promotes `js_repl` to `/experimental` with startup compatibility checks, user-visible warnings for incompatible Node versions, and a lowered minimum Node requirement of `22.22.0`. • Enables `request_user_input` in Default collaboration mode, not only in Plan mode. • Makes the `5.3-codex` model visible in the CLI model list for API users. • Introduces diff-based memory forgetting and usage-aware memory selection for improved long-session memory behavior. • Expands the app-server v2 thread API with experimental thread-scoped realtime endpoints/notifications and a `thread/unsubscribe` flow to unload live threads without archiving them. • Adds structured OTEL audit logging for embedded `codex-network-proxy` policy decisions and blocks. • Reduces sub-agent startup overhead by skipping expensive history metadata scans during subagent spawns.

OpenAI Codex CLI rust-v0.105.0

Wed, 25 Feb 2026 17:21:45 GMT

Codex CLI v0.105.0 adds syntax-highlighted diffs, voice dictation, multi-agent fan-out from CSV, new TUI commands, and granular approval controls. • Adds syntax highlighting for fenced code blocks and diffs in the TUI, plus a `/theme` picker with live preview and theme-aware diff colors for light and dark terminals. • Enables voice dictation in the TUI: hold spacebar to record and transcribe a prompt directly (enable with `features.voice_transcription = true` in config). • New `spawn_agents_on_csv` capability fans out multi-agent work from a CSV file with built-in progress and ETA tracking. • Sub-agents now support nicknames, a cleaner picker UI, and visible child-thread approval prompts for easier multi-agent tracking. • New `/copy` TUI command copies the latest complete assistant reply to the clipboard. • New `/clear` command and `Ctrl-L` shortcut clear the screen without losing thread context; `/clear` can also start a fresh chat. • Codex can now request extra sandbox permissions for a command mid-session, and specific approval prompt types can be auto-rejected without disabling approvals entirely. • App-server `thread/list` now supports searching threads by title. • Thread status is now exposed in `thread/read` and `thread/list` responses and in notifications. • App-server `thread/resume` returns the latest turn inline, reducing data loss on reconnects. • Adds configurable MCP OAuth callback URL for MCP server login. • Adds `allow_login_shell` config option. • Implements proxy-only egress for the Linux sandbox via a TCP-UDS-TCP bridge. • Node module resolution paths can now be specified for `js_repl`. • Adds configurable agent spawn depth. • Adds configurable `write_stdin` timeout. • Adds network proxy config wiring via `permissions.network` proxy config. • Adds JSON tracing logs for the app-server. • Adds ability to attach extra files to feedback submissions. • Profile-level `model_catalog_json` override is now supported.

OpenAI Codex CLI rust-v0.104.0

Wed, 18 Feb 2026 07:12:45 GMT

Codex CLI gains WebSocket proxy support, thread archive notifications, and distinct command approval IDs. • Supports `WS_PROXY`/`WSS_PROXY` environment variables (and lowercase variants) for proxying WebSocket connections through the network proxy. • App-server v2 now emits notifications when threads are archived or unarchived, so clients can react to state changes without polling. • Core and protocol layers now carry distinct approval IDs per command approval, enabling multiple approvals within a single shell command execution flow.

OpenAI Codex CLI rust-v0.103.0

Tue, 17 Feb 2026 23:02:52 GMT

Codex CLI gains richer app metadata in listings and a configurable prepare-commit-msg hook for co-author attribution. • App listing responses now include `app_metadata`, branding, and labels, enabling richer app cards without extra requests. • Commit co-author attribution now uses a Codex-managed `prepare-commit-msg` hook, with `command_attribution` config support to set a default label, a custom label, or disable attribution entirely.

OpenAI Codex CLI rust-v0.102.0

Tue, 17 Feb 2026 20:02:35 GMT

Codex CLI gains unified permissions flow, structured network approvals, multi-agent roles, and model reroute notifications. • Adds a unified permissions flow with clearer permissions history in the TUI and a new slash command to grant sandbox read access to blocked directories. • Introduces structured network approval handling with richer host/protocol context shown directly in approval prompts. • Adds customizable multi-agent roles configurable via the main config file. • Adds a `model/rerouted` notification so clients can detect and render model reroute events explicitly.

OpenAI Codex CLI rust-v0.100.0

Thu, 12 Feb 2026 18:29:57 GMT

Codex CLI gains a JS REPL runtime, memory slash commands, configurable sandbox read access, and multi-rate-limit support. • Adds experimental `js_repl` runtime that persists JavaScript state across tool calls, with optional runtime path overrides. • Adds `/m_update` and `/m_drop` TUI slash commands for in-session memory management. • Introduces `ReadOnlyAccess` policy shape for configurable sandbox read access on Linux and Windows. • Supports multiple simultaneous rate limits across the protocol, backend client, and TUI status surfaces. • Reintroduces app-server WebSocket transport with split inbound/outbound architecture and connection-aware thread resume subscriptions. • Enables Apps SDK apps in ChatGPT connector handling. • Promotes Linux bubblewrap sandbox and Windows Sandbox to Experimental capability level. Breaking changes: • The `disable_websockets` config key is renamed to `websockets_disabled`. • `CODEX_BWRAP_ENABLE_FFI` environment variable is removed; vendored bubblewrap is now always compiled on Linux.

OpenAI Codex CLI rust-v0.99.0

Wed, 11 Feb 2026 20:43:00 GMT

Codex CLI v0.99.0 adds concurrent shell execution, new TUI controls, app-server steering APIs, and GIF/WebP image support. • Enables concurrent shell command execution alongside active agent turns without interruption. • Adds `/statusline` command for interactively configuring which metadata appears in the TUI footer. • Adds sortable resume picker with toggle between creation time and last-updated time, with an in-picker mode indicator. • New app-server APIs for steering active turns (`turn/steer`), listing experimental features, resuming agents (`resume_agent`), and opting out of specific notifications. • Enterprise `requirements.toml` now supports restricting allowed web search modes (`allowed_web_search_modes`) and defining network constraints. • Image attachments now accept GIF and WebP formats in addition to previously supported types. • Adds shell environment and `rc` file snapshotting to bootstrap shell commands.

OpenAI Codex CLI rust-v0.98.0

Thu, 05 Feb 2026 17:00:36 GMT

Codex CLI v0.98.0 ships GPT-5.3-Codex support and promotes Steer mode to stable-on-by-default. • Adds GPT-5.3-Codex as a supported model. • Steer mode is now stable and enabled by default: `Enter` sends immediately during running tasks while `Tab` explicitly queues follow-up input. Breaking changes: • Steer mode is now enabled by default, changing keyboard behavior: `Enter` sends immediately during running tasks instead of queuing input, and `Tab` is now the explicit queue key — any workflow that relied on the previous `Enter`-to-queue behavior will behave differently without reconfiguration.

OpenAI Codex CLI rust-v0.97.0

Thu, 05 Feb 2026 05:11:10 GMT

Codex CLI v0.97.0 adds session-scoped tool auto-approval, live skill reloading, /debug-config, and configurable log_dir. • Adds session-scoped 'Allow and remember' approval for MCP/App tools, so repeated calls to the same tool are auto-approved without re-prompting during a session. • Adds live skill update detection so changes to skill files are picked up without restarting the CLI. • Supports mixed text and image content in dynamic tool outputs for app-server integrations. • New `/debug-config` slash command in the TUI lets you inspect the effective configuration at runtime. • Introduces initial memory plumbing (API client and local persistence) to support thread memory summaries. • Adds configurable `log_dir` to redirect logs, overridable via `-c` flag.

OpenAI Codex CLI rust-v0.96.0

Wed, 04 Feb 2026 18:23:37 GMT

Codex CLI v0.96.0 adds thread compaction API, WebSocket rate-limit signaling, and unified exec on all non-Windows platforms. • Adds `thread/compact` as an async trigger RPC in the v2 app-server API, letting clients start compaction immediately and track completion separately. • Adds a `codex.rate_limits` WebSocket event for rate-limit signaling, with WebSocket parity for ETag and reasoning metadata handling. • Enables `unified_exec` on all non-Windows platforms. • Constrained requirement values now include source provenance, enabling source-aware config debugging in UI flows such as `/debug-config`.

OpenAI Codex CLI rust-v0.95.0

Wed, 04 Feb 2026 04:54:32 GMT

Codex CLI adds macOS app launcher, personal skills, parallel shell tools, and CODEX_THREAD_ID injection. • Adds `codex app ` command on macOS to launch Codex Desktop from the CLI, auto-downloading the DMG if not present. • Supports personal skill loading from `~/.agents/skills` (with `~/.codex/skills` compatibility) and new app-server APIs/events to list and download public remote skills. • `/plan` now accepts inline prompt arguments and pasted images directly in the TUI, with improved slash-command editing and highlighting. • Shell-related tools can now execute in parallel, improving multi-command throughput. • Injects `CODEX_THREAD_ID` into the shell environment so scripts and skills can detect the active thread/session. • Adds vendored Bubblewrap with FFI wiring in the Linux sandbox as groundwork for upcoming runtime integration.

OpenAI Codex CLI rust-v0.94.0

Mon, 02 Feb 2026 18:27:37 GMT

Codex CLI v0.94.0 enables plan mode by default, stabilizes personality config, and adds skills loading from `.agents/skills`. • Plan mode is now enabled by default with updated interaction guidance in the plan prompt. • Personality configuration is now stable: default is `friendly`, configured via the `personality` config key, with automatic forward migration of existing settings. • Supports loading skills from `.agents/skills`, with explicit relative-path lookup instructions and nested-folder markers supported. • Console output now includes runtime metrics for easier diagnostics.

OpenAI Codex CLI rust-v0.93.0

Sat, 31 Jan 2026 06:59:51 GMT

Codex CLI gains SOCKS5 proxy support, streaming Plan mode TUI, SQLite log DB, connector browsing, and smart approvals by default. • Adds an optional SOCKS5 proxy listener with policy enforcement and config gating. • Plan mode now streams proposed plans into a dedicated TUI view, with a feature-gated `/plan` slash command for quick mode switching. • New `/apps` slash command lets users browse connectors in the TUI, plus `$` insertion for app prompts. • App-server supports external auth mode, accepting ChatGPT auth tokens from a host app and requesting refreshes when needed. • Smart approvals are now enabled by default, with explicit approval prompts for MCP tool calls. • Introduces a SQLite-backed log database with thread-ID filtering, 90-day log retention, and heuristic coloring via an improved logs client. • Adds `features enable`/`features disable` subcommands for toggling feature flags. • Adds `tui.notifications_method` config option. • Adds output display to the `/ps` command. • Live web search is now enabled for the `DangerFullAccess` sandbox policy.

OpenAI Codex CLI rust-v0.92.0

Tue, 27 Jan 2026 11:50:52 GMT

Codex CLI v0.92.0 adds dynamic tool injection, thread unarchive RPC, MCP OAuth scopes config, multi-agent explorer role, and cached web_search by default. • Enables dynamic tool injection at API v2 thread startup, routing tool calls and responses end-to-end through the server and core tool pipeline. • Adds `thread/unarchive` RPC to restore archived rollouts back into active sessions. • Supports defining OAuth scopes for MCP servers directly in `config.toml`, eliminating the need to pass `--scopes` on every login. • Expands multi-agent collaboration with an explorer role, improved collab event mapping, and max-depth guardrails to cap agent recursion. • Adds thread list filtering in the app server to simplify browsing large thread sets. • Makes cached `web_search` the default client-side behavior.

OpenAI Codex CLI rust-v0.90.0

Sun, 25 Jan 2026 16:37:37 GMT

Codex CLI gains a network sandbox proxy, connectors/MCP support, and a beta collaboration mode with ephemeral threads. • Adds a network sandbox proxy with policy enforcement to control outbound network access. • Introduces connectors support (phase 1) via an app server and MCP integration, with new config surface. • Ships collaboration mode as beta in the TUI, featuring a clearer plan → execute handoff and simplified Coding vs Plan mode selection. • Supports ephemeral threads and improved provenance metadata for spawned collaboration threads. • Adds proxy configuration support for WebSocket connections. • Enforces stricter limits on the number of concurrent multi-agents.

OpenAI Codex CLI rust-v0.89.0

Thu, 22 Jan 2026 21:35:51 GMT

Codex CLI gains /permissions command, per-skill toggle UI, smarter slash-command matching, and expanded app-server APIs. • Adds `/permissions` command as a shorter alias for the approval workflow (original `/approvals` kept for compatibility). • Adds `/skill` UI to enable or disable individual skills from within the TUI. • Improves slash-command selection by prioritizing exact and prefix matches over fuzzy matches. • App server supports new `thread/read` API and filtering of archived threads in `thread/list`. • App server clients support layered `config.toml` resolution; `config/read` can compute the effective config from a given working directory. • Release artifacts now include a stable URL for the published config schema.

OpenAI Codex CLI rust-v0.88.0

Wed, 21 Jan 2026 19:19:10 GMT

Codex CLI gains device-code auth, collaboration modes, /fork sessions, codex cloud list, and WebSocket proxy support. • Adds device-code auth as a standalone fallback for headless environments where browser-based login is unavailable. • Introduces collaboration modes (with presets and per-turn overrides) for multi-agent coordination. • New `codex cloud list` subcommand to list cloud resources from the CLI. • New `/fork` slash command to fork the current session instead of opening the session picker. • Shows forked-from session ID in `/status` output. • Supports enabling/disabling individual skills via config or API. • Adds `model_personality` config option to customize model behavior. • Renames `experimental_instructions_file` to `model_instructions_file` in config. • Adds `/experimental` menu in TUI2 for accessing experimental features. • Supports proxy configuration for WebSocket connections. • Auto-enables WebSocket transport when conditions are met. • New `max_threads` config option to cap concurrent thread count. • Returns threads sorted by `created_at` or `updated_at` via the app-server API. • Adds a request-user-input tool and overlay for interactive prompts during task execution. • Introduces forward navigation in backtrack preview within the TUI. • Closes all threads when `/new` is invoked. • Detaches non-TTY child processes for cleaner headless operation. • Displays raw shell command on user shell interactions. • Preserves slash command order in search results. Breaking changes: • The `experimental_instructions_file` config key is renamed to `model_instructions_file`; existing configs using the old key will need to be updated.

OpenAI Codex CLI rust-v0.87.0

Fri, 16 Jan 2026 15:37:42 GMT

Codex CLI v0.87.0 adds multi-ID collaboration waits, user-snapshot shell execution, and TUI approval surfacing for spawned threads. • Enables collaboration wait calls to block on multiple IDs in a single request, simplifying multi-thread coordination. • Runs user shell commands under the user snapshot so aliases and shell config are honored. • Surfaces approval requests from spawned/unsubscribed threads directly in the TUI. • Adds user message metadata (text elements and byte ranges) round-tripping through protocol, app-server, and core so UI annotations survive history rebuilds.

OpenAI Codex CLI rust-v0.86.0

Fri, 16 Jan 2026 01:18:52 GMT

Codex CLI adds SKILL.toml metadata support and explicit web search disable control. • Adds `SKILL.toml` support for defining skill metadata (names, descriptions, icons, brand color, default prompt) surfaced in the app server and TUI. • Enables clients to explicitly disable web search and signal eligibility via a header to align with server-side rollout controls.

OpenAI Codex CLI rust-v0.85.0

Thu, 15 Jan 2026 18:38:22 GMT

Codex CLI v0.85.0 adds real-time agent collaboration events, agent role presets, and interrupt-capable send_input. • App-server v2 now emits collaboration tool calls as item events in the turn stream, enabling clients to render agent coordination in real time. • New `spawn_agent` parameter accepts an agent role preset for richer agent control in collaboration tools. • New `send_input` interrupt capability lets callers optionally interrupt a running agent before delivering a message. • `/models` metadata now includes `migration_markdown` so clients can display richer upgrade guidance when suggesting model migrations.

OpenAI Codex CLI rust-v0.84.0

Thu, 15 Jan 2026 01:29:12 GMT

Codex CLI Rust v0.84.0 adds metadata on text elements for richer client rendering and schema evolution. • Adds additional metadata fields to text elements in the Rust protocol/types, enabling richer client rendering and future schema evolution.

OpenAI Codex CLI rust-v0.81.0

Wed, 14 Jan 2026 18:12:36 GMT

Codex CLI gains gpt-5.2-codex default, headless device-code login, Linux read-only mounts, and MCP threadId support. • Switches default API model to gpt-5.2-codex. • Adds `threadId` to `codex mcp-server` responses, enabling chained use with the `codex-reply` tool. • Enables automatic device-code login flow when a headless (no-browser) environment is detected. • Supports read-only bind mounts in the Linux sandbox to prevent writes to sensitive paths. • Renders partial (in-flight) tool calls in the TUI transcript overlay. • Adds `tui.alternate_screen` config key and `--no-alt-screen` CLI flag to control alternate-screen behaviour (e.g., for Zellij scrollback). • Publishes a generated JSON Schema for `config.toml` in `docs/` to enable config validation.

OpenAI Codex CLI rust-v0.80.0

Fri, 09 Jan 2026 19:48:15 GMT

Codex CLI gains session forking, sandbox elevation, skill invocations via v2 API, requirements exposure, and metrics observability. • Adds conversation/thread fork endpoints so clients can branch a session into a new thread. • Introduces the `/elevate-sandbox` command with onboarding prompts for upgrade/degraded sandbox mode. • Exposes `requirement/list` endpoint so clients can read `requirements.toml` and adapt agent-mode UX. • Supports explicit skill invocations through the v2 API `UserInput::Skill`. • Introduces metrics capabilities with additional counters for observability.

OpenAI Codex CLI rust-v0.79.0

Wed, 07 Jan 2026 00:56:03 GMT

Codex CLI gains multi-conversation agent control, thread rollback, cached web search, and an analytics config toggle. • Adds multi-conversation 'agent control' so a session can programmatically spawn or message other conversations. • Adds `thread/rollback` app-server API so IDE clients can undo the last N turns without rewriting history. • Adds `web_search_cached` flag to return cached-only Web Search results as a safer alternative to live requests. • Allows global exec flags (model, json, sandbox toggles, etc.) to be passed after `codex exec resume`. • Shows time/version-targeted announcement tips in the TUI, driven by a TOML file in the repo. • Adds `[analytics] enabled=...` config section to control analytics collection behavior.

OpenAI Codex CLI rust-v0.78.0

Tue, 06 Jan 2026 18:47:47 GMT

Codex CLI gains external-editor prompt editing, project-aware config layering, MDM support, and richer exec policy justifications. • Adds `Ctrl+G` to open the current prompt in your configured external editor (`$VISUAL`/`$EDITOR`) and sync edits back into the TUI. • Supports project-aware config layering: loads repo-local `.codex/config.toml`, honors configurable `project_root_markers`, and merges with system config like `/etc/codex/config.toml`. • Supports enterprise-managed configuration requirements on macOS via an MDM-provided TOML payload. • Exec policy rules can now include human-readable justifications via a `justification` arg to prefix_rule() in `*.rules` files, with policy loading following the unified config-layer stack. • Improves `tui2` transcript navigation with multi-click selection, a copy shortcut/affordance, and a draggable auto-hiding scrollbar. • Starts Windows PowerShell sessions in UTF-8 mode to reduce encoding-related prompt/output issues.

OpenAI Codex CLI rust-v0.77.0

Sun, 21 Dec 2025 05:37:01 GMT

Codex CLI v0.77.0 adds sandbox mode constraints, normalized TUI scrolling with config knobs, and flag-free MCP OAuth login. • Adds `allowed_sandbox_modes` field to `requirements.toml` to restrict which sandbox modes a project permits. • Adds `tui.scroll_*` config settings and normalizes mouse wheel and trackpad scrolling behavior across terminals in TUI2. • MCP OAuth login for streamable HTTP servers no longer requires the `rmcp_client` feature flag — works out of the box. • Improves fuzzy file search display consistency by centralizing file-name derivation in `codex-file-search`. • Updates bundled model metadata (`models.json`) with latest available models.

OpenAI Codex CLI rust-v0.76.0

Fri, 19 Dec 2025 18:55:54 GMT

Codex CLI gains /ps command, ExternalSandbox policy, model list UI, admin-scoped skills, and system-wide UNIX config support. • Adds `/ps` command to list running processes from within the TUI. • Introduces `ExternalSandbox` policy for delegating sandbox enforcement to an external process. • Supports system-wide `/etc/codex/requirements.toml` on UNIX for admin-managed dependency configuration. • Adds a model list UI for browsing and selecting available models interactively. • Enables skills by default (previously opt-in), with support for admin-scoped skills. • Supports `shortDescription` field for skills entries, surfaced in the skills popup. • Adds macOS DMG build target for easier distribution and installation. • Improves terminal detection metadata to enable per-terminal scroll tuning. • Updates bundled system skills included with the CLI. Breaking changes: • The `exclude` setting now defaults to `true` in the app server, changing behavior for existing app-server deployments that relied on the previous default.

OpenAI Codex CLI rust-v0.74.0

Thu, 18 Dec 2025 18:08:47 GMT

Codex CLI gains gpt-5.2-codex model, a new /experimental slash command, model picker UI, and configurable ghost-snapshot warnings. • New `/experimental` slash command for accessing experimental features from within the CLI. • New model picker UI for selecting models interactively. • Adds config option to disable ghost snapshot warnings. • Supports SYSTEM-level skills, expanding the skills system beyond user-defined entries. • Adds public skills discovery with improved repo skill discovery and error UX. • TypeScript SDK gains `xhigh` reasoning effort support. • Model list loading is now non-blocking, improving startup responsiveness. • Constrains allowed values for `approval_policy` config field. • Sandboxes the `.codex` sub-folder as read-only when it resides inside a writable root.

OpenAI Codex CLI rust-v0.73.0

Mon, 15 Dec 2025 22:38:50 GMT

Codex CLI v0.73.0 adds OpenTelemetry tracing, ghost snapshot v2, ghost commit config support, and a reimplemented SkillsManager. • Adds ghost snapshot v2 for improved session capture. • Supports ghost commits via config for session replay workflows. • Reimplements skills loading via SkillsManager and `skills/list` for consistent discovery. • Adds OpenTelemetry tracing support for observability into Codex operations.

OpenAI Codex CLI rust-v0.72.0

Sat, 13 Dec 2025 01:22:42 GMT

Codex CLI v0.72.0 adds remote compaction for API-key sessions, expanded sandbox safety, and 1Password support. • Enables remote compacting (context compaction via API) for API-key-based sessions, not just OAuth users. • Adds 1Password integration support. • Introduces Elevated Sandbox levels 3 and 4, tightening sandboxing for shell command execution. • Expands the safe-command allowlist, reducing unnecessary sandbox prompts for common operations. • Adds reliable utilities for locating `pwsh.exe` and `powershell.exe` on Windows, and uses PowerShell to parse PowerShell syntax. • Signs two additional Windows executables for improved trust on Windows hosts. • New config API with a cleaner config loading flow.

OpenAI Codex CLI rust-v0.71.0

Thu, 11 Dec 2025 18:36:44 GMT

Codex CLI rust-v0.71.0 adds gpt-5.2 support, shell snapshots, long-snapshot warnings, and an elevated Sandbox 2. • Adds gpt-5.2 as a selectable model, OpenAI's latest frontier model with improvements across knowledge, reasoning, and coding. • Shows the default model in the model picker so practitioners can see at a glance what will be used. • Adds shell snapshots for shell commands, capturing environment state for reproducibility. • Adds warnings when snapshots grow too long, surfacing potential performance or context issues early. • Introduces Elevated Sandbox 2, an upgraded sandboxing environment.

OpenAI Codex CLI rust-v0.69.0

Wed, 10 Dec 2025 22:28:39 GMT

Codex CLI gains Skills injection, MCP in-session login, vim TUI navigation, shell snapshotting, and an experimental tui2 frontend. • Adds Skills support: explicitly selecting a skill now injects its SKILL.md content into the turn; skills load once per session and warn on unreadable files. • Adds MCP in-session login so users can authenticate to Model Context Protocol servers without leaving the CLI session. • Adds vim-style navigation keys (hjkl/arrow equivalents) for both option selection menus and the transcript pager. • Adds shell snapshotting in the exec/sandbox layer for safer and more reliable command execution. • Introduces an experimental tui2 frontend, available behind a feature flag. • Elevates Linux sandbox allowances to permit sendmsg/recvmsg syscalls, unblocking more networked workloads. • Adds support for using a remote branch when performing reviews if the local branch trails, enabling review of unsynced work. • Rate-limit warnings now display as percentage of quota remaining for clearer visibility. • Config writes now preserve comments and key order; model field is optional to match real-world config files. • TUI log files now strip ANSI escape codes for cleaner plaintext logs. • Adds `codex-max` prompt and tools support for experimental models.

OpenAI Codex CLI rust-v0.66.0

Tue, 09 Dec 2025 03:37:53 GMT

Codex CLI gains execpolicy TUI whitelisting, `--branch` for cloud exec, sigstore signing, and cloud status/diff/apply flows. • Adds TUI ability to whitelist command prefixes after an approval, so repeated similar commands skip future prompts. • Sandbox denials now propose an execpolicy amendment in the TUI that you can accept inline. • Shell MCP server now runs execpolicy, so MCP tools follow the same approval rules as direct commands. • Execpolicy fallback checks now inspect each pipeline segment, catching unsafe tails like `| rm -rf` that were previously missed. • Adds `--branch` flag to `codex cloud exec` for targeting a specific branch on remote runs. • Adds `status`, `diff`, and `apply` subflows to the cloud exec path so you can inspect and apply cloud-run changes locally. • Linux release artifacts are now signed via sigstore for supply-chain verification. • Adds is-mutating detection for the shell command handler to better classify dangerous shell operations. • Skills are also loaded from the repository root in addition to existing search paths. Breaking changes: • `experimental_use_rmcp_client` is removed from the config (the flag no longer exists).

OpenAI Codex CLI rust-v0.65.0

Thu, 04 Dec 2025 18:23:17 GMT

Codex CLI adds /resume and /skills commands, history trimming, pycache exclusion, and Ctrl-P/N TUI navigation in v0.65.0 • Adds `/resume` slash command for snappier session resumption from the TUI. • Adds `/skills` slash command (also via `$`) for listing and selecting skills defined in skills.md. • Promotes Codex Max as the new default model. • Trims `history.jsonl` automatically when `history.max_bytes` is set, capping local history size. • Ignores common junk directories — including `__pycache__` — by default to reduce context noise. • Adds Ctrl-P / Ctrl-N keyboard shortcuts for arrow navigation inside the TUI textarea. • Renders tips and tooltips via Markdown with a bold 'Tip' label for richer in-app guidance. • Adds model warning when `apply_patch` is used with an incompatible model. • Supports listing MCP servers from the app-server API. • Adds `--version` flag for the `@openai/codex-shell-tool-mcp` package. • Adds one-off commands support to app-server v2. • Introduces alias compaction for more efficient context management. • Adds experimental support for `skills.md` skill definitions. • Displays tokens used when the context window size is unknown. • Restores clipboard image paste support on native Windows in the TUI.

OpenAI Codex CLI rust-v0.64.0

Tue, 02 Dec 2025 22:15:06 GMT

Codex CLI v0.64.0 adds detached review mode, MCP elicitations, per-run custom env injection, compaction events, and ImageView inline rendering. • Adds experimental `exp` model selection for tool experimentation. • Adds unified exec basic pruning strategy to limit session bloat. • Adds per-run custom environment injection for unified exec processes. • Adds policy-approved command bypass so approved commands skip sandbox checks. • Adds detached review mode with explicit enter/exit events and review thread IDs. • Adds MCP elicitations support for interactive model-initiated prompts. • Adds shell-tool MCP login support and explicit server capability declaration. • Publishes `@openai/codex-shell-tool-mcp` to npm for public installation. • Adds compaction events emitted on threads and turns for observability. • Adds token-usage and plan-update notifications on thread/turn events. • Adds `item/fileChange/outputDelta` output deltas on file-change items. • Adds `ImageView` item type that renders images inline in the app-server. • Exposes process IDs on command items for event handling. • Adds thread and turn IDs propagated on every item and error notification. • Exposes git info, current working directory, CLI version, and source metadata on threads. • Adds `send-followup-v2` to the app-server test client. • Adds config management utilities to the app-server. • Enables history lookup on Windows and WSL. • Enables enterprises to skip upgrade checks and messages. • Windows sandbox flags risky browser or URL launches as dangerous before execution. • Consolidates world-writable-directory scanning for improved safety defaults. • Upgrades rmcp client to 0.10.0, enabling custom client notifications. • Adds `cargo-audit` and `cargo-deny` for supply-chain security in CI.

OpenAI Codex CLI rust-v0.63.0

Fri, 21 Nov 2025 18:25:18 GMT

Codex CLI adds a Declined status for command execution approvals in the app server. • Adds a Declined status for command execution, allowing the app server to explicitly signal when a command has been rejected.

OpenAI Codex CLI rust-v0.59.0

Wed, 19 Nov 2025 18:09:22 GMT

Codex CLI gains GPT-5.1-Codex-Max, native Windows Agent mode, compaction support, and expanded 10K tool output tokens. • Adds GPT-5.1-Codex-Max model for higher reliability and long-running, project-scale agentic coding workflows. • Introduces native Windows Agent mode with an experimental sandbox that limits filesystem and network access, allowing Codex to read/write files and run commands with fewer approvals. • Adds first-class Native Compaction support to improve performance across extended coding sessions, enabled by default. • Expands tool output token limits to 10,000 tokens, configurable via `tool_output_token_limit` in `config.toml`. • Adds LM Studio OSS model support. • Adds mTLS configuration support for OpenTelemetry via the `[otel]` config section. • Enables parallel tool calls for faster multi-step agent execution. • Adds git branch tooling so the model can query and work with branches programmatically. • Adds `--add-dir` flag to exec and the TypeScript SDK for specifying additional working directories. • Credits are now visible via the `/status` command. • Codex Resume now displays branches and filters sessions by current working directory. • Adds placeholder icons for images that cannot be decoded to prevent API errors. • Adds non-blocking MCP server startup so the TUI is responsive while MCP tools initialize. • TUI notifications are now enabled by default.

OpenAI Codex CLI rust-v0.58.0

Thu, 13 Nov 2025 18:04:00 GMT

Codex CLI gains GPT-5.1 support, a new shell_command tool, seatbelt log-denials debugger, and app-server JSON schema generation. • Adds support for the gpt-5.1 model family, including model picker integration and NUX onboarding. • New `shell_command` tool for executing shell commands from within the agent. • New `codex debug seatbelt --log-denials` command for diagnosing sandbox permission denials. • App-server gains a new command to generate JSON schema for protocol definitions. • App-server adds `item started/completed` events for turn items, enabling finer-grained lifecycle tracking. • App-server `thread/resume` endpoint now supports `history`, `path`, and `overrides` parameters. • Adds `workdir` field to `unified_exec` for controlling working directory of executed commands. • Adds opt-out for rate-limit model nudge, giving users control over model-switch suggestions. • Unified exec gains escalation handling for more robust sandboxed execution. • Enables `ghost_commit` feature by default, committing only after mutating tools complete. • TUI now displays keyboard shortcuts inline for approval options. • Windows `.exe` artifacts are now uploaded for CLI releases, enabling direct Windows binary downloads. • Auth-aware status output now uses authentication information from `AuthManager`. • Rate-limit status bar is now surfaced in the UI. • Warns when a model switch occurs on session resume. • Proxy context is preserved across compaction events.

OpenAI Codex CLI rust-v0.57.0

Sun, 09 Nov 2025 22:30:05 GMT

Codex CLI gains Ctrl-N/P slash-command navigation, unified exec safe-command auto-approval, and new app-server endpoints. • Adds Ctrl-N / Ctrl-P keyboard navigation for slash command lists, file pickers, and history in the TUI. • Unified exec mode now allows safe commands to run without requiring user approval. • Skips retries automatically when the API returns an `insufficient_quota` error, avoiding unnecessary wait loops. • Removes the shell tool when unified exec is enabled, streamlining the tool surface. • Promotes shell config tool to model family config level. • App-server implements the `account/read` endpoint. • App-server exposes additional fields on the `Thread` object. • Adds `network_access` and `web_search` options to the TypeScript SDK. • WSL: normalizes Windows paths during updates. • Replaces raw Cloudflare 403 HTML responses with a friendly error message. • Kills shell tool process groups on timeout, improving cleanup for long-running commands. Breaking changes: • The shell tool is removed from the available tool set when unified exec is enabled (`--unified-exec`).

OpenAI Codex CLI rust-v0.56.0

Fri, 07 Nov 2025 18:09:48 GMT

Codex CLI gains GPT-5-Codex-Mini, model nudges, single-reasoning-effort model support, and new v2 server APIs. • Introduces GPT-5-Codex-Mini, a compact and cost-efficient variant of GPT-5-Codex. • Adds model nudge suggestions for queries to guide model selection. • Supports models with a single reasoning effort level. • Windows Sandbox now warns when an Everyone-writable directory is detected. • Sandbox widened to allow certificate operations when network is enabled. • App-server exports v2 Thread, Turn, and account login (start/completed/cancel) APIs. • Session metadata is now included in listConversations responses. • Allows Codex to be run from PID 1. • Loads custom prompts from symlinked Markdown files.

OpenAI Codex CLI rust-v0.54.0

Tue, 04 Nov 2025 18:53:40 GMT

Codex CLI v0.54.0 adds Azure OpenAI proxy support, an improved compactor, and elapsed-time display after aborts. • Adds options to `responses-api-proxy` to support Azure OpenAI endpoints. • Introduces compactor v2 (`feat: compactor 2`) for improved conversation compaction, with a warning displayed on compact. • Shows elapsed time in the TUI after aborting a request. • Follows symlinks during file search. • Parses Azure OpenAI rate-limit messages for clearer error reporting. • Logs sandbox commands to `$CODEX_HOME` instead of the current working directory. • Includes reasoning tokens in the context window calculation. • Adds sandbox command assessment changes based on experiment feedback. • Refines TUI text-area word separator handling. • Ensures the trust prompt is not skipped on Windows when sandbox is enabled.

OpenAI Codex CLI rust-v0.53.0

Fri, 31 Oct 2025 01:21:24 GMT

Codex CLI gains a Windows Sandbox alpha, /exit command alias, and absolute-time rate-limit errors. • Adds Windows Sandbox alpha support for isolated execution on Windows. • Adds `/exit` as a slash-command alias for `/quit`. • Rate-limit errors now report an absolute timestamp instead of a relative delay. • Removes last-turn reasoning filtering, exposing full reasoning output. Breaking changes: • The `include_view_image_tool` config key has been removed; any config referencing it will need to be updated.

OpenAI Codex CLI rust-v0.52.0

Thu, 30 Oct 2025 18:32:13 GMT

Codex CLI v0.52.0 adds shell passthrough with `!`, TUI undo, configurable compaction prompt, keyring auth, and MCP OAuth scopes. • Adds `!` syntax to execute shell commands directly from the Codex prompt. • New TUI undo operation lets users roll back the last applied change. • Queued messages are now visible in the TUI during active response streaming. • Compaction prompt is now configurable by the user. • New auth storage abstraction with OS keyring support and configurable backend. • Adds MCP OAuth scope specification support via `mcp add`. • MCP tool call results that include images are now rendered to the model. • Environment variable values are redacted in `/mcp` and `mcp get` output. • New `GetConversationSummary` RPC enables fetching and resuming conversation summaries by ID. • Item streaming events added to the app-server protocol. • Sandbox policy violations now surface a model summary and risk assessment. • Adds `sandbox_mode` support in user profiles. • MIME type verification added for attached images. • Windows TUI now displays auto-mode setup guidance. • Conversations annotated with `model_provider` field to enable filtering. • Ability to purchase credits for additional usage surfaced in the CLI. • MCP startup errors for timeouts and GitHub auth now provide clearer messaging. • Local tokenizer used for accurate truncation of unified exec tool outputs. • Stale or missing rate-limit data now produces explicit messaging in the TUI. • Returns an error when an unknown feature flag is passed to enabled/disabled feature config.

OpenAI Codex CLI rust-v0.50.0

Sat, 25 Oct 2025 21:37:23 GMT

Codex CLI v0.50.0 adds sandbox policy risk assessments, stale rate-limit messaging, and MCP env-var redaction. • Adds model summary and risk assessment output for commands that violate sandbox policy. • Adds messaging when rate limits are stale or no rate limits are cached. • Introduces `codex/event/raw_item` events in the app-server event stream. • Improves `/feedback` command diagnostics for better issue reporting.

OpenAI Codex CLI rust-v0.48.0

Thu, 23 Oct 2025 23:47:39 GMT

Codex CLI gains --add-dir, MCP tool filtering, OAuth scopes, enterprise login controls, and auto-compaction at 90% context. • Adds `--add-dir` flag to specify additional writable working directories beyond the default. • MCP stdio servers now use the official Rust MCP SDK (rmcp) as their client backend. • MCP stdio servers can specify a `cwd` to set their working directory. • MCP servers support `enabled_tools` and `disabled_tools` config options to selectively allow or block individual tools. • Streamable HTTP MCP servers can specify OAuth `scopes` during `codex mcp login`. • Adds `forced_login_method` and `forced_chatgpt_workspace_id` configuration options for enterprise managed-config control. • Adds experimental `codex stdio-to-uds` subcommand. • Adds `experimental_bearer_token` option to model provider definitions for custom auth. • Auto-compacts conversation context when it reaches ~90% of the model's limit. • Plan tool is now enabled by default in exec mode. • Local tokenizer used for accurate context truncation in unified exec. • Text cleared with Ctrl+C is preserved in input history and recoverable with the up arrow. • MCP tool names are now prefixed with `mcp__` for clearer namespacing. • Dedicated error message for GitHub MCP servers missing a personal access token. • When MCP auth expires, the user is prompted to log in again interactively. Breaking changes: • MCP tool names are now prefixed with `mcp__` — any automation or configuration referencing MCP tool names by their previous unprefixed names will break.

OpenAI Codex CLI rust-v0.47.0

Fri, 17 Oct 2025 17:07:34 GMT

Codex CLI gains agent overrides, OAuth MCP login, full-access warnings, macOS code signing, and auto-update banners. • Adds indentation mode for `read_file` to control how file content is presented. • Adds an agent override file to customize agent behavior without changing global config. • Prompts MCP OAuth login automatically when adding a streamable HTTP server that supports OAuth. • Adds a confirmation prompt (warning) when enabling full-access approval mode. • Adds an auto-update banner with approval flow, including detection of Bun installs. • Adds a warning about rate limits when using high-effort mode. • Adds dangerous auto-approval option for `codex exec`. • Adds `codex cloud exec` subcommand for cloud-based execution. • Includes parsed command data in `ExecApprovalRequestEvent` for richer approval metadata. • Adds a `path` field to the `ParsedCommand::Read` variant. • Passes Codex thread ID in notifier metadata for better traceability. • Adds a header display for task kind in the TUI. • Adds macOS code signing and notarization to release binaries. • Shows a message when a stream is correctly resumed. • Exposes sandbox denied errors in logs for easier diagnosis.

OpenAI Codex CLI rust-v0.46.0

Thu, 09 Oct 2025 02:06:27 GMT

Codex CLI gains streamable HTTP MCP servers, new list_dir/grep_files tools, and alias creation in v0.46.0 • Adds `list_dir` built-in tool, giving the agent a native directory-listing capability. • Adds `grep_files` built-in tool for pattern-based file searching during agent sessions. • Supports streamable HTTP MCP servers via `codex mcp add`, alongside optional bearer token or OAuth login. • Adds `enabled` config field per MCP server entry so individual servers can be toggled without removing them. • Adds ability to explicitly specify a credentials store for MCP server authentication. • Adds auth status reporting for MCP servers. • Enables new MCP stack via `experimental_use_rmcp_client = true` in `config.toml`. • Adds UP/ENTER keybinding support in the CLI input. • Switches TUI code highlighting to tree-sitter for bash syntax. • Adds animated breathing spinner on true-color terminals. • Adds dynamic width for line numbers in diff views. • Truncates context on compact to manage long sessions.

OpenAI Codex CLI rust-v0.45.0

Mon, 06 Oct 2025 19:21:42 GMT

Codex CLI gains OAuth MCP auth, parallel tool calls, and gpt-5 default for Windows in v0.45.0 • Adds experimental OAuth authentication support for MCP servers. • Removes the requirement to set `experimental_use_rmcp_client` for streamable HTTP MCP servers that don't need OAuth. • Adds initial parallel tool call support. • Defaults to `gpt-5` for Windows users who have not configured a model. • Outputs only the final message to stdout for `codex exec`, enabling cleaner scripting pipelines. • Adds a pulsing dot loading state indicator in the UI. Breaking changes: • The `codex login --api-key` flag is replaced by `--with-api-key`, which reads the key from stdin; existing scripts passing the key directly via `--api-key` will break.

OpenAI Codex CLI rust-v0.44.0

Fri, 03 Oct 2025 17:01:36 GMT

Codex CLI v0.44.0 adds cloud task management, streamable HTTP MCP servers, custom prompt arguments, and a refreshed TUI. • New TUI refresh: updated chat composer, bottom pane, two-stage model picker, and upgrade nudge. • Custom prompts now support named and positional (numeric) arguments via the `/prompts:` prefix. • Adds support for streamable HTTP MCP servers. • New `codex cloud` subcommand (very experimental) for managing cloud tasks. • Experimental reduction of repetitive approval prompts for read-only (safe) commands on Windows via PowerShell command safety classification. • Displays context window usage ratio while tasks are running. • Shows 'Viewed Image' indicator when the model processes an image. • Adds `/review` command to main command palette. • Fuzzy file search is now exposed via the MCP server. • OpenTelemetry events support added. • Web search item wired up in the response stream. • Falls back to configured instruction files when `AGENTS.md` is not available. • Adds `Updated at` time in the session resume picker. • Supports `CODEX_API_KEY` environment variable for `codex exec`. • Separates `codex mcp` into distinct `codex mcp-server` and `codex app-server` subcommands. • TypeScript SDK scaffold introduced with support for model, sandbox mode, working directory, and `skipGitRepoCheck` options. • Writes PID in addition to port to the server info file. Breaking changes: • The `codex mcp` command is split into `codex mcp-server` and `codex app-server`; any scripts or configs invoking `codex mcp` will break. • The legacy `codex exec --json` format is removed; callers relying on the old JSON output format will break.

OpenAI Codex CLI rust-v0.42.0

Fri, 26 Sep 2025 18:42:34 GMT

Codex CLI gains an experimental Rust SDK MCP client, a responses-API proxy, secure mode, and safer command execution checks. • Adds experimental Rust SDK–based MCP client for model context protocol integration. • New `responses-api-proxy` component to simplify and secure response handling and proxying. • New `CODEX_SECURE_MODE=1` environment variable to restrict process observability in sensitive environments. • Adds explicit `codex exec` events, including `item.started`, with improved output display on success. • Adds dangerous command detection checks in core and a Windows-specific safe-command check before execution. • Revamped `/status` command with clearer presentation and details. • Pageless session list for browsing sessions without pagination interruptions. • Approvals UI moved to `ListSelectionView` for a more consistent selection experience. • Improved MCP tool call styling in the terminal UI. • Hides status indicator during answer streaming to reduce visual noise.

OpenAI Codex CLI rust-v0.41.0

Wed, 24 Sep 2025 17:10:52 GMT

Codex CLI gains rate-limit visibility, exec output schemas, and an include-plan-tool flag in v0.41.0. • Shows rate-limit reset time and current usage when a rate limit is hit, so practitioners know exactly when to retry. • Adds `--output-schema` parameter to `exec` mode for specifying a structured output schema. • Adds `--include-plan-tool` flag to `exec` mode to include and display the plan tool. • Vendors Ripgrep (`rg`) directly into the npm release, eliminating `@vscode/ripgrep` postinstall failures.

OpenAI Codex CLI rust-v0.40.0

Tue, 23 Sep 2025 16:28:39 GMT

Codex CLI gains /review commands, usage limits in /status, MCP timeouts, and defaults to gpt-5-codex with auto-compaction. • Switches default model to `gpt-5-codex`. • Adds automatic context compaction for `gpt-5-codex` when the session hits 220k tokens. • Adds usage limits display to the `/status` command. • Adds `/review` command with options to review a specific commit, diff against a base branch, or apply custom review instructions. • Adds configurable MCP tool call timeout: defaults to 60s, overridable per-server via `tool_timeout_sec` in `config.toml`. Breaking changes: • The `/limits` command has been removed; usage limit information has moved to `/status`.

OpenAI Codex CLI rust-v0.39.0

Thu, 18 Sep 2025 21:48:53 GMT

OpenAI Codex CLI v0.39.0 introduces the new `/review` command for in-session code review. • Adds `/review` command for initiating code review directly within a Codex CLI session. • Adds hint for `codex resume` on TUI exit to help users continue interrupted sessions. • Turn notifications now include the agent's reply text for richer context.

OpenAI Codex CLI rust-v0.37.0

Wed, 17 Sep 2025 17:59:38 GMT

OpenAI Codex CLI rust-v0.37.0 adds approval/turn-end notifications, persistent search, and review mode core updates. • Adds desktop notifications on approvals and turn end. • Persists search items across sessions. • Introduces review mode core updates. • Restyled thinking outputs for improved readability. • Adds a dev message upon review exit.

OpenAI Codex CLI rust-v0.36.0

Mon, 15 Sep 2025 17:17:00 GMT

Codex CLI v0.36.0 adds GPT-5-Codex, session resumption, JSON-RPC expansions, MCP interface, and experimental context compaction. • Adds GPT-5-Codex model support: faster on easy tasks, harder on complex tasks, with improved code quality and better AGENTS.md steerability. • New `codex resume` command lets practitioners pick up old conversations where they left off. • New `codex login --api-key` command stores API credentials in `CODEX_HOME/auth.json` for explicit, persistent authentication. • Adds initial MCP (Model Context Protocol) interface and documentation for integrating external tool servers. • Expands JSON-RPC server with `SetDefaultModel` (passing `None` clears the default), `UserInfo`, and `reasoning_effort` field in `NewConversationResponse`. • Introduces experimental automatic context compaction to handle long sessions without manual intervention. • New TUI onboarding flow with animations, consistent session headers on resume, and reasoning-level display in the header. • Expands default sandbox permissions to cover a broader set of operations out of the box. • Command output is now included when a timeout is sent to the model, giving it context on what ran before the cutoff. • Adds `Review Mode` core capability for reviewing changes before applying them. • Workspace roots are now injected into the environment context automatically. Breaking changes: • `OPENAI_API_KEY` is no longer read from the environment; run `codex login --api-key "your-api-key-here"` once to store the key in `CODEX_HOME/auth.json`, or run `codex login` to use ChatGPT auth.

OpenAI Codex CLI rust-v0.33.0

Wed, 10 Sep 2025 19:53:13 GMT

Codex CLI 0.33.0 adds a custom Markdown renderer, image support in messages, and keyboard word-deletion. • New custom Markdown renderer replaces tui_markdown for improved in-terminal rendering. • Supports images in `UserMessageEvent`, enabling image attachments in chat messages. • Adds `alt+delete` keybinding to delete the word to the right of the cursor (`delete_forward_word`). • Sets a user-agent suffix when Codex is used as an MCP server. • Introduces rollout items for staged feature delivery. Breaking changes: • The POSIX unification and snapshot sessions feature (introduced in #3179) has been reverted; any workflows depending on that behavior will no longer work.

OpenAI Codex CLI rust-v0.32.0

Wed, 10 Sep 2025 17:24:16 GMT

Codex 0.32.0 adds Alt+Delete word deletion, ArchiveConversation API, rollout groundwork, and broader apply_patch OSS model compatibility. • Adds Alt+Delete keybinding in the TUI to delete the next word to the right of the cursor. • Adds `ArchiveConversation` request type to the client protocol for conversation management. • Includes `rollout_path` in `NewConversationResponse` as initial groundwork for rollout support. • Expands `apply_patch` compatibility to OSS models from gpt-oss providers using alternative naming conventions (e.g. `openai/gpt-oss-*`). • Sets a user-agent suffix when Codex acts as an MCP server. • Re-exports `InitialHistory` from `conversation_manager` and generates additional TypeScript types, including returning conversation ID with `ConversationSummary`. Breaking changes: • The `config.responses_originator_header_internal_override` config key is replaced by the `CODEX_INTERNAL_ORIGINATOR_OVERRIDE_ENV_VAR` environment variable; any existing config using the old key will no longer work.

OpenAI Codex CLI rust-v0.31.0

Mon, 08 Sep 2025 21:32:22 GMT

Codex CLI 0.31.0 adds per-MCP-server startup timeouts, command preview highlighting, and richer session/status info. • Adds `startup_timeout_ms` config option per MCP server declaration, fixing slow-start issues especially on Windows. • Shows minutes and hours in the TUI thinking timer for long-running sessions. • Displays CLI version in `/status` output. • Respects model family configuration overrides from the TOML config file. • Moves token usage and context information to the session level in the TUI. • Clears non-empty prompts with Ctrl+C. • Highlights the Proposed Command preview in the TUI. • Adds a `getUserAgent` MCP method. • Cancels pending OAuth login to free up the localhost port when login is abandoned.

OpenAI Codex CLI rust-v0.30.0

Fri, 05 Sep 2025 22:07:26 GMT

Codex CLI 0.30.0 adds session resume/continue flags, MCP session history, bash syntax highlighting, and Windows Full Access auto-approval. • Adds `--resume` session picker and `--continue` quick-resume flags to the TUI for returning to previous sessions. • Adds MCP session resume and history listing support, replaying event messages from response items on resume. • Adds bash syntax highlighting in the TUI command display. • Enables auto-approval of patches on Windows in Full Access (DangerFullAccess) mode, eliminating approval prompts on non-sandboxed platforms. • Improves `@` file search to include specific hidden directories such as `.github` and `.gitlab`. • Introduces a rollout policy mechanism for controlled feature exposure. • Adds a shared HTTP client for more consistent network handling. • Uses macOS-native key glyphs (⌥⇧⌃) for keyboard hints on Mac. • Pager now auto-scrolls (pins scroll to bottom) in the TUI. • Introduces MCP sandbox call support. • Prompts Codex to read `AGENTS.md` files for project-level agent instructions. Breaking changes: • Project `.env` files are no longer loaded automatically — environment variables previously sourced from a project `.env` on startup must now be set in the shell or passed explicitly.

OpenAI Codex CLI rust-v0.29.0

Wed, 03 Sep 2025 08:32:19 GMT

Codex CLI 0.29.0 adds Android/Termux support, Windows ARM64 distribution, and switches to the latest search tool. • Adds Android/Termux support by gating the `arboard` dependency on unsupported targets. • Includes Windows ARM64 executable in the npm package. • Switches to the latest search tool for `@` search queries. • Supports `cd foo && ...` syntax in `exec` and `apply_patch` commands. • Shows a loading state in the TUI when `@` search results are pending. • Adds stable, cross-platform file locking using `std::fs` APIs. • Adds a rollout listing API and returns file heads via the extracted `rollout` module.

OpenAI Codex CLI rust-v0.26.0

Fri, 29 Aug 2025 03:34:49 GMT

Codex CLI gains custom slash-prompt libraries, agentic image viewing, and an MCP GetConfig endpoint. • Adds custom `/prompts` support: drop prompt files into `~/.codex/prompts` to create reusable slash commands. • New 'View Image' tool lets Codex agentically load and interpret local image files during a task. • New MCP `GetConfig` endpoint exposes the fully resolved Codex configuration for inspection by MCP clients.

OpenAI Codex CLI rust-v0.25.0

Wed, 27 Aug 2025 08:42:26 GMT

Codex CLI gains remove_conversation API, mouse wheel scrolling, Alt+Ctrl+H word deletion, and context window on task_started events. • Adds `remove_conversation` API to `ConversationManager` for manual cleanup in long-lived servers. • Enables mouse wheel alternate scrolling in transcript and diff views. • Adds Alt+Ctrl+H shortcut to delete the previous word (parity with Alt+Backspace). • Includes context window information on `task_started` events; model may now vary per turn. • ESC with queued messages returns them to the composer instead of discarding them. • Caches transcript line wraps to keep long transcripts responsive.

OpenAI Codex CLI rust-v0.24.0

Tue, 26 Aug 2025 17:40:56 GMT

Codex CLI gains web search, transcript mode, image paste, queued messages, and long-running shell command support. • Adds web search capability via the explicit `--search` option. • New transcript mode (Ctrl+T) with live-updating scrollable view of the full session. • Supports copy/paste and drag-and-drop of image files directly into the TUI (macOS Terminal + iTerm). • Introduces queued messages, letting input be staged while the model is still responding. • Adds edit/resume conversation from any previous message in history (esc-esc). • Adds long-running shell command support via new `exec_command` and `write_stdin` tools. • New `model_verbosity` config option for tuning GPT-5 output verbosity via the Responses API. • Now reads all AGENTS.md files up the directory tree to the git root for richer project context. • Diff output now displayed in a pager with hunk headers for easier review. • Simplifies command approval UI in the TUI. • Hides chain-of-thought (CoT) output by default; surfaces headers in the status indicator instead. • Improves MCP tool cache hit rate by sorting tools deterministically.

OpenAI Codex CLI rust-v0.23.0

Wed, 20 Aug 2025 05:48:52 GMT

Codex CLI gains /mcp, /approvals, and /model slash commands plus runtime reasoning effort control and ChatGPT auth auto-refresh. • Adds `/mcp` slash command in the TUI to inspect and interact with MCP servers. • Adds `/approvals` slash command to control approval/permission settings at runtime. • Adds `/model` slash command to change the active model and reasoning effort without restarting. • Adds 'minimal' reasoning effort level for GPT-5 models. • Shows login options when not signed in with ChatGPT, improving auth discovery. • Auto-refreshes ChatGPT auth tokens to maintain uninterrupted sessions. • Shows a progress indicator for the `/diff` command. • Adds a `/diff` command for diffing session changes. • Releases zip-archived binaries for easier distribution. • Adds DotSlash entry for Windows x86_64, enabling Windows distribution support. • Adds Ctrl+H as an additional backspace keyboard shortcut in the TUI. • Supports Ghostty terminal Ctrl-b/Ctrl-f word-navigation fallback in the TUI.

OpenAI Codex CLI rust-v0.22.0

Fri, 15 Aug 2025 17:31:58 GMT

Codex CLI gains markdown streaming, improved diff UI, Ctrl-Z TUI suspend, and a Rust-native login server. • Supports markdown streaming in the TUI output. • Improved diff display readability when using a light terminal background. • Adds `ctrl-z` keybinding to suspend the TUI. • Login server rewritten in Rust, replacing the Python implementation.

OpenAI Codex CLI rust-v0.21.0

Tue, 12 Aug 2025 04:43:24 GMT

Codex CLI v0.21.0 adds diff previews for apply_patch, output truncation notices, and MCP JSON schema sanitization. • Shows a diff preview when `apply_patch` is about to modify files, letting you inspect changes before they land. • Includes an output truncation message in tool call results so the model knows when it received incomplete command output. • Adds JSON schema sanitization for MCP tools to ensure compatibility with internal JsonSchema enums. • Sends a prompt cache key to improve token efficiency through better caching. • Splits multiline commands in the UI for improved readability. • Parses and formats exec commands more clearly in the UI. • Shows a feedback message after the `/compact` command completes.

OpenAI Codex CLI rust-v0.15.0

Thu, 07 Aug 2025 17:29:06 GMT

Codex CLI v0.15.0: gpt-5 default, new approval mode, and trust-based onboarding flow • Sets `gpt-5` as the default model for all sessions. • Adds `--ask-for-approval on-request` mode, letting the model decide when to prompt for user approval — a middle ground between `on-failure` and `never`. • Introduces a new onboarding flow that auto-configures `--sandbox workspace-write` and `--ask-for-approval on-request` when a folder is marked as trusted, optimized for Git repo workflows. Breaking changes: • The default model is changed to `gpt-5`; any workflow that relied on the previous default model will now use `gpt-5` instead.

OpenAI Codex CLI rust-v0.11.0

Sat, 02 Aug 2025 00:49:31 GMT

Codex CLI gets native terminal scrolling, /compact command, experimental planning tool, and version-update notifications. • New terminal UX appends output to the end of the terminal instead of running fullscreen, enabling native scrollback and copy/paste. • Adds the `/compact` command for compacting conversation context. • Introduces an experimental planning tool. • CLI now checks for newer versions and notifies you when an update is available.

OpenAI Codex CLI rust-v0.10.0

Thu, 24 Jul 2025 21:55:46 GMT

Codex CLI v0.10.0 expands trusted commands by default and adds Git state capture to session logs. • Expands the set of commands trusted by default, reducing approval prompts for common operations. • Records Git state (branch, commit, etc.) in the `.jsonl` session log for better auditability of AI-driven changes.

OpenAI Codex CLI rust-v0.8.0

Sat, 19 Jul 2025 00:35:28 GMT

Codex CLI v0.8.0 adds response streaming in TUI and `codex exec`, plus a `--json` flag for JSONL output. • Streams model responses in real time in the TUI and when using `codex exec`. • Adds `--json` flag to `codex exec` to print output as JSONL to stdout. • Reorganizes `~/.codex/sessions` into `YYYY/MM/DD` subfolders for easier navigation and better filesystem performance. • `ctrl-d` now only exits the TUI when the composer is empty, preventing accidental exits mid-session.

OpenAI Codex CLI rust-v0.6.0

Sat, 12 Jul 2025 23:36:11 GMT

OpenAI Codex CLI v0.6.0 adds paste summarization and an experimental `codex apply` command for Codex Web. • New `codex apply` command (experimental) lets you interact with Codex Web directly from the CLI. • Adds paste summarization for large pastes, automatically condensing oversized clipboard input.

OpenAI Codex CLI rust-v0.5.0

Thu, 10 Jul 2025 21:56:47 GMT

Codex CLI rust-v0.5.0 adds reasoning-summary config control and Android platform support via npm. • New `model_supports_reasoning_summaries` config option to control reasoning summary behavior per model. • Running Codex installed via `npm` on Android (`process.platform === "android"`) now routes to the Rust CLI.

OpenAI Codex CLI rust-v0.4.0

Wed, 09 Jul 2025 07:06:51 GMT

Codex CLI v0.4.0 adds shell completion generation, per-profile reasoning controls, and custom base URL support. • Supports `OPENAI_BASE_URL` environment variable for the built-in `openai` model provider, enabling use of compatible API endpoints. • Adds `model_reasoning_effort` and `model_reasoning_summary` fields to profile definitions for fine-grained reasoning control. • New `completion` subcommand enables shell tab-completion generation for package managers like Homebrew.

OpenAI Codex CLI rust-v0.3.0

Tue, 08 Jul 2025 05:46:18 GMT

Codex CLI gains a `--sandbox` flag and custom HTTP header support for model provider requests. • Adds `--sandbox` flag to control sandbox behavior from the command line. • Enables configuration of custom HTTP headers when making requests to model providers. Breaking changes: • The `config.toml` sandbox-related options have breaking changes — existing sandbox configuration will need to be updated after upgrading.