Using OpenAI's Codex Plugin in Claude Code

The quick answer

OpenAI publishes a Codex plugin for Claude Code at openai/codex-plugin-cc. Four commands inside a Claude Code session get you from nothing to a Codex review:

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

/codex:setup reports whether Codex is installed and signed in, and can install it for you if npm is available. Once it's green, /codex:review hands your current changes to Codex and brings the review back into your Claude Code session.

What you're actually installing

The plugin doesn't ship a model, and it doesn't ship an MCP server. It's a bundle of skills, one subagent, and a few hooks that shell out to the codex binary already on your machine. The README is explicit about this: the plugin wraps the Codex app server, uses your global codex install, and picks up the same configuration Codex would use if you ran it directly. (codex-plugin-cc README)

That matters for expectations. There's no separate Codex runtime, no second sandbox, and no cloud handoff. Same machine, same repository checkout, same local sign-in.

Claude Code can print the component inventory for any installed plugin. Running claude plugin details codex on a fresh install of version 1.0.6 gave us this:

Component inventory
  Skills (11)  adversarial-review, cancel, codex-cli-runtime, ...
  Agents (1)   codex-rescue
  Hooks (3)    SessionStart, SessionEnd, Stop
  MCP servers (0)

Projected token cost
  Always-on:   ~449 tok   added to every session

Zero MCP servers changes how you think about the install. If you're used to extending Claude Code by adding an MCP server, this works nothing like that: no transport to choose, no OAuth panel, no .mcp.json entry. Codex arrives as namespaced slash commands and a subagent instead of as tools.

The ~449 always-on tokens are the standing cost of keeping the plugin enabled, paid on every request whether or not you invoke Codex. That's cheap by plugin standards, but it's real, and it's the kind of thing worth auditing when you're managing Claude Code's context across several installed plugins.

Prerequisites

You need both vendors' auth. There's no way around it, because the plugin drives a real Codex process on your machine.

• Claude Code, recent enough to have the /plugin command. Run claude --version and update if /plugin isn't recognized. (Claude Code plugin docs)
• Node.js 18.18 or later. (codex-plugin-cc README)
• A ChatGPT account or an OpenAI API key. The free ChatGPT tier is enough to start. codex login accepts either sign-in method, and whatever you use counts against your Codex usage limits. (codex-plugin-cc README)
• The codex CLI, either already installed or installed for you during setup.

If you already use Codex on this machine, you're done: the plugin reads your existing Codex CLI authentication and config rather than asking you to sign in again.

Install and first run

Adding a marketplace registers the catalog without installing anything; installing pulls the plugin itself. The repo publishes its marketplace under the name openai-codex, and the single plugin inside it is called codex, which is why the install target reads codex@openai-codex.

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex

Claude Code will ask which scope you want (Claude Code plugin docs).

• User scope follows you into every project.
• Project scope writes into the repo's .claude/settings.json, so collaborators get prompted to install it too.
• Local scope keeps it to this repository and you alone.

Team installs are easier from the shell, where the same commands take a --scope flag and skip the interactive panel:

$claude plugin install codex@openai-codex --scope project

Then reload and check your Codex side:

/reload-plugins
/codex:setup

If Codex isn't installed, setup offers to do it, or you can handle it yourself with npm install -g @openai/codex. If Codex is present but not signed in, run !codex login from inside Claude Code. A healthy install shows the codex: slash commands in /help and the codex:codex-rescue subagent in /agents.

A good first run is a backgrounded review, because reviews across several files aren't fast:

/codex:review --background
/codex:status
/codex:result

--background returns immediately with a job you poll rather than blocking the session. /codex:status lists the running jobs for this repository, and /codex:result prints the finished review once it's done. Both are covered again below, since they apply to every command that can run in the background.

The commands worth learning

Eight commands ship with the plugin, and they split into three jobs. (codex-plugin-cc README)

Review. /codex:review runs a read-only review of your uncommitted work, or of your branch against a base with --base main. It doesn't take custom focus text. /codex:adversarial-review does, and it's steerable: it questions the design and the tradeoffs rather than auditing the diff line by line. Both accept --wait and --background, and neither will change your code.

/codex:adversarial-review --base main challenge whether this was the right caching and retry design

Delegate. /codex:rescue hands a task to Codex through the codex-rescue subagent: investigating a bug, attempting a fix, or continuing a previous Codex thread. It takes --model and --effort, and defers to Codex's own defaults when you omit them. You can also just say "ask Codex to redesign the database connection to be more resilient" in plain language, since the subagent is written to pick up delegation requests on its own.

Manage. /codex:status, /codex:result, and /codex:cancel cover background jobs for the current repository. /codex:result also prints the Codex session ID, so you can reopen that exact run with codex resume <session-id> and keep working in Codex directly.

There's also /codex:transfer, which converts your current Claude Code conversation into a persistent Codex thread and prints the codex resume command to continue it. It reads your transcript through the plugin's SessionStart hook, and the source has to live under ~/.claude/projects.

When Codex earns its place

Reaching for a second model for everything is a good way to double your token spend and halve your throughput. Our take: this plugin is worth installing for adversarial review and for handoff, not as a general-purpose second brain.

Adversarial review is the strongest case. Asking the same model that wrote the code to critique it produces agreeable critique. A different vendor's model has no attachment to the approach, so /codex:adversarial-review before a risky merge (auth changes, migrations, anything with a rollback story) surfaces objections a same-session review tends to smooth over. The command exists specifically to pressure-test assumptions and alternative approaches rather than to lint.

Handoff is the second case. If a debugging session has gone long and you'd rather continue it in Codex, /codex:transfer moves the context instead of making you re-explain it. And /codex:rescue --background is genuinely useful for the "go investigate this flaky test while I do something else" shape of work.

What it doesn't replace: Claude Code's own tools, subagents, and MCP integrations. For most day-to-day work, the MCP servers you already run give Claude more leverage than a second model would, because they add information Claude lacks rather than a second opinion on information it already has.

Limits and gotchas

The review gate can run away with your usage. /codex:setup --enable-review-gate installs a Stop hook that fires a targeted Codex review whenever Claude finishes a response, and blocks the stop if the review finds issues. The README carries an explicit warning about this: it can create a long Claude/Codex loop and drain usage limits quickly, so only turn it on when you're watching the session. It's off by default, and leaving it off is the right call for most people. (codex-plugin-cc README)

Two sets of usage limits apply. Codex work bills against your ChatGPT or OpenAI API usage, not your Claude plan. A backgrounded adversarial review on a large branch is not free on either side.

Model and effort live in Codex's config, not Claude's. To change what the plugin defaults to, set model and model_reasoning_effort in ~/.codex/config.toml, or in a project-level .codex/config.toml at the root of the directory you started Claude in. Project-level overrides only load when the project is trusted (codex-plugin-cc README).

model = "gpt-5.4-mini"
model_reasoning_effort = "high"

Those two keys are what /codex:rescue --model and --effort override per invocation, so the config file is where you set the default you want most of the time.

Plugins execute arbitrary code. Anthropic's own guidance is that plugins and marketplaces are highly trusted components running with your user privileges, and that you should only add sources you trust. Being published under the openai organization is a reasonable basis for that trust here; the general rule still stands for everything else you install. (Claude Code plugin docs)

The commands sometimes don't show up. Run /reload-plugins first, and failing that, uninstall and reinstall. claude plugin details codex tells you what actually loaded, which separates a plugin that didn't register from a Codex binary that isn't signed in.

What stays yours to see

The zero-MCP-servers line in that component inventory marks a boundary. A plugin like this one is somebody else's code running on your machine, and it stays opaque to you by design; you get its commands, not its internals. An MCP server is the reverse. You run it, so its traffic is yours to read, and reading it is how you learn which tools people actually reach for and which ones they never touch. AgentCat is built for that half.