You can have both terminal coding agents for $40 a month. That’s the same price as one Cursor Teams seat. The question most developers actually face isn’t “Codex or Claude Code” — it’s which one deserves to be your first install, and what you lose if you only pay for one.

Both tools launched their current generation in April 2026. Both run in your terminal. Both cost $20/month at the entry tier. And they’re measuring neck-and-neck on SWE-bench Verified: GPT-5.5 at 88.7%, Opus 4.7 at 87.6%. The 1.1-point spread is noise, not signal.

The meaningful differences are architectural, and they dictate which tool wins on which jobs.

What the $20 tier actually buys you

	Claude Code Pro ($20/mo)	Codex CLI on Plus ($20/mo)
Entry price	$20/mo ($17 annual)	$20/mo (ChatGPT Plus)
Model	Claude Opus 4.7	GPT-5.5
Context window	200K tokens	400K tokens
Quota model	Monthly usage cap	Rolling 5-hour window caps
Next tier up	Max 5x — $100/mo	Pro 20× — $200/mo
Mid-range tier	Yes ($100/mo Max 5x)	No (jumps to $200)
Platform (full native)	macOS, Linux, Windows (v2.1.120+)	macOS, Linux
Windows status	Full (no Git Bash required)	Experimental
Open source	No	Yes (MIT)

The gap that stings most at $20 is context. Codex ships 400K tokens on the Plus plan — double the usable context in Claude Code Pro. That matters for large-file refactors where Claude Code Pro is more likely to ask you to break the task into smaller chunks.

The gap that saves you money at the mid-range is Claude Code’s $100/mo Max 5x tier. OpenAI has no $100 option: it’s Plus at $20 or Pro at $200. If you’re a heavy user but not a heavy heavy user, Claude Code has a stopping point that Codex doesn’t.

Architecture: where the real split is

Both tools are agentic — they plan, execute multi-step tasks, read your codebase, and commit changes. The execution model is completely different.

Claude Code is local-first and interactive by default. When you run claude, it presents a structured plan, shows you which files it will touch, waits for your approval, then executes. The loop keeps you in the conversation. Complex ambiguous requirements — “refactor this module to use the repository pattern” — benefit from this model because Claude Code asks clarifying questions before writing code. That extra round-trip catches edge cases that pure autonomous execution would miss.

The /batch command flips this into parallel mode: Claude Code decomposes a task into 5–30 independent units, each in its own isolated git worktree, with a coordinating lead agent merging the results. A batch of 20 endpoint documentation tasks takes roughly the same wall-clock time as one. This is Claude Code’s primary speed lever.

Codex CLI is sandboxed-async by design. Three autonomy levels let you set how much supervision the agent needs before it runs:

• Suggest mode: every edit and shell command requires your approval. Right for production codebases.
• Auto-edit mode: file changes apply automatically; shell commands still prompt. Right for feature branches.
• Full-auto mode: no confirmations within the sandbox boundary. Right for well-scoped, isolated tasks.

The workspace-write sandbox (default in full-auto) restricts Codex to your working directory and routine local commands — edits outside that boundary still require approval. You can move to danger-full-access when a task needs external services, but that’s the exception.

Where this pays off: Codex in full-auto mode is faster for bulk tasks that don’t need clarification. “Write unit tests for all functions in this module” runs unattended, start to finish. Claude Code’s default interactive mode would pause for plan approval. If you already know exactly what you want and the task is well-scoped, Codex’s three-mode system gets out of your way more cleanly.

Benchmarks: the three numbers that actually matter

The single benchmark question — which model is smarter? — has a more complicated answer than the headline SWE-bench scores imply.

SWE-bench Verified evaluates real GitHub issue resolution on issues that human reviewers have confirmed are solvable. GPT-5.5 scores 88.7% (OpenAI-reported, April 2026). Opus 4.7 scores 87.6% (Anthropic-reported, April 2026). Different testing harnesses, different agentic scaffolds — the 1.1-point gap should be treated as tied.

SWE-bench Pro is the harder, newer variant: issues from repositories updated after most LLM training cutoffs, so memorization helps less. Here Opus 4.7 leads at 64.3% versus GPT-5.5 at 58.6% — a 5.7-point edge. For teams working on recent frameworks and libraries that don’t appear heavily in training data, this gap is meaningful.

Terminal-Bench 2.0 measures CLI-specific capabilities: multi-step command-line workflows, tool coordination, and planning across turns in a pure terminal context. GPT-5.5 scores 82.7% (#1 on the leaderboard). Opus 4.7 is not ranked. This is Codex CLI’s home turf, and the performance advantage for DevOps-heavy workflows is real.

The takeaway: Opus 4.7 wins on complex, newer code. GPT-5.5 wins on terminal-native tasks. Neither model is definitively better; each is better at what it was optimized for.

Three scenarios where the choice is clear

Scenario 1: You’re a backend engineer refactoring a 40-file payment service.

The task spans many files with subtle interdependencies. You’ll have questions partway through — “should I keep the legacy retry logic or remove it?” — and the answer changes which files get touched.

Claude Code wins here. The interactive loop is a feature, not overhead. Opus 4.7’s SWE-bench Pro advantage on recent code kicks in. The /batch command handles the integration test generation once the refactor is scoped. Claude Code’s 1M context window (available on the $100 Max 5x plan) lets it hold the entire service in context without chunking.

Scenario 2: You’re automating code quality in CI — lint fixes, docstring generation, test file creation for new functions.

These tasks are well-defined, repetitive, and don’t need human supervision. The codebase is under version control with clean rollback.

Codex CLI wins here. Full-auto mode runs without pausing. AGENTS.md defines the rules once; every CI-triggered run inherits them. The 400K context handles large files without the overhead of a Max plan upgrade. Codex Cloud (via the macOS app) can run these tasks as scheduled overnight batches in OpenAI’s infrastructure, independent of your local machine.

Scenario 3: You’re a solo dev prototyping a new feature on a Friday afternoon.

You want real-time feedback, fast iteration, and the ability to course-correct quickly. You’re making architectural decisions as you go.

This one is genuinely a toss-up that comes down to whether you’re on macOS/Linux (both equal) or Windows (Claude Code wins on parity), and whether the task is well-defined (Codex) or exploratory (Claude Code). The Terminal-Bench gap shows up in scripting tasks; the SWE-bench Pro gap shows up in complex code logic. Neither is a blowout.

Ecosystem: the lock-in you’re actually buying

This is the comparison that matters most for teams planning a 6-month tool consolidation.

Claude Code runs on CLAUDE.md — project and user-level instruction files that support layered configuration (project root → ~/.claude/ → local override), hooks for auto-formatting and blocking destructive commands, and MCP server connections. Teams that invest in this system — structured test commands, domain-specific code review checklist, automated PR triggers — get compounding returns. The /ultrareview command (launched April 2026) fires a cloud fleet of bug-hunting agents that deposit findings into your CLI session. Routines schedule recurring tasks on Anthropic’s infrastructure, running on a calendar or GitHub event even when your machine is off.

None of this is accessible from Codex CLI because CLAUDE.md is Anthropic-specific. If your team uses Cursor, Windsurf, or any Claude Code IDE surface, CLAUDE.md works uniformly across all of them — it’s not a terminal-only format.

Codex CLI runs on AGENTS.md — the open standard that 60,000+ open-source projects have already adopted. Aider reads it. GitHub Copilot reads it. OpenHands reads it. If your team’s open-source projects already ship AGENTS.md, Codex CLI inherits your project context without any extra configuration. The simplicity is intentional: AGENTS.md covers instructions and prohibited actions; it doesn’t have hooks or layered scopes. For project-specific setup, that’s usually enough.

The practical implication: switching between tools is cheap on the Codex side (AGENTS.md travels), more expensive on the Claude Code side (CLAUDE.md doesn’t). If you’re a contributor to open-source projects that you don’t control, Codex’s alignment with the open standard has real value.

The billing traps

Rolling 5-hour windows (Codex Plus): The ChatGPT Plus Codex allocation resets on a rolling basis every 5 hours. Run three long full-auto sessions back-to-back, and you’ll hit the cap before the window resets. This isn’t a monthly budget; it’s a rate limiter. Heavy users who run Codex as their primary tool for 8-hour coding days will either purchase overage credits or find themselves blocked mid-session. The Pro tier at $200/month removes this ceiling with a 20× Plus allocation.

Context-window pricing tier (Claude Code): The 1M context window isn’t included on the $20 Pro plan — it requires Max 5x ($100/mo) or higher. A Pro user who pastes a large file that exceeds 200K tokens mid-session hits a hard limit. Practical workaround: Claude Code will ask you to start a new session or break the task down. It’s workable but annoying. If 400K context on Codex handles your files, you’re getting more for $20.

Mid-tier gap (Codex): ChatGPT has Plus ($20) and Pro ($200), with no middle option. Claude Code’s $100 Max 5x tier is the practical plan for heavy-daily-use developers who don’t need 20× quota. If you’re running 3–4 hours of agentic sessions per day, Claude Code’s tiering fits your usage curve better. Codex forces a jump to $200 for the same headroom.

Platform checklist

Both tools run natively on macOS and Linux. Claude Code added full Windows support in v2.1.120 (Week 18, April 27–May 1, 2026) — Git Bash is no longer required, and PowerShell works as the native shell. Codex CLI lists Windows support as experimental; WSL2 remains the documented recommendation for Linux-native behavior.

Claude Code’s VS Code extension works inside Cursor and Windsurf forks — the CLAUDE.md config, MCP connections, and session context transfer. If your team uses Cursor Pro, adding Claude Code Pro at $20 gives you a second agent layer without reconfiguring your IDE.

The Codex macOS app (launched February 2, 2026) is the only GUI control center for parallel cloud agents on either tool. Linux and Windows users on Codex manage cloud tasks through the CLI. There is no equivalent desktop app for Claude Code — it has a web interface at claude.ai/code and an iOS app, but no standalone desktop agent coordinator.

Decision framework: three developer profiles

Profile A: Daily IDE coder, VS Code or JetBrains → Start with Claude Code Pro ($20). The VS Code and JetBrains extensions integrate directly with your existing workflow. CLAUDE.md persists project context. The interactive loop fits feature development. Add Codex CLI when you have well-defined batch tasks.

Profile B: DevOps engineer, heavy CLI and automation → Start with Codex CLI (already on ChatGPT Plus?). Terminal-Bench 2.0 performance, full-auto mode, AGENTS.md compatibility with your existing open-source tooling. Upgrade to Claude Code if you start working on complex multi-file refactors that benefit from the interactive model.

Profile C: Backend engineer or ML engineer on newer codebases → Claude Code Max 5x ($100/mo). The SWE-bench Pro advantage matters when you’re working on libraries that shipped after mid-2024. The 1M context window holds large codebases without chunking. Codex CLI stays free as a secondary tool for bulk automation tasks.

Honest take

The “run both” recommendation is genuinely correct and not a cop-out: they solve different problems, and at a combined $40/month for both Pro tiers, the math works.

If you can only pay for one: Claude Code wins on interactive pair-programming quality, team workflow automation depth (CLAUDE.md + Routines + /ultrareview), and the $100 mid-range tier. Codex CLI wins on terminal-native performance, bulk autonomous execution without supervision, and context window size at the $20 tier.

The argument for Codex CLI as your only terminal agent: you’re already paying for ChatGPT Plus, the tasks you automate are well-defined, and you contribute to open-source projects that already ship AGENTS.md.

The argument for Claude Code as your only terminal agent: you work on complex multi-file features, you want the interactive refinement loop, and your team is standardizing on Claude-based tools across IDE extensions and CI.

The argument for both: you want the best available coverage, you’re already paying $40/month for a Cursor seat anyway, and you’d rather have two specialized tools than one generalist with blind spots.

See also: Cursor vs Claude Code 2026 for how the IDE-versus-CLI architecture split plays out at the same price points, and Claude Code Power User Setup 2026 for getting the most out of CLAUDE.md, hooks, and subagents.

Sources

• Claude Code Review 2026 — AICoderScope (May 19, 2026)
• OpenAI Codex CLI Review 2026 — AICoderScope (May 24, 2026)
• Claude Code — What’s New (Weeks 13–20, 2026)
• Introducing GPT-5.5 — OpenAI (April 23, 2026)
• Codex CLI on GitHub — openai/codex
• Claude Code vs Codex CLI — Termdock (May 2026)
• Codex vs Claude Code (May 2026): Benchmarks, Subagents & Limits — MorphLLM
• Introducing GPT-5.3-Codex — OpenAI
• Codex Flexible Pricing for Teams — OpenAI
• Claude Pricing — Anthropic

Last updated May 26, 2026. Pricing and features change frequently; verify current state before purchasing.