Stop Switching Terminals! Run OpenAI Codex Inside Claude Code

Stop Switching Terminals! Run OpenAI Codex Inside Claude Code

What if the biggest bottleneck in your development workflow isn't your code—it's the constant context switching between your AI assistants? Here's the brutal truth most developers won't admit: they've got Claude Code open in one pane, OpenAI Codex running in another terminal, and their actual IDE somewhere in the background. Three contexts. Three mental models. Zero flow state.

Sound painfully familiar?

You're deep in a complex refactor with Claude Code, you hit a wall, and you know Codex would crush this specific review or bug hunt. But that means stopping, opening a new terminal, losing your thread, and praying you remember the exact state of your working directory. The friction is so subtle you barely notice it—until you realize you've burned twenty minutes just orchestrating your tools instead of shipping code.

That friction just died.

Enter openai/codex-plugin-cc—the bridge that lets you summon OpenAI Codex's full power without ever leaving Claude Code. Code reviews that challenge your assumptions. Background task delegation that keeps working while you think. A unified workflow where Claude's conversational brilliance meets Codex's surgical precision. No terminal juggling. No lost context. Just pure, uninterrupted momentum.

This isn't another plugin announcement. This is a workflow revolution hiding in plain sight. And if you're still alt-tabbing between AI tools, you're about to feel very silly.

What is openai/codex-plugin-cc?

openai/codex-plugin-cc is an official plugin from OpenAI that embeds Codex capabilities directly into Claude Code's interface. Built for developers who've already invested in Anthropic's terminal-based coding assistant, it eliminates the architectural barrier between two of the most powerful AI coding tools on the planet.

The repository lives at github.com/openai/codex-plugin-cc and represents something rare in the AI tooling space: genuine interoperability. OpenAI didn't just expose an API and call it integration. They built a native plugin that speaks Claude Code's protocol, registers slash commands in Claude's namespace, and even surfaces Codex work as a subagent you can invoke conversationally.

Why is this trending now? Three converging forces. First, Codex has evolved from autocomplete into a full autonomous coding agent capable of multi-file reasoning, test generation, and extended background tasks. Second, Claude Code has become the preferred terminal interface for developers who value natural language interaction and deep codebase understanding. Third—and most critically—developers are exhausted by tool fragmentation and hungry for consolidation without compromise.

The plugin's genius is architectural simplicity. It wraps your local Codex CLI installation, uses your existing authentication, respects your existing configuration, and delegates through the same Codex app server you'd run manually. Nothing duplicated. Nothing sandboxed away. It's not a separate Codex runtime pretending to integrate—it's your Codex, accessible through Claude's interface.

For teams already standardizing on Claude Code, this means individual developers can augment with Codex's strengths without forcing workflow changes on colleagues. For solo developers, it means finally getting the "best of both worlds" without the "worst of both interfaces."

Key Features That Transform Your Workflow

The plugin registers seven slash commands and one subagent, each solving a distinct developer pain point. Let's dissect what makes them powerful.

/codex:review delivers standard Codex code review quality directly in your Claude session. It examines uncommitted changes or branch diffs with the same rigor as running /review inside Codex natively. The critical insight: multi-file reviews can run long, so the --background flag lets you fire it and forget it, checking results when convenient.

/codex:adversarial-review is where things get spicy. Unlike standard review, this is steerable—you can direct Codex to pressure-test specific assumptions, challenge design choices, or hunt for failure modes in sensitive domains like authentication, data loss scenarios, or race conditions. The extra focus text parameter means you're not getting generic feedback; you're getting targeted intellectual combat.

/codex:rescue delegates actual work through the codex:codex-rescue subagent. Bug investigation, test fixes, continuing previous Codex sessions, or even running cheaper/faster passes with smaller models. The --resume and --fresh flags handle session continuity intelligently.

Background job management (/codex:status, /codex:result, /codex:cancel) completes the async story. Start work, walk away, check progress, retrieve results, or abort if priorities shift. This isn't "run and hope"—it's genuine distributed task management.

/codex:setup handles onboarding friction. Detects Codex installation, offers to install via npm if missing, manages authentication, and even configures an optional review gate that intercepts Claude's responses with automatic Codex review—blocking continuation if issues surface.

The configuration system respects Codex's standard TOML hierarchy: user-level ~/.codex/config.toml for defaults, project-level .codex/config.toml for overrides. Set your preferred model and reasoning effort once, apply everywhere.

Real-World Use Cases Where This Shines

The Pre-Ship Sanity Check

You're about to merge a three-day feature branch. Your own tests pass. Claude helped you architect it. But something feels... off. Instead of context-switching to Codex or gambling on your own review stamina:

/codex:review --base main --background

Come back in ten minutes to Codex's unflinching assessment of edge cases you missed, performance implications you rationalized away, and error paths you never tested.

The Design Decision Inquisition

That caching layer you built? The retry policy? You're pretty sure it's right. But "pretty sure" doesn't ship to production. Time for intellectual combat:

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

Codex will argue against your choices, surface alternatives, and force you to defend or improve. This isn't validation-seeking—it's deliberate disconfirmation of your own confidence.

The Flaky Test That Haunts CI

It's 4 PM. The integration test fails randomly. You've stared at it too long. Delegate without derailing your evening:

/codex:rescue --background --model gpt-5.4-mini --effort high investigate the flaky integration test
/codex:status  # check before you leave
/codex:result  # review findings tomorrow morning

The Production Incident Handoff

Pager fires. You're investigating with Claude, but the root cause is elusive and you need parallel exploration:

/codex:rescue investigate why the build is failing in CI

While Claude helps you trace logs and metrics, Codex independently examines code paths, recent changes, and dependency updates. Two AI agents, one human conductor, zero context loss.

The Review Gate for Critical Paths

Enable automatic interception for security-sensitive work:

/codex:setup --enable-review-gate

Now every Claude response in authenticated flows gets automatic Codex review. Issues block continuation until addressed. Warning: this can create extended Claude/Codex loops—enable only when actively monitoring.

Step-by-Step Installation & Setup Guide

Prerequisites first. You'll need Node.js 18.18 or later installed. Your Codex usage counts against your existing limits—either through a ChatGPT subscription (including Free tier) or an OpenAI API key.

Step 1: Add the marketplace source to Claude Code

/plugin marketplace add openai/codex-plugin-cc

This registers OpenAI's plugin repository in Claude Code's marketplace index, making the plugin discoverable for installation.

Step 2: Install the plugin itself

/plugin install codex@openai-codex

The @openai-codex namespace distinguishes this official plugin from any community alternatives.

Step 3: Reload Claude Code's plugin system

/reload-plugins

This hot-reloads the plugin registry without restarting your Claude Code session.

Step 4: Run setup verification and configuration

/codex:setup

This diagnostic command checks multiple things in sequence: whether the codex binary exists in your PATH, whether you're authenticated with OpenAI, and whether npm is available for automatic installation if Codex is missing.

If Codex isn't installed, /codex:setup will offer to run:

npm install -g @openai/codex

If Codex is installed but authentication is missing, run:

!codex login

The ! prefix executes the command in your underlying shell rather than as a Claude Code directive.

Step 5: Verify successful installation

After setup completes, you should observe:

• All /codex:* slash commands available in tab completion
• The codex:codex-rescue subagent listed in /agents

Quick validation run:

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

This fires a background review, checks its status, and retrieves results—confirming the full async pipeline works.

REAL Code Examples from the Repository

Let's examine actual patterns from the openai/codex-plugin-cc README, with detailed explanations of what each achieves and when to deploy it.

Example 1: Basic Review with Branch Comparison

/codex:review --base main

Before: You've been working on a feature branch for days. Your git diff is intimidatingly large. Self-review is compromised by familiarity—your brain fills in gaps because it knows your intent.

What happens: Codex receives your entire branch diff against main and applies its review heuristics. Unlike line-by-line human review, Codex reasons across files, tracking how changes in your data layer propagate to API contracts, how error handling in new code interacts with existing catch blocks, whether your migrations are backwards-compatible.

After: You receive structured feedback on architectural consistency, not just syntax. The --base main parameter is crucial—without it, Codex only sees uncommitted changes, missing the broader context of your branch evolution.

Example 2: Steerable Adversarial Review

/codex:adversarial-review --background look for race conditions and question the chosen approach

Before: You've implemented a distributed lock for your microservice deployment. You're proud of the Redis-based solution. Pride is dangerous before production.

What happens: The --background flag delegates this to async execution so you can keep working. The trailing focus text look for race conditions and question the chosen approach is the steering mechanism—this isn't generic review, it's directed skepticism. Codex will specifically probe: What happens if Redis fails between lock acquisition and operation? Is your lock TTL shorter than your maximum operation time? Did you consider lease-based alternatives? What about the thundering herd on lock release?

After: You receive a structured argument against your implementation, potentially with alternative patterns like etcd leases or database advisory locks. The adversarial framing triggers Codex's more critical reasoning mode.

Example 3: Delegated Investigation with Model Selection

/codex:rescue --model gpt-5.4-mini --effort medium investigate the flaky integration test

Before: Your integration test fails 12% of the time in CI, never locally. You've spent two hours on it. Time to escalate—to an agent that doesn't get frustrated.

What happens: The --model gpt-5.4-mini selects a smaller, faster model appropriate for investigation rather than heavy generation. --effort medium balances thoroughness against speed. The natural language task description investigate the flaky integration test gets parsed by Codex's intent system.

Codex will: examine test files for timing dependencies, check for shared state between tests, look for network mocks that might race, analyze CI environment differences from local setup, and suggest diagnostic additions like retry logging or deterministic ordering.

After: You receive findings and likely a proposed fix or further diagnostic steps. The --effort medium means you might need to iterate, but you got rapid initial intelligence cheaply.

Example 4: Session Continuation Pattern

/codex:rescue --resume apply the top fix from the last run

Before: Your previous /codex:rescue identified three potential fixes for a bug. You chose to sleep on it. Now you're ready to act.

What happens: The --resume flag signals Codex to load the previous rescue thread for this repository, maintaining full conversation and investigation context. The new directive apply the top fix from the last run operates on Codex's prior ranked recommendations.

After: Codex implements the fix with awareness of why it was ranked first, what alternatives were considered, and what risks were identified. No context recreation, no re-explaining the problem.

Example 5: Configuration Override for Project Defaults

# .codex/config.toml at project root
model = "gpt-5.4-mini"
model_reasoning_effort = "high"

Before: Your team wants consistent Codex behavior across all developers using the plugin, without everyone maintaining personal configs.

What happens: This project-level TOML overrides user defaults when the project is trusted. All /codex:* commands in this directory tree automatically use gpt-5.4-mini with high reasoning effort.

Critical security note: Project-level configs only load when explicitly trusted, preventing malicious repositories from hijacking your Codex execution with unexpected model choices or—worse—redirected endpoints.

Advanced Usage & Best Practices

Master the background economy. Almost every command supports --background, and you should default to it for anything non-trivial. The status/result/cancel trio gives you full control without blocking your Claude session. Think of it like Unix job control: fire, monitor, retrieve.

Chain adversarial and standard reviews. Run /codex:review for catch-the-obvious, then /codex:adversarial-review with specific focus for deeper challenge. Two passes, two mental models, dramatically different failure mode coverage.

Use model selection strategically. The README documents that spark maps to gpt-5.3-codex-spark—a faster, cheaper variant. For investigation and scoping, prefer smaller models. For implementation and complex generation, default or larger models. The --effort flag provides additional granularity.

Resume deliberately, not desperately. The --resume vs --fresh distinction matters. Resume when continuing coherent work. Fresh when previous context might mislead—like when a bug's root cause turned out to be different than initially suspected.

Monitor the review gate's cost. The --enable-review-gate feature is powerful but dangerous—every Claude response triggers Codex review, potentially creating expensive loops. Enable for focused security reviews, not general development.

Migrate to native Codex when needed. The codex resume <session-id> pattern lets you take any delegated task from Claude into full Codex for extended work. The plugin isn't a walled garden—it's a gateway.

Comparison with Alternatives

The plugin wins decisively on integration depth and workflow friction. Manual Codex CLI offers identical capabilities but punishes you with context destruction. Claude Code alone lacks Codex's specific strengths. Generic API integrations demand maintenance you didn't budget for.

FAQ

Do I need a separate Codex subscription? No. Your existing ChatGPT subscription (including Free tier) or OpenAI API key covers Codex usage. The plugin consumes the same quota as direct Codex use. Run /codex:setup to verify your authentication state.

Does this run Codex in the cloud or locally? Locally. The plugin delegates through your installed Codex CLI and local app server. Same machine, same repository checkout, same environment variables. It's your Codex, just accessed through Claude's interface.

Can I use my existing Codex configuration? Absolutely. The plugin reads ~/.codex/config.toml for user defaults and .codex/config.toml for project overrides. All your existing model preferences, custom endpoints, and reasoning effort settings apply immediately.

What happens if a background job fails? /codex:status shows job states including failures. /codex:result retrieves available output even from incomplete runs, often with enough context to diagnose. For catastrophic failures, check your Codex session directly with codex resume <session-id>.

Is the review gate safe for CI/CD? No—the review gate is designed for interactive Claude Code sessions only. The potential for extended Claude/Codex loops makes it unsuitable for automated pipelines. Use it for manual security reviews with active human monitoring.

Can I delegate to Codex without slash commands? Yes. Natural language delegation works: "Ask Codex to redesign the database connection to be more resilient." The plugin interprets and routes appropriately.

What Node.js version is required? Node.js 18.18 or later. This ensures compatibility with the Codex CLI's dependency tree and modern JavaScript^{↗ Bright Coding Blog} features used in the plugin's implementation.

Conclusion

The openai/codex-plugin-cc isn't merely convenient—it's a statement about the future of AI-assisted development. The era of monolithic tool loyalty is ending. The winners will be developers who orchestrate multiple specialized agents through unified interfaces, preserving context and momentum.

This plugin executes that vision with surprising elegance. No abstraction layers that leak. No configuration duplications that drift. Just your existing Claude Code workflow, now supercharged with Codex's autonomous capabilities when you need them, invisible when you don't.

The cost of adoption is minutes. The cost of not adopting is the accumulated friction of thousands of context switches, the missed insights from reviews you were too busy to run, the bugs that adversarial review would have caught.

Your terminal is already open. Claude Code is already running. Install the plugin, run /codex:setup, and experience what uninterrupted development flow actually feels like. The future isn't choosing between Claude and Codex. It's never having to choose at all.