Last updated: June 2026. Benchmarks and pricing reflect the post-April 2026 reset.
TL;DR
OpenAI Codex CLI is open-source, cloud-native, sandboxed per task, and roughly 10x cheaper for a typical refactor. Claude Code is proprietary, local-first, ships an aggressive plugin and sub-agent ecosystem, and wins blind quality reviews about two-thirds of the time. Pick Codex for cost-efficient, isolated tasks you want to fire-and-forget. Pick Claude Code for coordinated multi-file refactors where output quality matters more than the bill. Both top SWE-bench within 0.1 points of each other, so model capability is no longer the deciding factor.
What are Codex CLI and Claude Code?
Both are agentic coding CLIs. You type a goal in plain English, the agent reads your codebase, runs commands, edits files, executes tests, and iterates. They look similar at the surface and diverge sharply once you actually use them.
OpenAI Codex CLI is the rebuilt 2026 version of Codex. Apache-2.0 licensed, written in Rust, available on GitHub at openai/codex with 91,000+ stars. It runs locally on macOS, Linux, and Windows, but its design center is async cloud delegation: spin up a sandboxed container, hand it a task, walk away.
Claude Code is Anthropic’s proprietary CLI. 132,000+ GitHub stars even though only the wrapper layer is open. It ships as a terminal CLI, VS Code extension, JetBrains plugin, desktop app for macOS and Windows, web surface at claude.ai/code, an SDK for TypeScript and Python, a GitHub Action, and a GitHub App. The CLI is the reference implementation; everything else is a different skin on the same agent loop.
The architectural divergence is the first thing that actually matters.
Architecture: cloud-native vs local-first
Codex defaults to spinning up an ephemeral sandboxed container per task. You can run it purely locally, but the optimized path is “delegate a task, let it execute in isolation, get the diff back.” The 2026 release added the /goal command, which schedules future work and lets Codex wake up automatically to continue on long-running tasks across days or weeks. Combined with cross-session memories, it handles persistent workflows in a way no local-first agent does cleanly.
Claude Code lives in your terminal, against your real working directory, with your real shell. It can launch sub-agents (separate Claude sessions through the Task tool with isolated context windows) for parallel work, but the orchestrator stays in your shell, in your repo, watching files change in real time. This is the right model when subtasks have dependencies on each other and the work is too coupled to fan out to independent containers.
If you have written non-trivial code with both, the difference is felt instantly. Codex feels like dispatching a remote contractor. Claude Code feels like pair-programming with someone sitting at your machine.
Pricing in 2026
After the April 2026 pricing reset, the headline tiers line up almost identically. The real cost difference shows up in what you can actually do at each tier.
| Tier | Codex CLI (OpenAI) | Claude Code (Anthropic) |
|---|---|---|
| Entry | ChatGPT Plus, $20/mo | Claude Pro, $20/mo |
| Mid | ChatGPT Pro, $200/mo | Claude Max, $100/mo |
| High | Pro tier with priority | Claude Max, $200/mo |
| Team | Team / Enterprise (custom) | Team Premium, $100/seat |
| API | Pay-per-token via OpenAI API | Pay-per-token via Anthropic API |
What the table does not show: the $20/mo Claude Code Pro plan hits rate limits in a few hours of real agentic work on a serious refactor. Anyone doing daily professional AI-assisted coding ends up on Max at $100 or $200. Codex on $20/mo ChatGPT Plus is similarly constrained for sustained agentic use.
For one-shot cost comparison, a documented end-to-end Express.js refactor came in at around $15 on Codex and roughly $155 on Claude Code. Ten times the cost. Same task, similar quality, very different invoice.
Performance: SWE-bench, Terminal-Bench, and blind reviews
The most-cited coding benchmark in 2026 is SWE-bench Verified. Current scores:
| Benchmark | GPT-5.5 (Codex) | Claude Opus 4.8 (Claude Code) | Notes |
|---|---|---|---|
| SWE-bench Verified | 88.7% | 88.6% | Statistical tie |
| Terminal-Bench 2.0 | Leads | Behind | Codex advantage on shell-heavy tasks |
| Blind quality review (Express.js refactor) | 33% | 67% | Reviewers preferred Claude’s output 2-to-1 |
Two things to take from this. First, the model layer is no longer the deciding factor; both are essentially equal on the standard benchmark. Second, benchmarks lie about taste. The same task produced output that reviewers preferred from Claude two times out of three. That gap is what you are buying with the 10x price premium, and whether it is worth it depends on what the code is for. For internal tooling, throwaway scripts, or one-off refactors, almost certainly not. For production code you will read in two years, possibly yes.
When Codex CLI wins
- Greenfield, isolated tasks. “Build me a CRUD admin for this schema.” No dependencies on existing code. Codex’s sandbox model shines.
- Fire-and-forget delegation. Hand it a ticket, walk away, review the PR an hour later. Codex was designed for this loop.
- Long-running multi-day workflows. The
/goalcommand lets it wake itself up to continue work across days. Useful for slow migrations or research tasks you want it chipping away at. - Cost-sensitive work. If your refactor budget is real, Codex’s 10x cost advantage is the single biggest deciding factor for most teams.
- Open-source preference. Apache-2.0 means you can audit, fork, self-host. For some teams this is a procurement requirement.
- Terminal-heavy tasks. Build systems, infra scripting, CI pipelines. Codex’s Terminal-Bench lead reflects real-world behavior.
When Claude Code wins
- Coordinated multi-file refactors. When subtasks have dependencies on each other, Claude’s coordinated sub-agent teams beat Codex’s isolation model.
- Output quality matters more than cost. Two-out-of-three preference in blind reviews is not noise. For production code, this gap matters.
- You want a plugin ecosystem. Claude Code’s skills, plugins, MCP servers, hooks, and sub-agents form a deep extensibility surface. Codex’s MCP support is solid but the broader ecosystem is thinner.
- You live in the IDE. First-class VS Code and JetBrains plugins, a desktop app, and a web surface at claude.ai/code mean you can move between surfaces without leaving the agent loop. I cover the broader IDE-vs-CLI tradeoffs in my GitHub Copilot best practices post.
- Tight feedback loops. Watching the agent edit files in your repo, in real time, against your dev server, is a different cognitive mode than reviewing a remote PR. For exploratory work, this is faster.
Extensibility: MCP, skills, plugins, sub-agents
This is where the tools diverge most sharply, and where most comparison posts get lazy.
MCP (Model Context Protocol)
Both tools support MCP, the cross-vendor standard for connecting language models to external tools and data sources. Codex’s 2026 MCP updates added per-server environment targeting, OAuth for streamable HTTP servers, concurrent execution for read-only tools that advertise readOnlyHint, and tool search by default. Claude Code’s MCP support is functionally equivalent at the protocol level, with deeper integration into the broader Claude ecosystem.
For most developers, MCP is the right way to wire a coding agent into your existing tools. I explore the broader implications in my piece on context engineering for AI agents.
Skills (Claude Code only)
A skill is a markdown file containing knowledge, workflows, or instructions that Claude Code can invoke as a slash command or auto-load when relevant. Skills package task-specific instructions, scripts, and supporting files. There are 2,000+ open-source skills available across community marketplaces. Codex has no direct equivalent; the closest is a custom system prompt or AGENTS.md file.
Plugins (Claude Code only)
Plugins bundle skills, MCP servers, commands, hooks, sub-agents into a single installable unit. The Claude Code plugin marketplace lists 425+ plugins covering domain-specific workflows from medical research to e-commerce. This is the deepest extensibility surface in the agentic-CLI space right now.
Sub-agents and orchestration
Both tools support sub-agent orchestration but in different ways. Claude Code’s Task tool launches a separate Claude session with its own context window, used for work that does not need the parent’s full history. One documented session ran 49 specialized sub-agents in parallel for 2.5 hours; the cost was estimated at $8,000 to $15,000 for that single session. That is the ceiling of what is currently possible, and a warning about how fast costs scale on Claude Max.
Codex’s parallelism story is different. Multiple independent containers running independent tasks, each with its own scratch space, coordinated by the main session. Better for independent work, worse for coordinated refactors.
Sandboxing and safety
Both tools take command-execution safety seriously, but they implement it differently.
Codex defaults to sandboxed execution on macOS, Linux, and Windows. The 2026 Windows sandbox release fixed stale credential handling and gave PowerShell commands more time before backgrounding. Remote environments now preserve executor-native paths, shells, AGENTS.md discovery, and sandbox behavior across operating systems.
Claude Code runs commands in your actual shell by default, with an approval prompt for anything destructive. The approval UX is fast (one keystroke to allow), but the model is “trust the user to read the prompt.” For automated CI use, hooks let you intercept tool calls before they execute.
If your threat model is “I am running this on a machine with production credentials,” Codex’s sandbox-by-default approach is the safer baseline. If your threat model is “I am driving this from my laptop and I will read what it asks before approving,” Claude Code’s prompt-and-approve model is faster.
Real cost comparison: same task, both tools
The numbers come from a documented Express.js refactor benchmark widely shared in the AI engineering community. Same starting repo, same target architecture, same acceptance criteria:
| Metric | Codex CLI | Claude Code |
|---|---|---|
| Total cost | ~$15 | ~$155 |
| Time to completion | ~45 min | ~30 min |
| Lines changed | ~1,200 | ~1,100 |
| Tests passing after run | Yes | Yes |
| Blind reviewer preference | 33% | 67% |
Codex was 10x cheaper. Claude Code was about 30% faster end-to-end and produced output that reviewers preferred two-to-one. Whether that quality gap is worth $140 depends entirely on how much that code matters.
My verdict
I run both. The honest answer is that this is no longer a “which tool is better” question. It is a “which loop fits the work” question.
For experimental work, prototypes, internal tooling, and anything where I want to fire-and-forget, Codex is the default. The cost economics are unbeatable, the sandbox-per-task model is the right safety baseline, and the open-source license matters for the projects where I need to audit what the agent did.
For production code, complex refactors with cross-file dependencies, and work I want to live with for years, Claude Code earns the premium. The blind review preference is real. The plugin and skill ecosystem turns it into a tool that fits my workflow specifically, rather than a generic agent. I cover what that customization actually looks like in my post on what I run before merging AI-written PRs.
If you have to pick one, ask yourself what failure mode hurts more: spending too much on AI-generated code, or shipping AI-generated code that is technically working but feels off. The first answer points to Codex. The second points to Claude Code.
Decision framework
- Solo developer, hobby projects, internal tools → Codex CLI, $20 ChatGPT Plus tier
- Startup engineering team, cost-sensitive, fast shipping → Codex CLI, ChatGPT Pro
- Senior engineer, production code, output quality matters → Claude Code, Max $100/mo
- Platform team running coordinated multi-repo refactors → Claude Code, Max $200/mo
- Procurement requires open source → Codex CLI, Apache-2.0
- Need deep IDE integration (VS Code, JetBrains) → Claude Code
- Long-running async workflows across days → Codex CLI (
/goalcommand)
Frequently asked questions
Is Codex CLI free?
The Codex CLI binary is open-source and free under Apache-2.0. Using it against OpenAI’s models requires a paid OpenAI account (ChatGPT Plus at $20/mo, ChatGPT Pro at $200/mo, or pay-per-token via the OpenAI API). You can also point Codex at compatible third-party models if you self-host inference.
Is Claude Code open source?
The Claude Code CLI wrapper is partly open-source, but the agent loop, prompting strategies, and core orchestration are proprietary Anthropic technology. The Anthropic Agent SDK that powers it is available for TypeScript and Python developers building on top.
Which is better at coding: Codex or Claude Code?
On SWE-bench Verified, GPT-5.5 (Codex) and Claude Opus 4.8 (Claude Code) score 88.7% and 88.6% respectively, a statistical tie. On blind quality reviews of real refactors, reviewers preferred Claude Code’s output roughly 67% of the time. On Terminal-Bench 2.0, Codex leads. The honest answer is “they are equivalent on capability, different on taste.”
How much does each tool actually cost per refactor?
For a benchmark Express.js refactor, Codex ran around $15 end-to-end. Claude Code ran around $155 for the same work. The 10x cost difference is consistent across most tasks. Whether the quality difference is worth that markup depends on what the code is for.
Can Codex and Claude Code both use MCP servers?
Yes. Both support the Model Context Protocol for connecting to external tools and data sources. Codex’s 2026 updates added per-server environment configuration, OAuth for streamable HTTP servers, and concurrent execution for read-only tools. Claude Code’s MCP support is functionally equivalent at the protocol level.
Which tool should a small team pick in 2026?
For most small teams, Codex CLI on a ChatGPT Pro plan is the right default. Cost-efficient, sandbox-safe by default, and the gap on output quality is rarely material for the kinds of tasks small teams ship. Upgrade to Claude Code Max when you start doing complex refactors on code you intend to maintain for years.
Do I need to pick one? Can I use both?
Most experienced AI-assisted developers I know run both. Codex for cost-sensitive, isolated tasks; Claude Code for production-quality refactoring. The cost of subscribing to both is small relative to the cost of using the wrong tool for the wrong job.