Codex 0.145–0.146: Voice Coding, Agent Plugin

OpenAI shipped two feature-packed Codex releases in the same week. Codex CLI 0.145.0 landed on July 21 with audio input, realtime voice conversations, stabilized multi-agent V2, and one-click migration from Cursor and Claude Code. Eight days later, 0.146.0 arrived with Agent Plugins, session naming, and thread forking.

If you use Codex daily, both releases matter. If you are evaluating Codex against Claude Code or Cursor, the combination narrows the gap on extensibility and adds a capability neither competitor offers yet: voice-controlled coding.

Voice Coding: Talk to Your Agent

The biggest headline from 0.145.0 is audio input. Codex now accepts voice commands and common local audio formats as direct input. You can speak a task description, dictate a code review question, or talk through a refactoring plan — and Codex processes it the same way it handles typed prompts.

This is powered by streaming realtime V3 conversations. Realtime V3 is OpenAI’s latest audio processing pipeline, and in Codex it enables natural back-and-forth without the latency penalty you might expect. The agent transcribes your speech, reasons about it, and responds with tool outputs that include audio — meaning Codex can talk back.

Why this matters for beginners: voice input removes the friction of precise prompting. Instead of carefully crafting a prompt describing a bug, you can say “look at the authentication middleware and tell me why tokens expire too early” and get a directed investigation. It is not a replacement for reading code, but it lowers the barrier for getting an agent to start digging.

The ChatGPT desktop app (build 26.715, July 23) extends this further with GPT-Live full-duplex voice. You can speak and the agent listens simultaneously — no turn-taking pauses. On macOS, Screen Context lets Codex see your frontmost window while you talk through it. OpenAI showed two developers in the same room giving different voice instructions to the same Codex session simultaneously. It is the closest thing to pair programming with an AI that does not require a keyboard.

Voice is available on Plus, Pro, Business, Edu, and Enterprise plans. On iOS, you can direct Codex tasks via Remote while voice mode handles the input.

Multi-Agent V2 Goes Stable

Codex 0.145.0 stabilizes the multi-agent V2 experience. If you were using the opt-in multi-agent mode before, you know it was rough around the edges. The stable release brings:

Configurable sub-agent models. You can now assign different models to different sub-agents. Give your planning agent a reasoning-heavy model and your execution agent a fast, cheap one. This is the kind of fine-grained control that power users have been requesting since multi-agent first shipped.

Reasoning levels per agent. Set how much “thinking” each sub-agent does. A code-generation agent might need high reasoning; a file-search agent does not. This directly impacts latency and cost.

Concurrency controls. You decide how many sub-agents run in parallel. Codex’s parallel execution was always its signature feature, but without concurrency limits, a complex task could spawn more agents than your API budget or machine could handle.

Restored roles and improved navigation. The agent navigator — the UI that shows you what each sub-agent is doing — got a rewrite. Sub-agent roles are clearly labeled and the status flow is easier to follow.

For beginners: multi-agent means Codex can break a complex task into parts and run them simultaneously. One sub-agent writes tests, another refactors the implementation, a third updates documentation — all in parallel. V2 makes this practical by letting you control costs and monitor progress.

/import: Migrate from Cursor and Claude Code

One of the most practical additions in 0.145.0 is the expanded /import command. Codex can now pull in settings, MCP servers, plugins, sessions, commands, and project-scoped memories from:

Cursor — your model preferences, MCP configurations, and extension settings
Claude Code — your project rules, MCP servers, and session history

This is a one-command migration. If your team is switching from Cursor to Codex, or adding Codex alongside Claude Code, you do not have to rebuild your configuration from scratch. Run /import, select the source, and Codex maps your existing setup into its own format.

Why this matters: configuration migration has been the hidden cost of switching coding agents. Every agent has its own MCP setup, its own rules files, its own model preferences. /import acknowledges that developers do not live in a single-agent world and makes Codex a good citizen in a multi-tool workflow.

Amazon Bedrock Support

Codex 0.145.0 adds experimental Amazon Bedrock login and custom endpoint support. If your organization runs on AWS, you can now authenticate with Bedrock directly from the Codex CLI and use GPT-5.6 Sol as the default Bedrock model.

This matters for enterprise teams that cannot send code to OpenAI’s servers but can use Bedrock’s managed infrastructure. Custom endpoint support means any OpenAI-compatible API — Azure, self-hosted, or third-party — works with Codex natively.

Agent Plugins: Codex Gets an Ecosystem

The headline feature is Agent Plugins. Codex now supports plugin manifests — structured files that describe a plugin’s tools, permissions, and resource requirements. You can publish workspace plugins (private, team-scoped) or contribute to marketplaces. The initial marketplaces cover Amazon Bedrock and Claude Code, meaning plugins built for those platforms can run inside Codex with minimal porting.

Why this matters for beginners: before 0.146.0, extending Codex meant writing custom shell scripts or wiring MCP servers manually. Agent Plugins formalize the process. A plugin bundles its tools, declares what it needs, and Codex handles discovery, loading, and lifecycle. It is the difference between duct-taping integrations together and installing an npm package.

For teams, workspace plugin publishing means your internal deployment tool, your custom linting agent, or your company-specific code review bot can live inside the same Codex workflow your developers already use. No separate CLI. No separate config. Same terminal, same agent.

The plugin system also integrates with Codex’s existing skills discovery. When an executor provides skills — reusable task templates — Codex now discovers them automatically and includes them in skill selection. The reciprocal rank fusion algorithm picks the best skill for a given request from both built-in and plugin-provided options.

Session Naming: Find Your Work Later

If you have ever restarted Codex and lost track of which session was which, this one fixes it. You can now name sessions with /new or /clear. Name a session “auth-refactor” or “api-v2” and it sticks. You can also pin important threads and switch between side conversations without closing the active one.

Codex previously treated sessions as ephemeral. You started one, worked in it, and moved on. There was no labeling, no pinning, no way to jump back to an old session by name. For developers running multiple parallel agents — Codex’s signature feature — this was a real pain point. You would have five sessions open and no idea which one was handling the database migration.

Session naming pairs naturally with thread forking (see below). Name your main thread, fork it to explore an alternate approach, and switch back if the fork does not pan out. The named session stays pinned so you never lose the original.

Thread Forking: Explore Without Committing

Thread forking lets you branch a conversation into an alternate path. Start a session, reach a decision point, and fork instead of continuing. The fork creates a copy of the conversation history — you explore a different approach, and if it works, you continue there. If it does not, you switch back to the original.

Codex adds two flavors: regular forks (which appear in your thread listing) and temporary forks (which do not). Temporary forks are disposable exploration. Try a risky refactor, see if it works, discard it if it does not. Regular forks are for serious branches you want to keep.

Forked threads carry full paginated history. You can page through the conversation before the fork point, see what the agent decided, and understand why it went in a particular direction. For complex tasks that span many turns, this context matters. Starting a new session from scratch loses all of it.

Other Changes Worth Noting

The release also ships several smaller improvements that add up:

WebSocket remote execution. The app server now connects to remote Code Mode hosts over WebSocket. If you run Codex on a remote machine — a beefy Linux box, a cloud instance, a team server — the connection is persistent and bidirectional. No more polling or reconnection hacks.

Web search for custom providers. If you use a custom model provider that supports web search, Codex now enables it natively. No MCP server required. This matters for providers like Fireworks, Together, or any OpenAI-compatible endpoint that exposes search capabilities.

Proxy support hardened. The HTTP client pool now honors system proxy settings across authentication, plugin downloads, MCP authorization, remote execution, WebSockets, redirects, and LM Studio connections. If you work behind a corporate proxy, previous versions silently broke in various scenarios. 0.146.0 fixes them all.

Windows improvements. Navigation keys, process-tree termination with job objects, and proxy settings during security reviews all got fixed. Windows Codex has been catching up fast.

Skill catalog preservation. Under tight context budgets, Codex now retains more skill entries by dropping descriptions before dropping the catalog entry itself. If you use many skills, you will notice fewer “skill not available” moments.

How It Compares

Codex’s combined 0.145–0.146 release puts it in a different conversation. Goose has had extensibility since its early days — MCP servers, custom extensions, and a provider marketplace. Hermes formalized skills as reusable, shareable packages. Claude Code has the tightest model integration and the fastest release cadence. Cursor dominates the IDE layer.

But neither Goose, Hermes, nor Claude Code offer voice-controlled coding. Codex is the first major coding agent to ship native audio input with realtime V3. The /import command from Cursor and Claude Code is also unique — no other agent actively helps you migrate from its competitors.

Agent Plugins close the extensibility gap. The difference is positioning: Goose plugins focus on model providers, Hermes skills focus on workflow automation, Codex plugins lean toward tool integration and marketplace distribution. They solve different problems, and developers who use multiple agents benefit from all three.

For a deeper look at how Codex stacks up, see our Codex vs Copilot CLI terminal battle and the Codex parallel agent future analysis.

Getting Started

Update to 0.146.0 with:

npm install -g @openai/codex

Or if you installed via the standalone binary:

codex update

Name a session:

/new auth-refactor

Fork a thread:

# In an active session, use the thread controls to fork

Agent Plugins are available through the marketplace UI inside Codex. Workspace plugins require a manifest file in your project root.

The Bottom Line

Codex 0.145–0.146 together represent the most significant feature expansion since Codex went full Rust. Voice coding changes how you interact with the agent. Multi-agent V2 makes parallel execution practical and cost-controlled. /import removes the switching cost from Cursor and Claude Code. Agent Plugins open an extensibility ecosystem. Session naming and thread forking fix the two biggest workflow pain points.

If you have been waiting for Codex to match Goose’s extensibility or differentiate beyond parallel execution, this is the week it happened. Update to 0.146.0 with npm install -g @openai/codex and try voice input first — it is the feature you did not know you needed.

Looking to compare AI models without switching tabs? aiFiesta gives you GPT, Claude, Gemini, Grok, DeepSeek, and Perplexity in one place for $12/mo.

Codex 0.145–0.146: Voice Coding, Agent Plugins, Multi-Agent V2, and More