We pay for both. Claude Code on Anthropic's $200/month Max plan, Codex on OpenAI's $200/month Pro plan — $400 a month for two terminal agents that claim the same job. After months of running both daily against the same monorepo, the honest finding is that they're closer than either fanbase admits, the benchmark gap is within noise, and the real decision is about workflow shape: orchestration depth on one side, surface breadth on the other. This post lays out the July 2026 pricing, the current models, and the differences that survived daily use.
One framing note up front: this is a comparison of two prompt-driven CLIs, written by people who build a different kind of agent. Where that bias could color a claim, we've linked the source so you can check the claim without trusting us.
The plans: two identical price ladders
Both vendors converged on the same three-rung ladder, which makes the pricing comparison unusually clean.
Claude Code is bundled with Claude subscriptions: claude.com/pricing as of July 2026 lists Pro at $20/month, Max 5x at $100/month, and Max 20x at $200/month, plus pay-per-token via the Anthropic API if you'd rather meter than subscribe. Usage on subscriptions is quota-based — allowances that reset on short rolling windows, with weekly caps on heavy use. Team plans put Claude Code on Premium seats at $100/seat/month.
Codex mirrors it: the CLI itself is free and open-source, and you pay through a ChatGPT plan — Free, Go at $8/month, Plus at $20/month, Pro at $100/month (5x) or $200/month (20x), with Business seats at $20/user/month on annual billing (Codex pricing, July 2026). One structural change worth knowing: in April 2026 OpenAI moved Codex usage accounting to token-aligned credits instead of per-message counting, so heavier tasks now draw down your allowance faster than chatty small ones.
The practical read on the ladders: $20 gets a real workday of either tool with limits you'll hit on agentic sessions, $100 removes the limits for most single-developer use, and $200 exists for people running parallel agents or very long sessions. We're on the $200 tiers because we run multi-hour agent sessions daily; most developers we know sit happily at $20 or $100.
The models are effectively tied
The model question dominated this comparison in 2024 and 2025. In July 2026 it's the least interesting section, which is itself the finding.
Claude Code defaults to Claude Sonnet 5 with native 1M-token context, with
Opus 4.8 one /model
away for harder problems. Codex runs on the GPT-5.5 family, with
GPT-5.5-Codex as the coding-tuned variant across all its surfaces. On the
public numbers, Codex leads Terminal-Bench 2.1 at 83.4% and ties Opus 4.8
on SWE-bench Verified within 0.1
points.
A tenth of a point on SWE-bench is smaller than the variance we see between two runs of the same prompt on the same model. Our field experience matches the benchmarks: on well-scoped tasks both tools succeed or fail for the same reasons — context quality, task clarity, test coverage — not model choice. We've written before about how to read these benchmarks skeptically; the short version is that once two agents are within a point of each other, the benchmark has stopped being the deciding variable.
If your evaluation of Claude Code vs Codex starts and ends with a leaderboard, you're choosing between two tools on the axis where they differ least.
Where they actually differ
Months of daily use produced a consistent pattern in which tool we reach for. It maps to how each product is architected.
Claude Code: orchestration depth
Claude Code's distinguishing features are the ones that treat the agent
as a system you configure, not a chat you have. Subagents are GA and run
in the background by default — up to 8 parallel workers from a single
task, isolating changes in their own git worktrees and opening draft
PRs. Hooks fire
deterministic scripts at lifecycle points (PreToolUse as a security
checkpoint before any tool runs, PostToolUse, and friends), which is
how you enforce rules the model can't talk itself out of. Skills,
CLAUDE.md project memory, and MCP round out a genuinely deep
configuration surface.
The cost of that depth is that Claude Code rewards investment. Out of the box it's a strong pair-programmer; the teams getting the most from it have written hooks, skills, and memory files. It's a terminal-native power tool, and it looks like one.
Codex: surface breadth
Codex's bet is one execution model across every surface: the terminal
CLI, an IDE extension, the web app, iOS, and tagging @codex on a GitHub
issue or PR to spin up a cloud task. The
Rust-based CLI is open-source,
sandboxed by default, and supports AGENTS.md, skills in
.codex/skills, and MCP — the configuration story has largely reached
parity with Claude Code over the past year.
Where Codex pulls ahead in our use is delegation ergonomics. Kicking a task to the cloud from your phone, or from a GitHub comment, and getting a diff back with logs is a loop Claude Code doesn't match as smoothly. Where it lags is orchestration: there's no equivalent of Claude Code's hook system for hard guardrails, and parallel-agent workflows feel bolted on rather than native.
How we split the work
Our own split after months on both, for whatever one team's sample is worth: Claude Code gets the long-running, multi-file work where we want subagents fanning out and hooks enforcing the rules — roughly the sessions that justify the Max plan. Codex gets the delegated one-offs — "fix this, I'll look at the diff later" — especially anything started away from the desk. If we could keep only one at $20, we'd keep whichever one matched our editor and ecosystem, and we mean that literally: the capability gap at the median task is that small.
When not to use each
The anti-recommendations, one line each.
- Claude Code — not if nobody on the team will invest in configuration. Unhooked and unconfigured, you're paying for depth you won't use, and the $20 Codex Plus tier does the same median task.
- Codex — not if you need hard, deterministic guardrails on what the agent may do. Sandbox policies help, but there's no lifecycle-hook equivalent, and policy-by-prompt isn't policy.
- Both — not if the actual problem is a backlog. Each is prompt-first: a developer decides what to work on, starts the session, and reviews the result. The deciding and starting is still your job.
That last line is the category boundary that months of dual subscriptions made obvious. Both tools got dramatically better at executing a task in 2026. Neither is designed to pick the task up from your tracker, work the queue unattended, and hand back tested PRs — that's a different product category, with different safety and cost-control requirements, and it's the one we build Codowave in. If your bottleneck is a queue rather than a keyboard, evaluate that category separately; a CLI agent won't drain a backlog you don't feed it.
For the head-to-head this post is about, the scorecard after $400 a month and a few hundred sessions each: pricing is a tie by construction, models are a tie within noise, Claude Code wins orchestration, Codex wins reach. Pick the one that matches where your work starts — and spend the hour you saved on benchmarks writing better task descriptions, which moved our success rate more than any model switch did.