# OpenAI ships Codex into Claude Code — two commands, or four?

> Source: <https://dev.to/creeta/openai-ships-codex-into-claude-code-two-commands-or-four-c7l>
> Published: 2026-07-22 03:53:41+00:00

A rare thing happened on March 30, 2026: OpenAI shipped first-party tooling straight into a competitor's terminal. The result is `codex-plugin-cc`

, and it changes how a two-agent workflow fits in one window.

`codex-plugin-cc`

is an official OpenAI plugin that runs the Codex coding agent from inside Anthropic's Claude Code CLI. It lives at [openai/codex-plugin-cc](https://github.com/openai/codex-plugin-cc), is Apache-2.0 licensed, and is effectively pure JavaScript . The notable part is the direction of travel — a frontier-model vendor packaging tooling for a rival's ecosystem.

It is not a new runtime. As OpenAI puts it in its developer-forum announcement:

"It is not a separate runtime. It is Codex, just invoked from inside Claude Code." — OpenAI (source:

[OpenAI Developer Community])

The plugin delegates to the Codex CLI and app server already installed on your machine, reusing your existing auth and configuration . Maintenance is active: `v1.0.0`

landed March 30, 2026, and the current `v1.0.6`

shipped July 8, 2026 — six patch releases in four months . This is the same Codex agent that hit more than 5 million weekly users by June 2026 , surfaced in a different terminal.

The prerequisites are modest but specific. You need Node.js 18.18.0 or later — this is a hard engine constraint declared in the plugin's `package.json`

(`engines: ">=18.18.0"`

), not an advisory floor, so an older runtime will refuse to install . On the account side, either a ChatGPT subscription — the free tier qualifies — or an OpenAI API key unlocks Codex .

Auth is inherited, not re-entered. If you are already logged into Codex locally, the plugin reuses that state automatically — no second login . No Codex installed yet? `/codex:setup`

can offer to run `npm install -g @openai/codex`

when npm is present, or you can run that command manually first .

The full official path is four slash commands run inside an active Claude Code session, not the two the viral clip advertises . Work through them in order:

`/plugin marketplace add openai/codex-plugin-cc`

`/plugin install codex@openai-codex`

`codex`

, the marketplace is `openai-codex`

, which is why the reference reads `codex@openai-codex`

.`/reload-plugins`

`/codex:*`

skills never surface, and the `codex:codex-rescue`

subagent stays absent from `/agents`

.`/codex:setup`

`npm install -g @openai/codex`

; if Codex is present but not logged in, it prompts you to run `!codex login`

from Claude Code .Verify before you rely on it: once `/codex:setup`

completes without complaint, `/codex:review`

should respond, and the `codex:codex-rescue`

subagent should be visible in `/agents`

. If either is missing, re-run `/reload-plugins`

— a skipped reload is the most common reason the command surface fails to appear.

The viral "two commands, 30 seconds" pitch covers only the marketplace add and the plugin install — steps 1 and 2. Skip `/reload-plugins`

and the plugin is registered but dormant: its `/codex:*`

slash commands never load into the running session, so nothing appears to work . Skip `/codex:setup`

and the plugin never checks whether Codex is installed and authenticated — the failure is silent rather than a readable error, which is the worst kind to debug .

Two behaviors deserve caution before you lean on this in real work:

`Stop`

hook to fire Codex on every Claude response. OpenAI and practitioners warn this can spin up a sustained Claude/Codex loop that drains usage limits fast — treat it as optional, not a default .Keep it current, too. `v1.0.6`

, released July 8, 2026, removed shell expansion for git commands — a correctness and security fix for a plugin that shells out inside your repo. Earlier builds carried Windows-compatibility and app-server readiness regressions, so pin a recent version .

After `/codex:setup`

completes, the plugin exposes a focused set of `/codex:*`

slash commands plus a `codex:codex-rescue`

subagent visible in `/agents`

. This is a command surface, not a general orchestration runtime — each command maps to one Codex action against your local checkout.

| Command | What it does | Key flags |
|---|---|---|
`/codex:review` |
Read-only Codex review of uncommitted changes or a branch diff |
`--base` , `--wait` , `--background`
|
`/codex:adversarial-review` |
Same target selection, but a skeptical pass that questions design decisions and assumptions, not just bugs |
`--base` + optional focus text |
`/codex:rescue` |
Delegates investigation or a fix to the `codex:codex-rescue` subagent |
`--model` (`spark` → `gpt-5.3-codex-spark` ), `--resume` , `--fresh` , `--effort`
|
`/codex:transfer` |
Hands the active Claude Code session into a persistent Codex thread for longer delegation (added in v1.0.5) | — |
`/codex:status` · `/codex:result` · `/codex:cancel`
|
Manage background jobs | — |

One practical habit: before you lean on a blocking `--wait`

, run background jobs and poll them with `/codex:status`

and `/codex:result`

, cancelling with `/codex:cancel`

— `--wait`

ties up your terminal until Codex returns . The concrete takeaway: install a pinned recent build, run `/codex:review`

once to confirm the subagent responds, then wire the review commands into your ship checklist — you now have Claude planning and Codex reviewing in a single terminal .

No. A ChatGPT free-tier account qualifies, and an OpenAI API key works as well . The plugin does not maintain its own credentials — it reuses whatever authentication your local Codex install already holds. If you are already logged into Codex on the machine, that auth is picked up automatically; if not, run `!codex login`

from Claude Code once and you are set.

No. Codex usage counts against your Codex limits, and Claude usage against Claude's — there is no shared quota, no cross-account auth, and no linked billing . The plugin is a convenience bridge that invokes your locally installed Codex CLI and app server; it does not prove the two agents share context, accounts, or permissions. Watch the optional "review gate" in particular, since a Claude/Codex loop can drain Codex limits fast.

You most likely stopped at the two install commands and skipped `/reload-plugins`

. Adding the marketplace and installing the plugin registers it, but the running session has not yet loaded the new skills. Run `/reload-plugins`

, then `/codex:setup`

, and the `/codex:*`

slash commands plus the `codex:codex-rescue`

subagent will show up in `/agents`

. This is why the "two-command" framing is really four.

`/codex:review`

runs a standard, read-only Codex pass over uncommitted changes or a branch diff against a base ref such as `main`

, supporting `--base`

, `--wait`

, and `--background`

. `/codex:adversarial-review`

runs a steerable, skeptical pass that actively questions design decisions and assumptions, using the same target selection plus optional focus text. Reach for the adversarial pass when you want a pre-merge second opinion, not a routine change summary.

No. `openai/openai-developers-for-claude`

is a separate plugin that bundles a Docs MCP server and API-setup skills, while `openai/codex-plugin-cc`

exposes the Codex coding agent itself . They live in different repositories and serve different purposes; installing one does not give you the other. If your goal is code review and task delegation, `codex-plugin-cc`

is the one you want.
