Codex CLI 0.129.0 Adds Modal Vim Composer, Redesigned Resume/Fork Picker, and a `/hooks` Browser

OpenAI shipped Codex CLI 0.129.0 on May 7, 2026 -- the second meaningful Codex CLI release in eight days, following 0.128.0's persisted /goal workflows. Where 0.128 changed the runtime model (the agent keeps going until the goal is met), 0.129 is mostly about the surface you sit in front of: modal Vim editing in the composer, a redesigned resume/fork picker, a /hooks browser, expanded plugin management, and a long list of sandbox and MCP fixes.

For the broader Codex picture, the Codex CLI vs Claude Code vs Cursor architecture comparison is the right anchor, and our computer use, comment mode, and thread automations writeup covers the April work-agent expansion that frames where Codex is heading product-wise.

Key Takeaways

• Modal Vim composer. /vim brings modal Vim editing into the TUI composer with keymap contexts. Vim users get native bindings instead of fighting the input layer.
• Resume/fork picker, redesigned. Raw scrollback mode plus workspace-aware /diff make picking a prior session to resume or fork feel like working with real history rather than summaries.
• /hooks browser. Lifecycle hooks now have a first-class browser inside the TUI, including before/after compaction events.
• Plugin management, expanded. Workspace sharing, access controls, source filtering, and marketplace upgrades.
• Theme-aware status line. Colors now follow the active theme; optional PR and branch-change summaries surface in the status line.
• Experimental goals, polished. Pause/resume, validation, and improved discoverability for the /goal system from 0.128.
• Codex Apps auth + MCP elicitation. Surfaced through TUI/Guardian flows.
• Sandbox + MCP fixes. More reliable Linux sandbox startup, enhanced Windows sandbox (named pipes, ConPTY, Git), custom CA login, Bedrock endpoint reporting, and MCP output growth all addressed.

What Changed in /vim

/vim activates modal Vim editing inside the Codex CLI TUI composer. The changelog wording -- "modal Vim editing in TUI composer with /vim command and keymap contexts" -- is small but the keymap-contexts piece matters: keymaps behave differently depending on whether you are in normal or insert state, which is the whole point of modal editing. Without that, "Vim mode" is usually just a thin layer of bindings on top of an otherwise-modeless editor, which most heavy Vim users find more annoying than no Vim mode at all.

The practical effect: Codex CLI joins a small set of agent CLIs where the composer is something a Vim user can actually live in for long sessions. The agent composer is where you spend most of your typing time once you are using Codex seriously, and a real modal experience there removes the constant context switch between "Vim somewhere else" and "not Vim here."

The Redesigned Resume/Fork Picker

The picker is the Codex CLI surface where you select a prior session to resume or fork. Two upgrades land in 0.129:

• Raw scrollback mode. You see the actual prior turn output rather than a summarized rendering. Useful when the picker's summary view skips over the detail you need to decide whether this is the right session to fork from.
• Workspace-aware /diff. When you run /diff from inside the picker, it understands the current workspace, so the diff is relative to where you actually are rather than a stale assumption.

Combined with the /goal workflows that 0.128 added, the picker is now a meaningfully better surface for the "I had a Codex session running on this for two days, what did it actually do, where do I want to fork" workflow. That is the workflow that gets harder, not easier, as agent sessions get longer; this release notices that and makes it more habitable.

/hooks and the Compaction Boundary

0.129 introduces a /hooks browser inside the TUI for inspecting lifecycle hooks, with explicit support for before/after compaction events. Hooks are scripts the runtime calls at lifecycle points; the new browser is the in-CLI place to see what is registered, when it fires, and what it produced.

The before/after compaction support is the line worth noticing. Compaction is when the agent decides what to keep in working memory and what to drop. Hooking before lets you snapshot context before it gets thrown away; hooking after lets you transform what survives. For anyone running Codex against a long-lived workspace where the right context window is the difference between a useful agent and a confused one, hooks at the compaction boundary are a real lever.

The pattern this follows is similar to Claude Code's hook system, but with a UI for browsing what is wired up rather than a config file you have to read. That difference matters in practice -- "I do not know what hooks are firing" is one of the most common debugging failure modes in agent CLIs, and a browser is the simplest fix.

Plugin Management, Expanded

The 0.129 plugin changes are not glamorous but they are the kind of thing that makes plugin ecosystems actually work:

• Workspace sharing. A plugin can be enabled at the workspace level, not just per-machine. Teams sharing a workspace get the same plugins by default.
• Access controls. A permission layer for what plugins are allowed to do. The plugin equivalent of MCP server scopes.
• Source filtering. Constrain which plugin sources are eligible to install from. The plugin equivalent of npm's registry allowlist.
• Marketplace upgrades. In-CLI plugin updates, mirroring how codex update works for the CLI binary itself.

The combined effect is that plugins become something you can actually deploy across a team without having to hand-coordinate machines. That is the gap between "plugins exist" and "plugins are useful" for any tool with more than a few users.

Theme-Aware Status Line

The status line now picks colors from the active theme rather than hardcoded values, and optionally surfaces PR and branch-change summaries. The theme part is small but matters for the "I read terminals all day" crowd; the PR/branch summary is more interesting because it makes the status line a passive monitor for what your Codex session is touching. If you have ever lost track of which branch a long-running agent session ended up on, this is the safety rail.

Goals, Polished

The /goal system from 0.128 ships with three improvements in 0.129:

• Discoverability. The feature is easier to find from inside the TUI, not just from documentation.
• Pause/resume. You can pause an active goal cleanly and resume it later, without losing the goal state.
• Validation. The runtime now validates goal definitions rather than silently accepting malformed ones.

Pause/resume is the meaningful one. The 0.128 launch shipped goals as a "keep going until done" loop; pausing a goal is how you reclaim the agent for an unrelated turn (a quick question, a one-off file edit) without abandoning the larger objective. Without pause/resume, the only way to interject was to stop the goal entirely. With it, the goal becomes something closer to a background intent.

Codex Apps Auth and MCP Elicitation

Codex Apps auth and MCP elicitation are now surfaced through TUI/Guardian flows. The practical reading: when a Codex App or an MCP server needs auth or needs to elicit input from the user, the request comes through the same Guardian permission flow as other privileged operations rather than as an out-of-band prompt. That is the right design -- it means a long-running agent that hits an auth wall does not just hang silently; it surfaces the request the same way Codex surfaces every other thing that needs your judgment.

The Bug Fix List That Matters

The bug fixes in 0.129 are unusually long, and several touch the kind of thing that quietly bites real users:

• tmux /copy and terminal key handling. Better behavior for users running Codex inside tmux, which is most heavy users.
• Large paste placeholders and Ctrl+C draft persistence. Pasting a big block into the composer no longer breaks the placeholder rendering; Ctrl+C does not nuke a draft the way it did before.
• Reduced startup latency. Cold-start time is lower. For users who launch Codex sessions all day, this is felt.
• Linux sandbox startup, more reliable. Across the various Linux configurations Codex has to deal with.
• Windows sandbox: named pipe, ConPTY, Git. Windows has historically been the rough edge for Codex CLI; 0.129 sands several of those down.
• Custom CA login. Enterprise environments with custom CAs no longer hit the auth wall they used to.
• Bedrock endpoint reporting. Better telemetry/visibility when running against Bedrock.
• MCP output growth. MCP servers that produced ever-growing output no longer balloon the agent's context the same way.

Individually, none of these are a headline. Collectively, they are the difference between Codex CLI being a tool you can leave running across hours of work and a tool you have to nurse.

Why This Release Matters

The pattern across 0.128 and 0.129 is consistent: Codex CLI is being shaped into a tool that behaves like an editor you live in, not a CLI you visit. The 0.128 batch made long-running sessions a runtime concern (/goal, codex update, action-required terminal titles, plan-mode nudges). The 0.129 batch makes the surface inside those sessions habitable (modal Vim, real resume/fork, lifecycle visibility through /hooks, theme-aware status, the long sandbox + MCP cleanup).

That trajectory matters because it is where the competitive frontier is right now. Cursor's SDK and Composer 2 push is shaping the IDE-side of the same problem; Claude Code's recent releases are sharpening its own runtime (routines, the post-mortem on the spring quality regression). Codex CLI's bet is the terminal: that real engineers want a real terminal-native agent that respects how they actually work, complete with modal editing, hook visibility, and a status line that does not look out of place in their tmux setup.

For the canonical references, the Codex CLI changelog is the durable source for everything in 0.129.0, and the Codex GitHub releases page mirrors the same release notes for anyone tracking via Git.