CODEX VS CLAUDE CODE WHO WINS

CODEX VS CLAUDE CODE: THE MODELS, THE $20 TO $500 PLANS, AND WHO WINS

OpenAI Codex and Anthropic Claude Code are the two coding agents most developers now choose between. Both read your repository, edit files, run commands and tests, and open pull requests. Both have a CLI, IDE extensions, a desktop app and cloud agents that keep working after you close your laptop. The differences are in the models behind them, how the plans meter usage, and how each one behaves on long, messy jobs.

Everything below comes from the official model pages, pricing pages, help center articles, docs and launch posts of both companies as of November 9, 2026, plus a few labeled third-party sources.

A note on names: OpenAI’s current models are GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna. Anthropic’s are Claude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5. I checked each on the vendor’s own page.

⚡ The short version

CODEX (OpenAI) CLAUDE CODE (Anthropic)

Default model GPT-6.1 Sol Claude Opus 5.5

Top model GPT-6 Astra Claude Fable 5.1

$20 plan ChatGPT Plus Claude Pro

~$100 plan Pro 100 (10x Plus) Max (5x Pro)

~$200 plan Pro 200 (20x Plus) Ultra (10x Pro weekly)

$500 plan Pro 500 (50x Plus) none

5-hour limit none on any Pro tier Ultra only (verified)

Project file AGENTS.md CLAUDE.md (reads AGENTS.md)

Best at volume, price, cloud long autonomous runs,

tasks, code review agentic coding scores

In one line: Claude Code has the stronger published agentic coding numbers, and Codex gives more usage per dollar, a $500 tier and a cheaper default model.

🧰 What each product actually is

Codex

Codex is OpenAI’s coding agent, and it now lives inside ChatGPT. On July 9, 2026 the standalone Codex app merged into the ChatGPT desktop app for macOS and Windows (a Linux preview followed in August). In the app you switch between Chat, Work (OpenAI’s general agent) and Codex, which keeps the developer view with diffs, Git review and a pull request pane.

The surfaces are the Codex CLI (version 0.167.0 shipped November 6, 2026), an IDE extension that shares config.toml with the CLI and app, and Codex Cloud. In Codex Cloud you describe your dev setup, Codex installs and tests it, and you publish a reusable environment. Each new task starts in its own isolated workspace, and you can continue it from web, desktop or iOS while your computer sleeps.

On GitHub you tag

@codex

on a pull request for a review or turn on automatic reviews, with a “Code Review Rules” section in AGENTS.md. GitLab is in beta and there is a Slack integration.

The agent features: nested AGENTS.md files (global, repo, subfolder; the closest wins), Plan mode (/plan), Goal mode for objectives that run hours or days, subagents, skills, plugins that bundle skills and MCP servers, hooks (generally available since May 2026), event-triggered scheduled tasks, worktrees, a built-in browser, Computer Use on macOS and Windows, and a Chrome extension.

Safety is two knobs. Sandbox mode sets what Codex can touch (read-only, workspace-write or danger-full-access). Approval policy sets when it must ask before running a command. Codex can also import your Claude Code or Cursor setup with /import, which tells you who OpenAI sees as the main rival.

Claude Code

Claude Code started as a terminal app and now runs in the terminal, VS Code (and Cursor), JetBrains IDEs, the Claude desktop app, the web at

claude.ai/code

and the mobile apps. Every surface uses the same engine, so CLAUDE.md files, settings and MCP servers carry across.

The features, from Anthropic’s docs:

CLAUDE.md, read at the start of every session. If the repo already has an AGENTS.md, Claude Code can read that instead. It also keeps auto memory across sessions.
Skills (shareable workflows like /review-pr), hooks (shell commands before or after actions), and MCP for tools like Jira, Slack or your own services.
Subagents with isolated context that return summaries, and agent teams where a lead agent assigns and merges work. Agent teams are still experimental and off by default.
Background agents, the Agent SDK, cloud scheduled tasks that run when your computer is off (triggered by schedules, API calls or GitHub events), Remote Control from your phone,

@Claude

in Slack, GitHub Actions, GitLab CI/CD and GitHub Code Review on every pull request.
A sandboxed Bash tool. The docs note that file tools, MCP servers and hooks run outside that sandbox, so for full isolation Anthropic points you to a container or VM.

FEATURE CODEX CLAUDE CODE

CLI yes yes

IDE VS Code family VS Code, Cursor, JetBrains

Desktop app ChatGPT desktop Claude desktop

Cloud agents Codex Cloud envs Claude Code on the web

Instructions file AGENTS.md (nested) CLAUDE.md (+ AGENTS.md)

Plan mode /plan plan mode

Long goals Goal mode long runs, scheduled tasks

Subagents yes yes, plus agent teams (exp.)

Hooks / Skills / MCP yes / yes / yes yes / yes / yes

PR review bot

@codex

review GitHub Code Review

Sandbox OS-level, 3 modes sandboxed Bash tool

Browser/computer use macOS, Windows, Chrome Chrome integration

On paper the feature lists are now close to identical. The differences are in models, limits and behavior.

🧠 The models

OpenAI lineup in Codex

GPT-6 Astra. Launched September 3, 2026, OpenAI’s most capable model. $10 per million input tokens, $50 output, $1 cached input. 1,050,000-token context, 128K max output.
GPT-6.1 Sol. Launched September 29, 2026, now the Codex default. Pitched as near-Astra intelligence at a fifth of the price: $2 input, $10 output, $0.10 cached. 1,050,000-token API context, but a 500,000-token default window in Codex.
GPT-6.1 Terra. Added to Codex in late October 2026. A fast model for writing, image understanding and computer use. Its Codex credit rate is half of Sol’s.
GPT-6 Luna. The efficient model for simple, high-volume tasks: $0.10 input and $0.50 output. It is the only Codex model on the Free and $8 Go plans.

Anthropic lineup in Claude Code

Claude Fable 5.1. Top model for demanding reasoning and long-horizon work. $10 input, $50 output.
Claude Opus 5.5. Launched September 22, 2026, Anthropic’s recommended starting model. $4 input, $20 output, $0.20 cache reads. Anthropic says it performs at Fable 5.1’s level on most work and costs 40% less to run than Opus 5. Fast mode in Claude Code: up to 2.5x faster at $8/$40.
Claude Sonnet 5.5. Launched September 28, 2026. $2 input, $10 output.
Claude Haiku 5.5. From $0.10 input and $0.50 output, for classification, extraction and routing.

All four Claude models have a 1M-token context window and 128K max output on the API.

API PRICE PER 1M TOKENS (input / output)

GPT-6 Astra $10.00 / $50.00 ##########

Claude Fable 5.1 $10.00 / $50.00 ##########

Claude Opus 5.5 $ 4.00 / $20.00 ####

GPT-6.1 Sol $ 2.00 / $10.00 ##

Claude Sonnet 5.5 $ 2.00 / $10.00 ##

GPT-6 Luna $ 0.10 / $ 0.50 .

Claude Haiku 5.5 $ 0.10 / $ 0.50 . (from)

The pairs line up almost exactly. Astra and Fable cost the same. Sol and Sonnet cost the same. Luna and Haiku start at the same price. The odd one out is Opus 5.5 at $4 and $20, which sits between the tiers and is Anthropic’s default for Claude Code. That matters because the fair head-to-head is the default model on each side: GPT-6.1 Sol at $2/$10 against Opus 5.5 at $4/$20. Sol costs half per token.

One API detail: OpenAI charges 2x input and 1.5x output for the whole request once a prompt passes 272K input tokens on Astra and Sol.

Benchmarks, with sources

Each vendor picks its own harness and effort level, and some numbers in each table are copied from the rival’s report, so I list who measured what.

TERMINAL-BENCH 4.0 (agentic terminal tasks)

Claude Opus 5.5 66.4% ################ Anthropic, Sep 22, xhigh

GPT-6 Astra 57.9% ############## OpenAI, Sep 3, high

Claude Fable 5.1 55.8% ############# Anthropic

Claude Opus 5 52.3% ############ Anthropic

GPT-5.6 Sol 37.3% ######### OpenAI

Independent run (Artificial Analysis, 66 tasks x 3):

GPT-6 Astra 59.1% | Fable 5.1 52.0% | Opus 5 49.0%

Anthropic gives a standard error of plus or minus 2.6 points for its Opus 5.5 figure. I could not find an independent Terminal-Bench 4.0 run for Opus 5.5 or GPT-6.1 Sol, so the 66.4% is a vendor number.

FRONTIERCODE v1.1 MAIN (would the change get merged?)

Claude Opus 5.5 54.4% Anthropic table

GPT-6 Astra 53.3% OpenAI

Claude Fable 5.1 50.3% Anthropic table (OpenAI lists 50.9%)

GPT-5.6 Sol 47.5% OpenAI

DEEPSWE v1.1 (long-horizon SWE tasks, OpenAI table)

GPT-6 Astra 74.1%

Claude Opus 5 73.7%

GPT-5.6 Sol 72.7%

Claude Fable 5.1 67.4%

GPT-6.1 Sol “matches Astra at about 1/5 the cost” (no exact number published)

On cost per task, both companies make strong claims about their own models. Anthropic says Opus 5.5 at default effort beats Astra’s top FrontierCode score for about a fifth of the cost per task, and matches Astra on Terminal-Bench 4.0 for about 40% of the cost. OpenAI says GPT-6.1 Sol at max effort costs $5.47 per task on Terminal-Bench Science, against $23.21 for Opus 5.5 and $23.80 for Astra, and that Sol beats Opus 5.5 by 2.2 points on Zapier’s AutomationBench at medium effort for about a third of the cost.

What about SWE-bench? Neither OpenAI’s Astra launch post nor Anthropic’s Opus 5.5 launch post publishes a SWE-bench Verified or SWE-bench Pro score. Some third-party sites circulate exact SWE-bench numbers for these models. I could not trace them to a primary source, so I left them out.

My reading: on the agentic coding benchmarks both sides report, Opus 5.5 leads Astra. GPT-6.1 Sol is the wildcard, with OpenAI claiming near-Astra results at a fifth of the price but fewer published coding numbers. Anthropic itself says benchmark margins at this level are a less reliable guide to real-world differences.

💳 The plans: $20, $100, $200, $500 and teams

Both companies bundle the coding agent into their chat subscription, and usage is shared. On ChatGPT, Codex and ChatGPT Work draw from one allowance. On Claude, Claude Code shares limits with chat on web, desktop and mobile.

The $20 tier. ChatGPT Plus includes Codex on web, CLI, IDE and iOS, automatic code review and Slack, GPT-6.1 Sol and Luna, and limited Astra. OpenAI publishes estimated local messages per five hours on Plus: Astra 5 to 45, Sol 15 to 160, Terra 35 to 285, Luna 350 to 3,000, with possible weekly limits. Claude Pro ($20, or $17 a month billed annually) includes Claude Code and Opus 5.5 with five-hour and weekly limits. Fable costs extra credits on Pro. Anthropic publishes no message counts.

The ~$100 tier. ChatGPT Pro 100 has no five-hour limit in Codex, only an allowance with possible weekly limits, and Astra is included. On November 8, 2026 OpenAI’s Codex lead posted that it gives 10x Plus usage (a post, not a help page). Claude Max gives 5x Pro every five hours and every week, Fable up to half the weekly limit, and $100 a month in API credits. The help center says those credits cannot be used in Claude Code or the Claude apps.

The ~$200 tier. ChatGPT Pro 200 has no five-hour limit and, per the same post, 20x Plus. Claude Ultra, the renamed Max 20x, gives 10x Pro weekly usage with no five-hour limit for verified accounts, a separate Fable limit, and $200 in API credits (again, not for Claude Code).

The $500 tier. ChatGPT Pro 500 is the top consumer plan from either company: 50x Plus per the post, no five-hour limit, and Ultrafast mode for Astra and Sol (up to 8x faster generation on Sol, but it burns included usage at 8x). Anthropic has no $500 plan. Above Ultra you use usage credits, pay-as-you-go API billing, Team or Enterprise.

Team and Enterprise

ChatGPT Business: Standard seat $25 monthly or $20 annually; Premium $125 or $100, with more usage and no five-hour limit. Minimum 2 seats, larger cloud VMs for Codex. Enterprise is custom, billed by credits or tokens.

Claude Team: Standard $25 or $20 with 1.25x Pro’s per-session usage; Premium $125 or $100 with 6.25x. Minimum 2 seats, up to 150. Claude Enterprise charges a seat fee for access and bills every token at API rates, with no per-seat limits. Self-serve starts at 20 seats.

PRICE CODEX (ChatGPT) CLAUDE CODE (Claude)

—– —————————— ——————————

$0 Free: GPT-6 Luna, desktop app Free: no Claude Code

$8 Go: GPT-6 Luna, desktop app –

$20 Plus: Sol + Luna, limited Pro: Opus 5.5, Sonnet, Haiku

Astra, cloud review, 5h + 5h + weekly limits, Fable via

weekly limits paid credits

$100 Pro 100: ~10x Plus*, no 5h Max: 5x Pro per 5h and week,

limit, Astra included Fable up to 1/2 weekly limit

$200 Pro 200: ~20x Plus*, no 5h Ultra: 10x Pro weekly, no 5h

limit limit (verified accounts)

$500 Pro 500: ~50x Plus*, no 5h, no plan

Astra + Sol Ultrafast

Team Business $25/$20 std, Team $25/$20 std,

$125/$100 premium, min 2 $125/$100 premium, min 2

Ent. custom, credits or tokens seat fee + all usage at API

rates, no per-seat limits

API key: CLI/SDK/IDE, no cloud Console key: API rates

review or Slack

* multipliers from the Codex lead’s Nov 8, 2026 post, not a help page

At $100, Codex’s stated multiplier (10x Plus) is double Claude’s (5x Pro), with no five-hour window. At $200 it is 20x against 10x weekly. Each multiplier is relative to that company’s own $20 plan, and those plans differ in size, so this is not an exact comparison. The direction matches what developers report: limits are the top complaint about Claude Code and a top reason people give for Codex.

🏗️ One complex project, walked through

To make this concrete, here is an illustrative walkthrough. I did not run this project end to end on both tools. It describes how each product is designed to handle each phase, based on the documented features above, the vendors’ own case studies, and commonly reported experiences.

The project: a 7-year-old single-tenant Django monolith for a B2B invoicing product, around 250,000 lines with patchy tests. The goal is to turn it into a multi-tenant SaaS: tenant isolation in Postgres with row-level security, SSO and organization-level roles, Stripe subscription billing with usage-based metering, background jobs moved from cron scripts to a queue, and a zero-downtime migration of existing customers.

legacy monolith (single tenant)

[1] map + plan —> PLAN.md, risks, test gaps

[2] safety net —> characterization tests, CI green

[3] tenancy —> tenant_id everywhere + Postgres RLS

[4] auth/roles —> SSO, org roles, audit log

[5] billing —> Stripe subs + metered usage + webhooks

[6] jobs —> cron -> queue workers, retries, idempotency

[7] migration —> backfill, dual-write, cutover, rollback plan

Phase 1: mapping and planning

Use plan mode on both. Codex’s docs also suggest a PLANS.md execution-plan template. Claude Code’s plan mode keeps subagents read-only while they explore.

Claude Code’s edge here is delegation. Subagents can map the billing module, job scripts and data model in parallel, each returning a summary so the main context stays clean. Anthropic’s launch post cites testers who finished a 680,000-line migration in under a day and audited and fixed a 200,000-line codebase in under three hours. Those are vendor-picked stories, but they describe this exact kind of work.

Codex’s edge is cost: Sol’s 500K default window is enough for the map at half Opus 5.5’s token price. Nested AGENTS.md files give the billing folder its own rules (“never use Stripe live keys in tests”).

Phase 2: building a safety net

Before touching tenancy you need characterization tests that pin down current behavior. This long, repetitive work suits Codex Cloud: one reusable environment with Postgres, Redis and the test runner, then many isolated parallel tasks, one per module, each returning a diff. Push simple scaffolding to Luna and it stays cheap.

On Claude Code you run the same work with background agents or on the web, with a hook that runs tests after edits. The difference is how fast a Pro or Max plan hits its five-hour window with five agents running.

Phase 3: tenancy and row-level security

This is the riskiest phase. Every query must be scoped by tenant, and one missed join leaks data between customers, so judgment matters more than throughput. On Codex, switch from Sol to Astra here, as OpenAI’s own guidance suggests for hard multi-step changes. Astra is capped at an estimated 5 to 45 messages per five hours on Plus, so Pro 100 is the realistic minimum.

On Claude Code, Opus 5.5 is already the default, and Fable 5.1 is available on Max and Ultra for the hardest reasoning. A useful setup is a hook that blocks any commit where a new query in the data layer lacks a tenant filter, plus a dedicated security-review subagent.

Phases 4 to 6: auth, billing and jobs

Stripe work means webhooks, idempotency keys and retries. Codex’s built-in browser and Computer Use can click through your local checkout to verify it, and Codex Security Review checks each pull request on Pro, Business and Enterprise (not Plus). Claude Code verifies through its Chrome integration and reviews PRs with GitHub Code Review. Moving cron scripts to queue workers is mechanical: build the first worker with the agent, save the pattern as a skill, apply it to the rest. That part is a tie, and cheaper on Codex with Sol or Luna.

Phase 7: the cutover

Backfill, dual-write, verify, cut over, keep a rollback path. Both tools will write the scripts and runbook. Neither should run a production migration unattended: keep Codex in workspace-write with approvals on, and keep Claude Code’s permission prompts on for anything touching a non-local database.

Where each tends to fail

Codex: Sol can produce plausible changes that are shallow on cross-module reasoning, which is why OpenAI tells you to move to Astra for hard work. A broken cloud setup script wastes runs. Some developers in community threads report outages and capacity errors.

Claude Code: limits are the most frequent complaint, and a big parallel session drains a Pro plan fast. Long sessions drift if CLAUDE.md is vague. The Bash sandbox does not cover file tools, MCP servers or hooks, so use a container for full isolation.

Both: an agent that is allowed to “make the tests pass” may weaken the tests. Lock test files with a hook or review rule during refactors. Pin “done when” criteria in AGENTS.md or CLAUDE.md, and review every migration by hand.

✅ Pros and cons

Codex pros

More usage per dollar on the stated numbers: 10x, 20x and 50x Plus on the $100, $200 and $500 Pro plans, with no five-hour limit on any of them.
A cheaper default model. GPT-6.1 Sol costs $2 and $10 per million tokens, half of Opus 5.5.
Strong cloud workflow: reusable environments, isolated parallel tasks, mobile follow-up.
Built-in review and security.

@codex

review, automatic PR reviews, Codex Security Review and Security Cloud.
A $500 tier with Ultrafast mode for people who value speed over cost.
Computer Use, a built-in browser and a Chrome extension in the same app, useful for end-to-end verification.

Codex cons

Its best published coding scores belong to Astra, which costs 5x Sol per token and is limited on Plus.
GPT-6.1 Sol has fewer published coding benchmarks than the other flagship models.
Product sprawl. Chat, Work, Codex, dots and Sites share one app and one allowance, so it is harder to predict what eats your usage.
API-key mode drops cloud features such as GitHub code review and Slack.
The Pro multipliers come from an executive’s post, not from a pricing table you can link in a contract.

Claude Code pros

The strongest published agentic coding results right now. Opus 5.5 leads Terminal-Bench 4.0 (66.4%), FrontierCode v1.1 (54.4%) and CursorBench 4.0 (57.8%) in Anthropic’s table.
Built for long, sprawling jobs. Anthropic’s examples include a C to Rust rewrite of HAProxy (9.5 hours) that passed nearly all of its regression tests.
The most widely used coding agent. In the Stack Overflow 2026 survey (12,255 respondents), 65.5% had used Claude Code in the past year against 29.5% for Codex, and 41.4% want to use it in the next six months against 17.6%.
A deep customization stack: CLAUDE.md, auto memory, skills, hooks, subagents, agent teams and the Agent SDK.
The widest IDE coverage, including JetBrains.

Claude Code cons

Tighter limits for the price. Max is 5x Pro, Ultra is 10x Pro weekly, and only Ultra (verified) removes the five-hour wall.
No plan above $200. Heavy users fall back to credits or API billing.
The default model costs twice as much per token as OpenAI’s default.
The API credits on Max and Ultra cannot be used inside Claude Code.
Agent teams are still experimental and off by default.
A stray ANTHROPIC_API_KEY switches you to API billing silently.

🏆 The verdict

There is no single winner for everyone, so here is the pick by user type, then an overall call.

WHO YOU ARE PICK

————————————- —————————–

Student / hobbyist on $20 Codex (Plus): more volume

Solo dev, complex product, $100-200 Claude Code (Max / Ultra)

Heavy user who hits limits daily Codex Pro 200 or Pro 500

Large refactors and legacy migrations Claude Code (Opus 5.5)

Many small parallel tasks, PR triage Codex Cloud

Speed above all, money no object Codex Pro 500 (Ultrafast)

JetBrains shop Claude Code

Team on a budget, 2-150 people tie: both $20-25 / $100-125

Enterprise, predictable invoices ChatGPT Enterprise

Enterprise, pay only for real usage Claude Enterprise

Codex wins on value. On the published multipliers, $100 or $200 on ChatGPT Pro buys more agent time than the same money on Claude, with no five-hour wall, and the default model costs half as much per token. For a stream of well-defined tasks (tests, fixes, reviews, small features), Codex gets through more per dollar.

Claude Code wins on hard work. Opus 5.5 leads the agentic coding benchmarks both vendors report, and developers use it about twice as often as Codex in the largest survey available. On a job like the tenancy migration, where one missed filter is a data breach, judgment matters more than message counts.

My overall pick for a professional developer working on a real product is Claude Code on the Max plan, with a $20 ChatGPT Plus subscription alongside it for Codex cloud tasks and

@codex

reviews. That combination costs $120 a month and covers both strengths. If you can only pay for one and you regularly hit limits, pick Codex Pro 200. If you can only pay for one and your work is mostly hard, cross-cutting changes, pick Claude Code.

This market moves fast. Astra, Sol, Opus 5.5 and Sonnet 5.5 shipped within one month of each other, and both companies changed plan limits this fall. After two weeks on either tool, check the usage dashboard (Settings, Usage on Claude; /status in the Codex CLI) and decide with your own numbers.

Sources

OpenAI, GPT-6 Astra launch post:

https://openai.com/index/gpt-6-astra/

OpenAI, Introducing GPT-6.1 Sol:

https://openai.com/index/introducing-gpt-6-1-sol/

OpenAI API, GPT-6.1 Sol model page:

https://developers.openai.com/api/docs/models/gpt-6.1-sol

OpenAI API, GPT-6 Astra model page:

https://developers.openai.com/api/docs/models/gpt-6-astra

OpenAI Help, ChatGPT Work and Codex:

https://help.openai.com/en/articles/20001275-chatgpt-work-and-codex

OpenAI Help, About ChatGPT Pro tiers: