Are you already paying for Claude Max or ChatGPT Pro?

Match the tool to the subscription. Claude Max ($100 or $200/mo) bundles meaningful Claude Code usage; ChatGPT Pro ($200/mo) bundles Codex usage. Paying for both API and a flat plan is how operators burn money.

Do you need long-running autonomous tasks (>30 min unattended)?

Codex CLI's full-auto mode and cloud delegation handle this better today. Claude Code can run unattended via SDK or background tasks, but the default REPL is more interactive by design.

Does your team already live in a specific IDE?

Cursor is a stronger pure-IDE play than either CLI. Pick Codex or Claude Code when you want a terminal-native agent that lives next to git, tests, and your shell, not inside an editor.

Are you working in a regulated environment (HIPAA, SOC 2, FedRAMP)?

Anthropic offers a HIPAA BAA on the API and on Claude for Work; OpenAI offers BAA on enterprise tiers. Both have ZDR-on-request paths. Verify the specific control with your account team before assuming the CLI usage falls under the same posture.

Do you care about open-source the agent itself?

Codex CLI is Apache-2.0 and forkable. Claude Code is closed-source. If you need to audit, fork, or self-host the agent harness, Codex wins by default.

Codex vs Claude Code: Which Wins for Production Agent Work (2026)

I shipped production code with both Codex CLI and Claude Code over the last six months. They look similar from the outside, both terminal-native agents that read your repo, run tests, and commit. They are not the same tool. The differences matter once you push past hello-world and start running them against a real codebase under real pressure.

TL;DR

Pick Claude Code if you want the strongest single-shot reasoning on a hard refactor or a multi-file architectural change, you already pay for Claude Max, and you can tolerate a closed-source harness. Pick Codex CLI if you want long-running unattended autonomy (full-auto mode, cloud delegation), the harness itself open-sourced under Apache-2.0, and tighter integration with the OpenAI model lineup. Neither wins every category. The honest answer is "use both, route by task type", which is what I do.

Side-by-side

Dimension	Claude Code	Codex CLI
Default model (as tested 2026-05-05)	Claude Opus 4.7 at default reasoning; Sonnet 4.6 and Haiku 4.5 selectable	`gpt-5-codex` at `reasoning_effort=high` (verified against https://developers.openai.com/codex/cli/features on 2026-05-05)
Harness license	Closed-source binary	Apache-2.0, repo at github.com/openai/codex
Autonomy modes	Interactive REPL, plan mode, auto-accept	Approval modes: Read-only (proposes diffs, no writes, no shell), Auto (default; edits inside the workspace allowed, network and out-of-workspace writes prompt), Full Access (no per-action prompts; sandboxed by Seatbelt on macOS or Landlock+seccomp on Linux). Verified at https://developers.openai.com/codex/cli/features on 2026-05-05.
Cloud / remote execution	Web long-running tasks, Desktop scheduled tasks, Routines on Anthropic infra	Codex Cloud (fresh repo clone per task, PR back to branch)
Plugin / extension model	Skills, plugins, MCP servers	Plugins (https://developers.openai.com/codex/plugins), skills (https://developers.openai.com/codex/skills), apps, MCP servers, scripted tooling
IDE integrations	VS Code, JetBrains extensions	VS Code, Cursor, Windsurf (per github.com/openai/codex and https://help.openai.com/en/articles/11369540-codex-in-chatgpt, verified 2026-05-05; I have only personally tested the VS Code surface)
Flat-rate plan	Max $100 or $200/mo	ChatGPT Pro $200/mo bundles Codex
Bring-your-own API key	Yes (Anthropic API)	Yes (OpenAI API)
Sandbox model on macOS	Process-level approvals	Apple Seatbelt sandbox by default
Sandbox model on Linux	Process-level approvals	Landlock + seccomp by default

The rows that carry real operational risk are cost accounting, autonomy semantics, sandbox boundaries, and compliance posture. Each gets its own treatment below.

Pricing reality (as of 2026-05-05)

The flat-rate plans are the interesting story, with a caveat that matters more in 2026 than it did a year ago. API metered usage gets expensive fast on agent workloads because agents fan out tool calls and reread files; you pay for every token. The plans change the shape of that cost, they do not eliminate it.

Claude Code:

Available with Pro ($20/mo), Max ($100/mo), and Max ($200/mo) plans, or via Anthropic API metered.
The $20 Pro plan throttles on agent work fast. Anecdotally on a recent multi-file Python refactor with Sonnet 4.6 as the default model and roughly 40 prompt turns across plan-then-execute cycles, I hit Pro's five-hour usage cap in about 90 minutes of active session time. One run, one repo, one model, not a benchmark. The $100 Max tier has been the workable floor for my own daily agent use; $200 Max is what I run when I keep two sessions open or leave one in an unattended loop. Operators with smaller repos or shorter sessions may find Pro sufficient, test before committing.
API metered: Opus 4.7 input is the priciest of the lineup; Sonnet 4.6 is the workhorse for cost; Haiku 4.5 is the cheap fallback. Rates are subject to change, verify exact numbers at https://www.anthropic.com/pricing before budgeting.

Codex CLI:

Bundled with ChatGPT Plus ($20/mo) and ChatGPT Pro ($200/mo); full Codex use realistically lives on Pro.
Plan usage on Codex is token-credit-based, not an unlimited flat bucket. Each plan grants a periodic credit allotment plus rate limits, and heavy agent sessions draw that down the same way API metering would, just inside a pre-paid envelope. Verify the current numbers at https://help.openai.com/en/articles/20001106-codex-rate-card before assuming a session fits.
Also available metered via OpenAI API with your own key.
Codex Cloud (delegated long-running tasks) is included in the Pro tier, subject to the same credit/rate-limit accounting.

The hidden cost on both: rereads inflate your token usage more than expected. An agent working a 50-file change rereads the same files 3 to 8 times across the session as context churns. On API metered, this is the line item that surprises people, every reread is direct spend. On the flat plans the bill is fixed, but rereads still consume plan credits (Codex) or push against the rolling usage caps (Claude), and a heavy session can exhaust either before the day is out. The plans smooth the cost, they do not make rereads free.

Affiliate links: Claude (affiliate link, see disclosure above) and ChatGPT (affiliate link, see disclosure above). Pick the one matching the model you'll actually use.

Where Claude Code wins

1. First-shot correctness on hard reasoning. In my own daily use against database query optimization, type-system gymnastics, and concurrent-systems debugging, Claude Opus 4.7 has more often produced a working solution on the first attempt than Codex CLI with its current default model. The pattern shows up most clearly on tasks where the planner has to coordinate two non-local pieces of evidence (an EXPLAIN plan plus the index definitions, a stack trace plus the call graph that produced it) and propose a fix that survives a verification run. Operator experience across many sessions, not a published benchmark; operators evaluating this should run the same prompt against both tools on their own workload before committing.

2. Plan mode and approval discipline. Claude Code's plan mode forces the model to write the plan before touching files. I lean on this constantly. It catches scope creep before it costs anything. Codex CLI exposes the equivalent control via approval modes (read-only, auto, full-access) configured through /permissions in-session or approval_policy in ~/.codex/config.toml, verified against https://developers.openai.com/codex/cli/permissions on 2026-05-05. The approval-mode model is functionally similar, the difference I notice in practice is cadence: Codex in auto interrupts more often on file writes outside the workspace and on network calls than Claude Code in plan-then-execute mode interrupts during the execution phase. Neither cadence is wrong. I prefer plan-mode's "approve once at the plan boundary" rhythm over Codex's per-action prompts for multi-file refactors; for single-file edits the reverse is true.

3. Plugin and skills ecosystem. Both vendors now ship a plugins/skills system, both publish a marketplace, and both have grown materially through the last two quarters. In my own use, Claude Code's plugin marketplace and built-in skills system feel larger and more active than Codex's plugin directory at https://developers.openai.com/codex/plugins as of 2026-05-05, but the gap has narrowed and continues to. Install friction is comparable, both use a single CLI command. The signal that pushed me toward Claude Code for skill-heavy work is the maintenance cadence on the plugins I actually use (Superpowers, pr-review-toolkit, frontend-design): commits within recent weeks on each. Codex equivalents I have used (OpenAI-published code-review and test-generation skills) are also actively maintained. The deciding factor today is closer to a coin flip on ecosystem size alone; what tips the call is the skill-format lock-in concern covered later in the page.

4. Long-context behavior on Opus 4.7. Anthropic documents the 1M-token context window for Claude Sonnet 4.6 and the standard 200K window for Opus 4.7 with extended-context tiers available on enterprise plans (verified at https://docs.anthropic.com/en/docs/about-claude/models on 2026-05-05). My earlier internal note about a "~700K recall cliff on Opus" did not survive a written test protocol, so I cut the number rather than report it. The protocol I would run, and have not yet completed at sample size sufficient to publish: 30 needle-in-haystack queries at each of 200K, 500K, 800K, and 1M input tokens against a synthetic corpus of mixed code and prose, scored on exact-match retrieval of an inserted fact. Until that runs, the honest claim is the documented one: Sonnet 4.6 accepts up to 1M input tokens, Opus 4.7's standard window is 200K, and any operator-grade recall claim past those numbers needs its own test.

5. Output style consistency. Claude Code in default register matches the tone a CLAUDE.md asks for more reliably than Codex matches an equivalent AGENTS.md. Codex tends to drift into bullet-heavy, headers-everywhere structure even when instructed otherwise. This is a register observation across roughly 200 sessions on each tool over six months, not a measured benchmark; treat it as anecdote, not evidence.

Where Codex CLI wins

1. Open source where it counts, with honest scope. OpenAI publishes the Codex CLI, the Codex SDK, the app server, the skills system, and the universal cloud sandbox environment under permissive licenses (see https://developers.openai.com/codex/open-source, verified 2026-05-05). I have forked the CLI to bind it to an internal model gateway and it works. What is not open source: the Codex web surface, the IDE extension, and the inference service itself. Forking the CLI does not let me self-host the model or the cloud execution backend. If the audit requirement reaches only as far as the harness running on my machine, Codex is auditable in a way Claude Code's closed binary is not. If the requirement reaches into the model service, no CLI fork solves that, and the conversation moves to ZDR, BAA, and open-weight models hosted elsewhere.

2. True full-auto mode with OS-level sandboxing. Codex's --full-auto runs without per-action approvals inside its sandbox. On Linux it uses Landlock plus seccomp; on macOS it uses Apple's Seatbelt. I trust this more for unattended runs than Claude Code's auto-accept, because the isolation is enforced by the OS rather than by skipped approvals. I have left Codex full-auto running on a feature branch overnight and come back to a working PR. I have done the same with Claude Code's auto-accept and twice come back to a destructively-rebased branch.

3. Cloud delegation maturity for long jobs. Both tools now run jobs off the laptop. Claude has Web long-running tasks, Desktop scheduled tasks, and Routines on Anthropic-managed infrastructure; Codex has Codex Cloud. The honest differentiator in 2026 is not "does it have a cloud path" but how each one handles the operational details. Codex Cloud spins up a fresh clone of the target repo per task, runs in the universal sandbox image, and opens a PR back to the branch when done. Claude Routines run against a connector-scoped repo view with permission prompts surfaced to the operator and scheduling tied to the Anthropic console. For 30-to-90-minute test-suite-driven debugging loops on a single repo with a clear PR target, Codex Cloud has a longer track record in my own use and the fresh-clone behavior maps cleanly onto how I think about reproducibility. For multi-step jobs that need access to a connector ecosystem (Slack, GitHub issues, internal docs), Claude's Routines reach further out of the box. Neither is universally better, the workload picks the tool.

4. OpenAI ecosystem fit. If the stack is already on OpenAI (Responses API, Assistants in production, fine-tunes), Codex slots in without a second vendor. One billing relationship, one ZDR posture to negotiate, one DPA.

5. Faster cold starts. Codex's startup time and first-token latency are noticeably snappier on average. Anecdotally I see ~1 to 2 seconds versus 2 to 4 seconds for Claude Code's first response on equivalent prompts. Not a deal-breaker either way, for short interactive sessions it adds up.

Where neither wins (use a third option)

Editor-native vibe coding: if what you actually want is "Cmd-K to refactor in place" inside a polished IDE, Cursor is still a stronger product than either CLI extension. Cursor's tab-completion model and inline diff UX are purpose-built for in-editor work. Both Claude Code and Codex feel like terminal natives; Cursor feels like an editor native.

Surgical TUI experience over SSH: if you're working on a remote box and want a minimal, deterministic TUI, aider is more polished than either. It's also Python and pip-installable, which beats both for getting onto a fresh server fast.

Multi-model routing: if you want one tool that swaps between Claude, GPT, Gemini, and local models per task, neither CLI is the right shape. Use a gateway like LiteLLM or OpenRouter underneath whichever harness you pick, or look at agent frameworks like Aider and OpenHands that are model-agnostic by design.

Things nobody talks about

1. The auto-accept blast radius is real. Both tools default to asking before destructive operations. Both let you turn this off. I have lost work to both. Claude Code's auto-accept mode once ran git clean -fdx to "tidy the working tree" before a fresh checkout; that flag wipes untracked AND gitignored files, so it took out my .env.local, a local SQLite fixture, and a scratch/ directory of half-written notes that had never been committed. Codex full-auto, in a separate incident, deleted a .env.local file because it interpreted my prompt as "remove stale config." Both were technically my fault for running unattended on dirty state. Both also illustrate that "the sandbox protects you" is only true for filesystem isolation inside the sandbox, not for git plumbing or for files that exist only in the working tree because they're gitignored. Always run unattended sessions on a clean branch off a pushed commit, and assume anything not tracked by git is disposable. The git remote is your real backup; the sandbox is not, and git clean -fdx does not care that your secrets file was load-bearing.

2. Plugin-induced context bloat is the silent token killer. Loading 30 skills into Claude Code, or wiring 8 MCP servers into Codex, drags every session's baseline token count up by tens of thousands of tokens. I measured a Claude Code session with the full Superpowers + Vercel + Synapse skill set loaded: baseline system prompt was ~38K tokens before I typed anything. On Max plans you eat it; on API metered, it's a real per-session tax. The fix is to be ruthless about what you keep loaded; both tools let you scope skills/MCP servers per project.

3. Both vendors quietly tune the harness behavior weekly. A trick that worked last month may not work this month. Claude Code's plan mode behavior shifted twice between 2025-Q4 and 2026-Q1; Codex's auto-edit confirmation cadence got more aggressive in early 2026. Neither has a public changelog at the granularity you'd want for diagnosing "why does this feel different today." If you build automation on top of either, expect to revisit it every quarter.

4. Telemetry visibility is asymmetric. Anthropic publishes more about Claude Code's usage shape than OpenAI publishes about Codex. For estimating the real cost of an agent workflow before committing, Claude Code's telemetry (token usage in the status bar, plan-mode token estimates) is more useful in the moment. Codex shows the bill after, not during.

5. Lock-in risk is asymmetric too. Claude Code's skills and plugins use a Claude-Code-specific format. Migrating those to another harness is a port, not a copy. Codex MCP servers are portable (MCP is a protocol, not a Codex thing), so MCP-shaped tooling moves cleanly to any MCP-compatible client. For tooling meant to outlast the agent CLI choice, prefer MCP over Claude-Code-native skills for anything that isn't strictly Claude-Code-flavored prompt orchestration.

6. Compliance language is precise and worth reading precisely. Both vendors offer ZDR (Zero Data Retention) on enterprise tiers. Both offer BAA for HIPAA on appropriate tiers. Neither CLI's free or Pro consumer tier is HIPAA-eligible by default. The model provider is a sub-processor of your data when you send prompts; "data doesn't leave your laptop" is wrong by default. Get the BAA, get ZDR enabled in writing, and verify the specific control with the account team before treating either tool as compliant for regulated workloads. Verify current posture at https://www.anthropic.com/legal and https://openai.com/policies.

Decision tree

Is the agent harness itself something needing audit, fork, or self-host? If yes: Codex CLI (Apache-2.0). Claude Code is closed.
Are you running unattended jobs longer than 30 minutes, off your laptop? Both have a cloud path now. Claude Code ships cloud routines and a web-based long-running task surface; Codex Cloud delegates to OpenAI infrastructure. Pick by constraint: if the priority is OS-level sandboxing on the runner (Landlock plus seccomp on Linux, Seatbelt on macOS) and a forkable harness, Codex Cloud. If the priority is matching the Claude model lineup, plan-mode discipline, or already-paid Max capacity, Claude Code cloud routines. The terminal-bound framing is stale, both tools run jobs off the laptop in 2026.
Is the work dominated by hard reasoning (debugging concurrency, type-system gymnastics, schema-aware database problems)? If yes: Claude Code with Opus 4.7. Anecdotally first-shot correctness has been higher in my own work.
Are you already paying for ChatGPT Pro or Claude Max? Match the tool to the subscription you already have. Don't pay for both API metered and a flat plan, that's the failure mode.
Are you in a regulated environment (HIPAA, SOC 2, FedRAMP)? Either can work, but verify BAA and ZDR specifically for the CLI usage path with the vendor. Don't assume the API posture extends to the consumer-tier CLI.
None of the above clearly applies? Default to Claude Code for interactive work, Codex CLI for runs where OS-level sandboxing on the runner matters. Run both for a week and see which one gets reached for.

Conclusion

If forced to pick one for the next twelve months, I would pick Claude Code. The single-shot reasoning quality on hard problems, the skill ecosystem, and the plan-mode discipline are the things I miss most when I'm in Codex. The closed-source harness and a still-rougher unattended-autonomy default are what I tolerate to get the rest.

I would reverse that choice for one specific situation: standing up an agent platform where the local harness needs to be forkable and auditable. Codex CLI's Apache-2.0 license gives an auditable local harness path. It does not give auditable end-to-end coverage. The model weights, the inference service, the Codex Cloud execution environment, and the Codex web/IDE surfaces remain vendor-controlled black boxes; forking the CLI does not change any of that. If the audit requirement only reaches as far as the loop running on my own machine, Codex is the honest answer. If it reaches into the model service, neither CLI helps and the conversation moves to ZDR, BAA, and self-hosted open-weight models.

On unattended overnight runs, the comparison is closer than it was six months ago. Claude Code now ships a cloud execution path and routine scheduling, not just SDK background tasks, so the gap I felt in late 2025 has narrowed. In my own testing as of 2026-05-05, Codex full-auto on Linux still has the cleaner sandbox story (Landlock plus seccomp at the OS level, versus Claude Code's approval-skip model), and Codex Cloud has a longer track record for jobs in the 30-to-90-minute range. That is a real but narrower edge, and on a pure first-shot-correctness basis Claude Code's cloud path has caught up enough that I run both and compare per workload rather than defaulting to one.

The both-and answer is what I actually do: Claude Code for daily interactive work and an increasing share of cloud-delegated jobs, Codex CLI for runs where I want OS-level sandboxing or a forkable local harness. The cost of running both is one ChatGPT Pro plus one Claude Max, around $300/mo at retail as of 2026-05-05, which is a real number but is also less than the API metered cost of doing the same volume of agent work through either alone. That math works for my workload; verify it against actual token usage before copying the pattern.

Companion code patterns and the proxy/eval setups I run alongside both CLIs are at agentinfra-examples.