Why OpenAI Just Built a Bridge to Claude Code

The Announcement That Raised Eyebrows

On March 30, OpenAI’s VeitB posted a quiet announcement to the company’s developer forum: a new plugin that runs Codex inside Claude Code. The thread has since accumulated roughly 173,000 views and, notably, only twenty-seven likes. That view-to-engagement ratio suggests something more than product enthusiasm—call it curiosity, or perhaps confusion. OpenAI, after all, had just published an integration for Anthropic’s terminal agent, effectively treating Claude Code as a host operating system rather than a rival platform.

The repository, openai/codex-plugin-cc, does not pretend to be a standalone application. It is a thin orchestration layer that registers slash commands inside Claude Code for review, adversarial review, and task delegation, then hands the actual work to the local Codex CLI and Codex app server. It reuses whatever authentication, configuration, and environment the user already has for Codex. The architecture is deliberately lightweight: not a separate runtime, not an emulator, just a pipe between two agents that otherwise live in separate ecosystems.

Two Agents, One Terminal

To understand why this pipe matters, consider the structural differences between the two tools. Claude Code is local-first and interactive. It runs on the user’s machine, steps through execution with developer oversight, and offers approval gates for file writes and shell commands. OpenAI Codex, by contrast, runs in a cloud sandbox with an asynchronous, hand-off workflow: you delegate a task, it executes in an isolated container, and it returns a diff or pull request when finished. In head-to-head tests, Claude Code has proven faster for quick surgical fixes, while Codex is positioned for bulk changes, migrations, and CI integration.

The plugin does not try to collapse these differences. It exploits them. A developer can remain inside Claude’s interactive session—debugging a flaky test, tracing a dependency—while backgrounding a long-running Codex job to investigate the regression or redesign a database connection. Status and result commands let Claude act as the foreground orchestrator and Codex as the background worker. This is not merely having two tools installed. It is a workflow where one agent delegates to another and expects a structured handback, complete with session IDs that let you resume the Codex run directly in its native interface.

The Skeptical Review

The most conceptually interesting feature is the adversarial review mode. Unlike a standard read-only review, this mode is steerable and explicitly skeptical. It pressure-tests assumptions, questions tradeoffs, and probes failure modes—auth logic, race conditions, rollback strategies. You can feed it a specific concern, such as challenging whether a caching and retry design was the right call, and it will generate a critique from a different model family than the one currently hosting your session.

In a landscape crowded with AI review tools—CodeRabbit, Qodo, Greptile, and GitHub Copilot Code Review among them—this stands out because the reviewer is not a service but a second agent with a different training set and sandbox. The adversarial review is read-only by design; it does not fix code, it interrogates intent. That separation of concerns—Claude for execution, Codex for challenge—creates a checks-and-balances dynamic that a single monolithic agent cannot easily replicate.

The Community Was Already Here

OpenAI’s official entry into this space arrived after the community had already sketched the blueprint. The sendbird/cc-plugin-codex repository, public with 159 stars, functions as a similar bridge, managing model selection, reasoning effort, and review schemas for the Claude Code host CLI. Its commit history reveals the mechanical complexity of gluing two agent ecosystems together: handling friendly model aliases, resolving default reasoning effort per model tier, and adopting Claude-compatible review dialects. OpenAI’s version arrives with the institutional advantage of using the official Codex app server and the same open-source agent harness as the broader Codex ecosystem, but the use case—running multiple Codex tasks in parallel from inside Claude—was already validated by third-party developers.

That validation matters because the broader tooling landscape is consolidating around interoperability. The Nango project, for instance, packages API integration capabilities using Anthropic’s Agent Skills open standard—a format later adopted by OpenAI for Codex—enabling skills that work across Claude Code, Codex, Cursor, and other agents. When even integration infrastructure starts treating agent boundaries as implementation details, the plugin begins to look less like a novelty and more like infrastructure.

Friction and Future

The plugin is not without rough edges. Setup requires Node.js 18.18 or later, a local Codex installation, and an active ChatGPT subscription or OpenAI API key. The optional review gate feature, which uses a stop hook to run a targeted Codex review on Claude’s responses before allowing them through, carries an explicit warning: it can create long-running Claude-Codex loops and drain usage limits quickly. That caveat exposes the central tension of poly-agent workflows. Chaining large language models is computationally expensive, and without careful gating, the convenience of automation becomes a budget hazard.

Moreover, the plugin’s reception has been more spectated than celebrated. One hundred seventy-three thousand views with minimal likes suggests developers are watching to see what this symbolic gesture means rather than rushing to adopt it. The significance may be strategic rather than statistical. As one developer noted in discussion under the plugin’s announcement, the shift from isolated AI applications toward an interconnected intelligence layer could be more consequential than any single capability gain. The question being asked is not whether Codex can review code, but whether agents from competing labs can share a workspace.

The answer, for now, is cautiously affirmative. You can keep using Claude Code for messy refactors and machine-specific debugging, hand a bulk migration to Codex’s cloud sandbox, and let an adversarial review challenge the result—all without leaving your terminal. The plugin does not resolve the competition between OpenAI and Anthropic; it simply assumes that developers have already refused to choose sides.