Claude Code vs Codex: Opus 5.5 vs GPT-6 Sol

Anthropic and OpenAI replaced their default coding models ninety minutes apart on September 22, 2026. Anthropic shipped Claude Opus 5.5 and made it the Claude Code default the same day. OpenAI answered with GPT-6 Sol and GPT-6 Luna, halving the token price of its mid and low tiers. Any Claude Code vs Codex comparison written before that afternoon describes a lineup neither tool still defaults to.

This guide compares Claude Code vs OpenAI Codex on the models that ship today: pricing, context windows, vendor benchmarks, the first independent replication covering both new models, and workflow. Every figure comes from vendor documentation or a named third party, and the places where Anthropic and OpenAI report different numbers for the same model are flagged rather than smoothed over.

TL;DR

• Claude Code now defaults to Claude Opus 5.5 (September 22, 2026) at $4 per million input tokens and $20 output. That is 20% off Opus 5 per token, with cache reads cut 60% to $0.20. Claude Fable 5.1 remains the top tier at $10/$50.

• Codex now recommends GPT-6 Sol (September 22, 2026) at $2/$10, exactly half what GPT-5.6 Sol cost. GPT-6 Astra stays the frontier option at $10/$50, and GPT-6 Luna sits at $0.10/$0.50.

• The price gap reopened. Codex’s recommended model costs half of Claude Code’s per token, and OpenAI says the new rates are permanent rather than promotional.

• Anthropic reports Opus 5.5 at 66.4% on Terminal-Bench 4.0 against GPT-6 Astra’s 57.9% and Fable 5.1’s 55.8%. Artificial Analysis, running both new models on its own harness, puts Opus 5.5 ahead of GPT-6 Sol on agentic coding and behind it on cost per task.

• Claude Code is a supervised, local-first agent with deep hook and skill customization. Codex is an autonomous cloud executor with a Rust CLI, AGENTS.md support, and a free tier. Most experienced developers run both.

• CatDoes routes every prompt to the right model tier (Junior, Senior, Principal) so non-technical builders get the quality-versus-cost tradeoff handled for them.

Table of Contents

• Claude Code vs Codex: The Quick Verdict

• Side-by-Side Comparison Table

• Claude Code: Strengths and Limits

• OpenAI Codex: Strengths and Limits

• Benchmarks: What the Numbers Say

• Pricing and Token Efficiency

• When to Use Claude Code vs Codex

• From Code to a Shipped App

• Claude Code vs Codex FAQ

• Pick Your Agent, or Let One Pick for You

Claude Code vs Codex: The Quick Verdict

Claude Code is Anthropic’s coding agent. It started as a terminal tool and now runs across five surfaces that share one engine, one CLAUDE.md, and one settings file: the CLI, a desktop app for macOS, Windows, and Linux, the web and mobile apps, a VS Code extension, and a JetBrains plugin. Your code stays on your machine. The agent shows its reasoning, and since August 2026 it defaults to "auto" mode, where a classifier reviews proposed actions instead of stopping to ask you about each one.

Codex is OpenAI’s coding agent, and it made the opposite bet. The CLI is written in Rust, runs locally, and pairs with Codex cloud, where you hand off a task and get a branch or pull request back. In July 2026 the standalone Codex desktop app was folded into the ChatGPT desktop app, consolidating both under one product.

The shortest answer for late 2026: the two tools are close on capability and no longer close on price. Both carry roughly a million tokens of context, and both swapped their default model on the same afternoon. Anthropic’s own numbers put Opus 5.5 clearly ahead on agentic coding. OpenAI’s put GPT-6 Sol within a few points of the previous Claude frontier at half the token price. What separates the tools themselves has not changed: Claude Code is built to be supervised and deeply customized, Codex to be delegated to and run unattended.

Side-by-Side Comparison Table

Here is the comparison at a glance, current as of September 23, 2026. The sections below go deeper on each row.

Two rows do most of the work now. Codex is the only one of the two with a genuinely free tier and an $8 entry plan, and it is the only one that reads AGENTS.md. The third row is new: for the first time since the spring, the two tools’ recommended models are a factor of two apart on price.

Claude Code: Strengths and Limits

Claude Code reads your local filesystem directly and never uploads your repository to a cloud sandbox, which matters under an NDA or on proprietary code. Version 2.1.280, released alongside the model on September 22, 2026, makes Claude Opus 5.5 the default for Opus sessions, Opus subagents, and Opus-powered background work. Pro and Team Standard subscribers moved from Sonnet to Opus in the same release, so every paid plan now starts on the same model. All four current models (Fable 5.1, Opus 5.5, Opus 5, Sonnet 5) carry a 1M-token context window at a flat rate: a 900,000-token request bills at the same per-token price as a 9,000-token one.

What Claude Code does better than Codex:

• Cheaper long sessions. Opus 5.5 reads cache at $0.20 per million tokens, down 60% from Opus 5’s $0.50. On an agent loop that re-reads the same repository turn after turn, cache reads are most of the bill.

• Customization depth. Hooks fire on lifecycle events, including model-switch events, and can run conditionally. Skills are folder-based instruction packs loaded on demand, and custom slash commands were merged into them.

• Checkpointing. A snapshot is taken before every change. Esc-Esc or /rewind rolls back both files and conversation, and can resume from before a /clear.

• Subagents. Each gets its own context window, tool permissions, and model, and they nest up to five levels deep.

• Permission granularity. Six modes, from fully manual through plan mode to bypass, with OS-level sandboxing via macOS Seatbelt and Linux bubblewrap.

• Higher session limits. Anthropic raised the five-hour limits on Pro, Max, Team, and seat-based Enterprise plans with the 5.5 launch, and issued subscribers a rate-limit reset usable through October 22, 2026.

Where Claude Code falls short:

• No AGENTS.md. Anthropic still does not support the cross-tool AGENTS.md standard. The feature request has drawn roughly 5,000 GitHub reactions and public criticism from Shopify’s Tobi Lütke.

• Limits are still opaque. Anthropic says it raised the five-hour limits but publishes no absolute number for them or for the weekly cap that sits on top. Percentages you will find quoted for the September 2026 weekly changes trace to third-party trackers, not to Anthropic, so there is no reliable way to compare a Claude Code plan against a Codex one on volume.

• No free tier. Claude Code starts at the $20/mo Pro plan. Codex has a free tier and an $8 plan.

• The cheap-context edge is gone. Sonnet 5 at $2/$10 with a 1M window used to have no equivalent. GPT-6 Sol now matches it exactly on price with a slightly larger window and much stronger agentic scores.

• Tokenizer inflation. Claude 4.7 and later use a tokenizer that produces roughly 30% more tokens for the same text. Anthropic puts 1M tokens at about 555,000 words, against roughly 750,000 on earlier models, so headline per-token prices are not directly comparable across generations or vendors.

If you want a deeper look at how we route work across model tiers inside our own product, see our CatDoes vs Claude Code comparison.

OpenAI Codex: Strengths and Limits

Codex spans more surfaces than any competing agent: the Rust CLI, IDE extensions for VS Code, Cursor, Windsurf, JetBrains and Xcode, Codex cloud, the ChatGPT desktop and web apps, a mobile remote mode that drives a Mac from your phone, a TypeScript and Python SDK, a GitHub Action, and integrations with GitHub, GitLab, Slack and Linear. As of September 22, 2026 OpenAI recommends GPT-6 Sol for Plus, Pro, Business, Enterprise and Edu, and GPT-6 Luna for Free and Go.

What Codex does better than Claude Code:

• Half the token price. GPT-6 Sol costs $2/$10 against Opus 5.5’s $4/$20, with cache reads at the same $0.20. OpenAI told VentureBeat the rates are permanent rather than promotional, which is a change from the GPT-5.6 era.

• Free and cheap entry. A genuinely free tier plus an $8/mo Go plan, both running GPT-6 Luna. Claude Code has neither.

• AGENTS.md with real scoping. Codex merges a global file with per-directory project files, walking from repo root down to your working directory, with closer files overriding earlier ones under a 32 KiB combined budget.

• Autonomous cloud execution. Fire off parallel tasks in reproducible cloud environments and apply results back locally with codex cloud.

• Code review as a product. Comment @codex review on a pull request and Codex posts a standard GitHub review, deliberately flagging only P0 and P1 issues. A separate @codex security review runs a security pass.

• Migration path. Since August 2026 Codex can import an existing Claude Code, Claude Cowork, or Cursor setup directly.

Where Codex falls short:

• Long-context surcharge. Past 272K input tokens, Codex applies 2x input and 1.5x output rates to the entire request, on every GPT-6 model including Sol and Luna. Claude Code charges a flat rate across the full window. A default Codex session still reports roughly 258,000 usable tokens unless you raise the limit yourself.

• Reasoning is harder to audit. Astra uses a technique OpenAI calls opaque recurrence, and its own launch materials concede that "Astra’s written reasoning is harder to monitor than Sol’s." Chief scientist Jakub Pachocki framed it as monitorability getting harder as capability rises.

• Rollout is uneven. Older Codex CLI builds do not list the new models at all. Community reports put the floor at v0.156.0 for gpt-6-sol and gpt-6-luna to show up in codex debug models, and Enterprise and Edu administrators have to enable Luna before anyone can pick it.

• Sandbox escapes have been demonstrated. Security researchers chained prompt injection into host command execution across several agents including Codex during 2026. The specific findings were patched and bug bounties paid, but the class of attack is real.

• No plan mode equivalent. Codex has /review for read-only prioritized findings and a separate goal mode, but nothing that mirrors Claude Code’s approve-the-plan-before-execution flow.

Aider and Cursor split along a similar terminal-versus-editor line.

Benchmarks: What the Numbers Say

One caveat governs this entire section. Agentic coding benchmarks measure a model plus a scaffold, and the scaffolds differ: different revisions, run by different people, with different tool budgets and retry rules. Anthropic’s numbers come from Anthropic’s harness, OpenAI’s from Codex-style tooling, and moving either model into the other’s harness shifts the scores. Anthropic reports a standard error of 2.6 points on Terminal-Bench 4.0 and 3.5 to 5 points on Terminal-Bench-Science. Treat gaps under three points as noise.

There is one new wrinkle specific to September 22. OpenAI published its GPT-6 Sol comparisons against Claude Opus 5, which Anthropic had replaced ninety minutes earlier. Anthropic’s Opus 5.5 table, for the same reason, contains no GPT-6 Sol row. Neither lab was hiding anything; the models did not overlap long enough to benchmark each other.

Terminal-Bench 4.0 (agentic terminal tasks)

Opus 5.5 takes this one by 8.5 points over the best Codex model in the table, which is well outside Anthropic’s stated margin of error. Two caveats keep it from being a verdict. Every row is Anthropic’s own run, and OpenAI transcribed Astra at 57.7 in its own launch materials, so read that figure as "just under 58." Terminal-Bench 2.x scores are not comparable to 4.0 either. If you see GPT-5.5 quoted at 82.7% on Terminal-Bench 2.0, that is a different, easier benchmark, not evidence it beats Astra.

Independent numbers: Artificial Analysis

This is the part that did not exist a week ago. Artificial Analysis ran Opus 5.5 and GPT-6 Sol on its own harness at several effort levels, which makes it the first apples-to-apples look at the two September 22 releases.

Read the table by cost, not by row. Opus 5.5 at its default medium effort beats GPT-6 Sol at max on Terminal-Bench by 8.6 points and on the Intelligence Index by 3.7, and it costs about 26% more per task. Below roughly 44 on the Intelligence Index, Sol is cheaper than any Opus 5.5 setting that reaches the same score. Above it, Sol runs out of headroom entirely: max effort is the ceiling, and it lands below where Opus 5.5 starts.

The per-task costs also show why a per-token price comparison misleads. Artificial Analysis measured Opus 5.5 burning roughly 119,000 output tokens per task, against about 78,000 for Fable 5.1 and 27,000 for GPT-6 Astra. Opus 5.5 thinks longer, so its 20% price cut against Opus 5 landed it at roughly the same cost per task rather than below it. Cheaper tokens are not the same thing as a cheaper job.

Note also how far the two diverge on effort sensitivity. Opus 5.5 moves 7.1 points on Terminal-Bench going from medium to xhigh. Sol moves 13.6 points going the other way, from max down to xhigh. If you run Codex at a low effort setting to save money, you are giving up much more than the Claude equivalent would cost you.

DeepSWE and AutomationBench

Two benchmarks where both vendors published something, with the usual caveat that each ran its own scaffold.

DeepSWE is effectively a tie between Opus 5.5 and Astra, and it is the benchmark OpenAI used to fill the agentic-coding slot SWE-bench Verified used to occupy. Note the ordering oddity that survived the update: Fable 5.1, Anthropic’s most expensive model, still scores below Opus 5.5 here. Bigger is not automatically better for this workload, which is part of why Anthropic points coding users at Opus rather than Fable.

AutomationBench is the more interesting column, because it is the one place the two labs accidentally agree. Both Anthropic and OpenAI report Claude Opus 5 at exactly 26.9%, a rare cross-vendor match that makes the rest of the column more trustworthy than usual. On it, Opus 5.5 at 40.0% beats GPT-6 Sol at 33.2% but loses to GPT-6 Astra at 41.4%. OpenAI’s framing of the same gap is the one worth remembering: Sol reached 33.2% at roughly a ninth of what Opus 5 spent per task to reach 26.9%.

Where SWE-bench Verified went

If you came looking for a SWE-bench Verified comparison, it no longer exists in any form worth citing. Anthropic omitted it from the Opus 5, Fable 5.1, and Opus 5.5 launch materials alike, leading instead with Terminal-Bench, CursorBench and GDPval. OpenAI published no SWE-bench Verified score for GPT-6 Astra, Sol, Luna, or the GPT-5.6 family.

The reason is saturation. Top models had converged inside a single point of each other, at which stage the benchmark stops discriminating. Third-party leaderboards still list numbers in the 96 to 97% range for current models, but they are self-reported and they disagree with each other, in one case by more than four points for the same model. Any 2026 article quoting a precise SWE-bench Verified figure for Opus 5.5 or GPT-6 Sol is quoting something neither lab published.

The older generation head-to-head

The most-cited independent comparison of these two tools predates the current models entirely, and it is worth reading with that caveat attached. In a survey of 500-plus developers conducted during the Opus 4.x and GPT-5.x era, 65% preferred Codex for daily work, while blind reviews of the code produced rated Claude Code cleaner and more idiomatic 67% of the time against Codex’s 25%. A published Express.js refactor test from the same period had Claude Code finishing in 1 hour 17 minutes on 6.2M tokens and catching a race condition, against Codex at 1 hour 41 minutes on 1.5M tokens, missing the bug.

Those figures describe retired models and a pricing structure that no longer applies. The qualitative finding has held up, though, and the Artificial Analysis effort curves above are a reasonable quantitative echo of it: Claude tends to spend more and get further, Codex tends to get more done per dollar.

Pricing and Token Efficiency

The single biggest change of September 22 is that the middle of the market split in two. Anthropic cut Opus by 20% per token; OpenAI cut Sol and Luna by 50%. The frontier tier did not move.

Three things changed at once here. OpenAI’s recommended model is now half the price of Anthropic’s. Anthropic’s cache-read advantage, which used to be its clearest structural win, has been matched: Opus 5.5 and GPT-6 Sol both read cache at $0.20. And Sonnet 5, which was the cheapest million-token frontier-class model anywhere, is now tied by GPT-6 Sol on price and beaten by it on agentic benchmarks.

Anthropic still holds the cache advantage at the top: Fable 5.1 reads cache at $0.25 against Astra’s $1.00, a 4x gap on the line item that dominates long agent sessions. Full rates are published on Anthropic’s pricing page and OpenAI’s API pricing page.

Two structural details still matter more than the headline rates, and neither shows up in a price-per-million comparison. Codex applies 2x input and 1.5x output pricing to the entire request once you exceed 272K input tokens, so a single long session gets expensive fast; Claude charges its standard rate across the full 1M window. Pulling the other direction, Claude’s post-4.7 tokenizer emits roughly 30% more tokens for identical text. Both effects show up on the invoice.

Subscription plans

Both meter the same way: a rolling five-hour window with an additional weekly cap. Anthropic publishes no absolute numbers, so treat any article quoting "X hours per week" for Claude Code as an estimate. OpenAI does publish per-window message ranges on its Codex pricing page, and they moved with the new models. On Plus you now get roughly 5 to 45 Astra messages per five-hour window, 15 to 150 on GPT-6 Sol, and 350 to 3,000 on GPT-6 Luna. Pro 20x multiplies those by twenty. OpenAI stresses these are estimates, not fixed limits, because tool use, retrieval, and caching all change what a message consumes.

Anthropic’s usage is pooled across claude.ai, Claude Code, the desktop app and Cowork, so there is no separate Claude Code allowance. Codex moved from per-message pricing to token-based credits in April 2026, and Plus and Pro users can buy additional credits rather than upgrading. Codex also still supports plain API keys for the CLI, SDK and IDE extension, though doing so gives up every cloud-backed feature including GitHub code review and Slack.

Prompt caching and context economics

Cache reads are where the real money is on both platforms, and September 22 was the day Anthropic’s lead there stopped being automatic. Opus 5.5 reads cache at $0.20 per million tokens, a 60% cut from Opus 5’s $0.50 and 5% of its own input rate. GPT-6 Sol reads cache at the same $0.20, which is 10% of its input rate. Cache writes are where they separate: $5 per million on Opus 5.5 for a five-minute entry, against $2.50 on Sol.

OpenAI also fixed a practical annoyance with GPT-6: changing effort or enabling tools mid-conversation no longer breaks the cache, and reused prefixes qualify within a 30-minute window. If your agent loop toggles reasoning effort between steps, that alone can matter more than the per-token gap.

Anthropic offers a 50% batch discount and a fast mode on Opus 5.5 at $8/$40, which draws from usage credits rather than counting against plan limits. OpenAI matches the 50% discount on batch and flex modes and charges 2x standard for its own fast mode, putting fast GPT-6 Sol at $4/$20 — the same rate as standard Opus 5.5.

When to Use Claude Code vs Codex

Use Claude Code when:

• The change is high-stakes (auth, payments, security-sensitive code) and you want to approve a plan before execution.

• The work is hard enough that effort level matters. Opus 5.5 keeps climbing as you raise effort; Sol tops out sooner.

• You work with data that cannot leave your machine.

• You want programmable hooks, skills, and nested subagents for custom governance.

• Your sessions routinely run past 272K tokens, where Codex starts charging 2x input on the whole request.

Use Codex when:

• The task is well scoped and can run unattended in a cloud sandbox.

• Cost per task is the binding constraint. GPT-6 Sol reaches most of Opus 5.5’s quality at half the token price.

• You want automated pull request review and security passes in GitHub.

• You are running high volume, where GPT-6 Luna at $0.10/$0.50 has no Anthropic equivalent.

• You want to start free or at $8/mo, or your team already standardizes on AGENTS.md across tools.

Use both (still the most common answer):

"Claude Code for architecture, Codex for keystrokes" remains the shorthand, and the new pricing sharpens it rather than settling it. Use Claude Code to design and review the important 20% of changes, and Codex to grind through the mundane 80% at half the cost. The two companies clearly expect this: OpenAI ships a Codex plugin that runs inside Claude Code, and added direct import of Claude Code configurations in August 2026.

For a concrete hybrid workflow applied to indie mobile app development, our vibe code a mobile app guide walks through where each tool fits in the build loop.

From Code to a Shipped App

Neither Claude Code nor Codex can publish an app to the App Store. Both write and run code on a machine you control, and both stop at the point where working code has to become something other people can install. Neither one provisions a database, points a custom domain at your site, signs a release build, or submits it to Apple or Google for review.

That last mile is its own job with its own rules. It needs a backend with authentication and file storage, a signed release build, an App Store Connect or Play Console listing, screenshots at the right sizes, and a review process that rejects submissions for reasons unrelated to code quality. A coding agent hands you a repository. It does not hand you something a stranger can download.

That gap is what CatDoes covers. You describe the app or website in plain English, an agent builds it, wires up the backend, and ships it to the App Store, Google Play, or the web on your own domain. CatDoes Cloud (database, auth, storage, edge functions, realtime) is included on every plan, so there is no second service to configure.

• No local toolchain. No Xcode, no Android Studio, no API keys to rotate, and no developer console to learn before the first build runs.

• A free tier that deploys. The Free plan builds and deploys a web app at no cost with CatDoes Cloud included. Starter at $50/mo and above add native deployment to the App Store and Google Play.

• Keep the code. GitHub sync and code export are available on the higher plans, so the codebase stays yours to hand to Claude Code or Codex later.

• Submission is part of the job. On plans with native deployment, the agent handles the build, the signing, and the store submission rather than leaving you a zip file.

The three are not really competing for the same slot. Claude Code is where you design and review the parts of a codebase you need to understand. Codex is where scoped changes run unattended. An agent like CatDoes is for when the deliverable is a live app rather than a diff. If you want the longer version of what that last step covers, we wrote up what CatDoes does end to end.

Claude Code vs Codex FAQ

Which is better for beginners, Claude Code or Codex?

Neither, if the goal is to ship a working app without reading code. Both tools assume a developer is reviewing the output. Codex is easier to try because it has a free tier, but that lowers the cost of entry, not the skill requirement. If you have never written code, use an AI-native app builder that handles model routing, backend, and deployment for you, then move to Claude Code or Codex once you need to customize.

Does Claude Code work offline?

No. Claude Code runs your code locally but sends inference requests to Anthropic's API, so it needs an internet connection. What stays local is your codebase, filesystem, and command execution.

Can I use Claude Code and Codex on the same project?

Yes, and many developers do. OpenAI ships a Codex plugin that runs inside Claude Code, and since August 2026 Codex can import an existing Claude Code setup directly. Git branches keep the outputs from conflicting. The main friction is configuration: Codex reads AGENTS.md, Claude Code reads CLAUDE.md, and you will end up maintaining both.

Should I use Claude Opus 5.5 or GPT-6 Sol?

Opus 5.5 if quality per task matters most, GPT-6 Sol if cost per task does. On Artificial Analysis’s independent runs, Opus 5.5 at its default medium effort scores 52.5% on Terminal-Bench 4.0 for $1.34 a task, against GPT-6 Sol at max effort scoring 43.9% for $1.06. Sol is the better value anywhere below roughly 44 on the Intelligence Index, and it cannot reach the top of Opus 5.5’s range at any effort setting. For frontier work that justifies the price, GPT-6 Astra and Claude Fable 5.1 both cost $10/$50.

What is the cheapest way to try both?

Codex has a free tier, so the true floor is $20/mo: Claude Pro plus Codex Free, which now runs GPT-6 Luna. Claude Pro drops to $17/mo equivalent if you pay annually. For a fuller test of both, Claude Pro at $20 and ChatGPT Plus at $20 comes to $40/mo, less than most single-tool mid-tier plans. Codex also offers an $8/mo Go tier between free and Plus. On the API side, GPT-6 Luna at $0.10/$0.50 makes exploratory testing nearly free.

Do Claude Code or Codex replace CatDoes?

Not for mobile app builders. CatDoes handles the full stack: native iOS and Android output, CatDoes Cloud (database, auth, storage, edge functions, realtime), App Store and Google Play submission, and a checkpoint system tuned for iteration. Claude Code and Codex are general-purpose coding tools that assume you have already set up all of that yourself.

Pick Your Agent, or Let One Pick for You

Claude Code vs Codex was converging all summer. September 22 pulled it apart again, and on price rather than capability. Anthropic’s answer was a better model at a modest discount; OpenAI’s was a nearly-as-good model at half the price. Both shipped the same afternoon, and neither benchmarked against the other.

What that leaves you with is a clean split. Claude Code owns supervised, customizable work and the top of the quality curve, where Opus 5.5 keeps improving as you spend more effort on a problem. Codex owns autonomous execution, pull request review, and the entire bottom half of the cost curve, where GPT-6 Sol and Luna have no Anthropic equivalent. Running both is still the answer for most working developers, and it now costs less than it did a week ago.

If you are building a mobile app or website and do not want to track which frontier model shipped this week, try CatDoes free. Describe what you want to build, and the right agent tier (Junior, Senior, or Principal) runs each part of the job, so you get top-tier quality where it matters without burning premium credits on a button color change.