Codex 0.146.0 Explained: Session Management, Agent Plugins, and Thread Forking for Beginners

OpenAI released Codex CLI 0.146.0 on July 29, 2026 — the biggest single release of the summer for the terminal-based coding agent. It ships 239 changes across six new features, dozens of bug fixes, and a new plugin architecture that connects Codex to Amazon Bedrock and Claude Code marketplaces.

If you use Codex day-to-day, three things in this release will change your workflow: named sessions with pinning, thread forking, and Agent Plugins with a skills discovery system. Here's what each does, why it matters, and how to get started.

Named Sessions: Stop Losing Important Threads

Before 0.146.0, every Codex session got an auto-generated name. If you were juggling three tasks — a feature branch, a bug fix, and a refactor — they all blended together in the thread list. Finding the right one meant scrolling and guessing.

Now you can name sessions explicitly:

/new authentication-refactor

Or name an existing session when clearing:

/clear "API rate limiter"

Pin important threads so they stay at the top of your thread list regardless of when you last used them. Switch between side conversations without closing the active one — running a quick test in one thread no longer kills your progress in another.

Why This Matters

Session naming sounds simple until you realize most coding agents treat every conversation as disposable. You run a session, it finishes or you get distracted, and the thread becomes a ghost in your history. Named sessions with pinning turn Codex from a stateless tool into something closer to a project workspace. You can keep your "main branch work" pinned while experimenting in temporary threads that don't clutter the view.

Thread Forking: Branch Conversations Like Git Branches

Thread forking is the most powerful new feature for experienced users. When you're deep in a conversation and want to try a different approach, you can fork the current thread — it creates a copy that carries forward the full paginated history, but any changes you make in the fork don't affect the original.

Think of it like git branch for your AI conversation:

• You're 20 turns deep discussing a database migration
• You want to try a different schema without losing the original discussion
• Fork the thread — the new copy inherits everything up to that point
• Make your changes in the fork; the original stays untouched

Forks can be temporary — they won't appear in your thread listings unless you want them to. This means you can experiment aggressively without polluting your main conversation history.

Practical Example

Suppose you're refactoring an authentication module. You're 15 turns into a session, and the agent has generated several files. Now you want to try a completely different approach. Before 0.146.0, you'd either lose the context by starting fresh or keep pushing forward in a thread that's getting tangled.

With forking:

1. Fork the thread at turn 15 — you now have two identical copies
2. In the fork, tell the agent "try a JWT-based approach instead"
3. Keep the original thread if you want to go back to the session-cookie approach
4. Both threads maintain their full history independently

Agent Plugins: An Ecosystem for Extending Codex

This is the feature that changes Codex's long-term trajectory. Version 0.146.0 introduces Agent Plugins manifests — a standard way to package, publish, and discover plugins that extend what Codex can do.

What Agent Plugins Actually Are

An Agent Plugin is a bundle of capabilities that Codex can load and use during a session. Think of them like VS Code extensions but for a terminal agent. A plugin might provide:

• Custom tools the agent can call
• Pre-built workflows for common tasks
• Integration with external services
• Domain-specific knowledge and prompts

Where Plugins Come From

0.146.0 adds support for three plugin marketplaces:

1. OpenAI's own marketplace — the default source for officially supported plugins
2. Amazon Bedrock marketplace — plugins distributed through AWS's infrastructure
3. Claude Code marketplace — plugins from Anthropic's ecosystem, now accessible to Codex users

The Bedrock and Claude Code marketplace integrations are significant because they mean Codex isn't locked into a single vendor's plugin ecosystem. If a useful plugin exists in the Claude Code ecosystem, Codex can discover and use it.

Workspace Plugin Publishing

You can also publish plugins from your own workspace. This is the enterprise story: teams can build internal plugins that encode their specific tools, APIs, and workflows, then distribute them across the organization through the workspace plugin system.

# Discover plugins available to your executor
codex skills list

Codex now auto-discovers executor-provided skills and securely reads their associated resources. If you've configured skills in your environment, Codex will find them automatically.

Skills Discovery: Smarter Tool Selection

Under the hood, 0.146.0 adds a reciprocal rank fusion algorithm for skill selection. In plain terms: when Codex has multiple skills or tools available, it now uses a smarter ranking system to pick the most relevant one for your current task.

Before this release, skill selection was simpler — the agent might pick a tool based on basic keyword matching. Now it considers multiple signals and fuses them together, similar to how search engines combine ranking algorithms.

What This Means in Practice

If you have 10 skills configured — code review, testing, deployment, documentation generation, etc. — Codex is now better at picking the right one without you having to specify it explicitly. Ask it to "review this pull request" and it will prefer the code review skill. Ask it to "deploy this function" and it'll reach for the deployment skill.

The release also improves how Codex handles tight context budgets. When the available context is small, Codex now retains more skills and warns you when skill catalogs must be truncated rather than silently dropping them.

WebSocket Remote Execution

A smaller but important feature: Codex can now connect to remote Code Mode hosts over WebSocket. This means the app-server can delegate execution to a remote machine, opening the door to:

• Running Codex on a powerful remote server while controlling it from your laptop
• Connecting to cloud-hosted development environments
• Sharing a single execution environment across team members

For individual developers, this is most useful if you work on a lightweight laptop but need the agent to run on a machine with more resources. The WebSocket connection keeps the terminal responsive locally while the heavy lifting happens remotely.

Bug Fixes That Matter

Beyond the headline features, 0.146.0 fixes several issues that affect daily use:

• Proxy reliability: Proxy settings are now honored across authentication, plugin downloads, MCP authorization, remote execution, WebSockets, redirects, and LM Studio connections. If you're behind a corporate proxy, things should just work now.
• MCP connection stability: MCP connections and Apps tools stay current when authentication or configuration changes. Closed servers reconnect without restarting healthy ones.
• Windows improvements: Navigation keys are fixed, sandboxed process trees terminate reliably, and proxy settings survive security reviews.
• Terminal responsiveness: Nonblocking interrupts, better keyboard handling, and improved rendering on narrow layouts.

How to Update

If you installed Codex via npm:

npm install -g @openai/codex@0.146.0

If you're using the native binary installer:

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

# Windows (PowerShell)
irm https://github.com/openai/codex/releases/latest/download/install.ps1 | iex

Or update through the OpenAI-hosted release infrastructure (new in 0.146.0):

codex --version  # Check current version
codex update     # Update via built-in updater

What This Release Signals

Codex 0.146.0 is a shift from "AI chatbot that writes code" to "AI platform that orchestrates tools." The Agent Plugins system, skills discovery, and remote execution connect together into a vision where Codex is less a standalone agent and more a hub that coordinates multiple specialized tools.

The Bedrock and Claude Code marketplace integrations are particularly notable. Rather than building a walled garden, OpenAI is connecting Codex to other ecosystems. This is the opposite of the desktop-app-to-ChatGPT consolidation we saw earlier in July — the CLI is becoming more open while the desktop app is becoming more locked-in.

For developers choosing between coding agents, the plugin ecosystem is now a real factor. Read our Claude Code vs Codex comparison for the full picture of how the two agents differ, and check what developers say about Codex for community reactions as the product evolves.

The Beginner's Quick Start

If you're new to Codex or just updating from an older version, here's what to try first:

1. Name your sessions: Run /new my-feature-name before starting work. You'll thank yourself when you have 15 threads and need to find the right one.
2. Pin your main thread: Pin your primary work thread so it doesn't disappear under temporary experiments.
3. Fork before risky changes: Before asking the agent to do a major refactor, fork the thread. If the refactor goes sideways, you can pick up from the fork point without losing context.
4. Explore available skills: Run codex skills list to see what plugins and skills your environment provides. You might find capabilities you didn't know were available.
5. Update: Install 0.146.0 to get all these features. The proxy and MCP fixes alone are worth the update if you've been hitting connection issues.

The coding agent space is moving fast, and session management is table stakes now. What makes 0.146.0 stand out is the plugin ecosystem — it's the first release where Codex starts feeling like a platform rather than a tool.