Codex vs Claude Code: the real differences, and what six side-by-side runs showed

Codex and Claude Code are close to feature parity as agent harnesses: both read and edit your files, run commands, connect to MCP servers, load Agent Skills, run hooks and subagents, work headless in scripts, and hand tasks to the cloud. What separates them is the models behind them, which safety boundary is on by default, how far each lets you customize the agent loop, and how your plan meters usage. When we ran both CLIs on the same six coding tasks, both ended up passing every hidden test (one task after a follow-up review), and Codex was faster on five of them and used about a fifth of the list-price cost overall; most of the time gap came from one open-ended task where the two did different amounts of work. The more useful finding: passing the same tests, they shipped different gaps, and each found a real bug when it reviewed the other's work.

The short version: choose Codex if you already pay for ChatGPT, want an OS-level sandbox around the agent's commands from the first run, want an open-source CLI, or want image generation in the same allowance. Choose Claude Code if you prefer Anthropic's models, want a classifier approving routine actions by default, want browser checks from the terminal, or need hook events or interface mods Codex lacks. If you can, use both: OpenAI publishes a plugin that runs Codex reviews from inside Claude Code (codex-plugin-cc), and in our run a second agent's review caught bugs the tests missed, in under a minute each.

Capabilities, prices and versions were read from OpenAI's and Anthropic's documentation, pricing pages and GitHub releases on 20 October 2026, signed out, in the US. The six-task run is ours, from the same day; its method and limits are in that section.

What each is

Claude Code is Anthropic's coding agent. It runs in the terminal, in VS Code and JetBrains, in the Code tab of the Claude desktop app, in the browser at claude.ai/code and from the Claude mobile apps (Claude Code overview, platforms). The CLI is proprietary: its public repository holds the changelog, plugins and issue tracker, and its licence says "All rights reserved" (LICENSE.md). The current release is 2.1.304, published 19 October 2026 (releases). It needs a paid Claude plan (Pro, Max, Team or Enterprise), an Anthropic Console API key, or Claude through Amazon Bedrock, Google Cloud or Microsoft Foundry; the free Claude plan does not include it (setup).

Codex is OpenAI's coding agent. It runs as an open-source CLI, an IDE extension for VS Code and its forks, the Codex side of the ChatGPT desktop app on macOS, Windows and Linux, in the cloud from chatgpt.com/codex, and from the ChatGPT mobile app (Codex CLI, ChatGPT desktop app, Codex Cloud). The CLI is written in Rust and licensed Apache-2.0; the IDE extension and the cloud service are not open source (openai/codex, open-source components). The current CLI release is 0.163.0, published 15 October 2026 (releases). It is included in every ChatGPT plan, from Free (desktop app only, as it rolls out) to Pro (Codex pricing).

What is Codex, and how is it different from ChatGPT?

Codex is the agent, not a model: the name belonged to a 2021 code model (OpenAI, 2021), but today you pick the model underneath, and OpenAI recommends GPT-6.1 Sol on paid plans (Codex models).

ChatGPT is the account and the app; Codex is one of three ways to work inside it. OpenAI's own guide splits them into Chat for conversation, Work for finishing broader deliverables with tools, and Codex for developer work with technical detail such as diffs and commands (use ChatGPT). In the desktop app you choose ChatGPT or Codex when you start (desktop app). The plan is shared: "ChatGPT Work usage inside ChatGPT uses the same pricing, credits, and usage limits as Codex" (Codex pricing). So if you pay for ChatGPT Plus, you already have Codex; the question is only which surface you open.

At a glance

Sources: Claude Code model configuration, permission modes, sandboxing, memory, skills, MCP, hooks, subagents, computer use; Codex models, pricing, approvals and security, customization, MCP server removal, hooks, subagents, computer use, image generation; all read 20 October 2026. Hook counts are the event types listed in each vendor's hooks reference that day.

What we saw running both on the same six tasks

By the end, both tools passed every hidden acceptance test, ours for the small project and the maintainers' own for click; one task took a follow-up review message for both. They still shipped different gaps, and when each reviewed the other's work, each found a real bug. That is the short account of six tasks, one run per tool each, on 20 October 2026: a sample, not a benchmark. The project, prompts, hidden tests, transcripts and diffs are in a download (ZIP) so you can rerun it.

The setup. Four tasks ran on srtkit, a Python command-line tool for SubRip subtitle files that we wrote for this (about 140 lines, 14 unit tests): fix a bug that made two tests fail; add a lint command to a written spec; replace tuples with a frozen dataclass across the package and its tests without changing output; and an open-ended one, "Add WebVTT support... Handle real-world WebVTT files, not just the files srtkit itself writes." The last two ran on a real, unfamiliar codebase, pallets/click (about 12,700 lines of source and 2,100 tests), each at the commit just before a recent upstream fix. Task 5 rewrote pull request 3884, merged on 6 October 2026, as a bug report. Task 6 was a two-turn session built on pull request 3865, merged on 12 September 2026: a one-line bug report, then, in the same session, a maintainer-style review asking for a different rule and edge cases. For each task both tools started from a fresh copy of the same commit, with no later history. They ran non-interactively with approvals skipped (claude -p --permission-mode bypassPermissions, codex exec --dangerously-bypass-approvals-and-sandbox) and without choosing a model: Claude Code 2.1.300 used Opus 5.5 at medium effort, which is both the setting on our machine and Opus 5.5's default; Codex CLI 0.162.1 used GPT-6.1 Sol with no reasoning effort set. Both had our machine's usual configuration, including installed plugins and skills; neither called a skill, MCP tool or subagent, and every action in the transcripts is a shell command or a file edit. Afterwards we ran each project's own tests plus hidden tests neither tool saw: five for the lint spec; three plus byte-for-byte output checks for the refactor; four for WebVTT, covering conversion, statistics and round trips (not shift); and for each click task, the tests the maintainers wrote in that pull request, unchanged.

The last column is an API list-price equivalent, not what a subscription charges per task. Claude Code reports its own estimate at Anthropic's list prices; Codex reports token counts, which we priced at GPT-6.1 Sol's list rates of $2 per million input tokens, $0.10 cached and $10 output (OpenAI API pricing). Wall time includes each CLI's start-up. Lines include tests and documentation; for task 6 they are the final diff after both turns.

Precise tasks: nearly interchangeable. On tasks 1 to 3 both found the same one-line bug (minutes not wrapping at 60 past the hour) and wrote the same fix, met the lint spec exactly, and did the refactor without changing a byte of output. On the refactor, both saved the command output before the change and compared it afterwards without being asked. Codex was faster on two of the three, and its list-price cost was about a third of Claude Code's or less each time.

The real codebase: both found the fix the maintainers wrote. In click, each tool located the two methods involved in a 3,800-line module and made essentially the change that was merged upstream, in under a minute. Claude Code also added a changelog entry, as the maintainers had, and checked that its new tests failed without the fix. Codex added more test cases and finished at under a third of the list-price cost.

A two-turn change: same fix, different disclosure. In task 6, both tools answered the bug report the same way, with a list of known abbreviations such as "vs." and "e.g.", which passed 34 of the maintainers' 36 test cases; the maintainers had chosen a general rule instead. After the review message, both switched to the rule and passed all 36, and both did it by editing an existing test whose input contradicted the new rule, which the review had asked them to keep passing. Claude Code flagged it as a conflict in its summary: "There's one conflict: the request to keep all existing tests passing couldn't be fully met," with the test it changed and the one-line alternative. Codex mentioned it once in a progress message ("I also capitalized the next word in an older sentence-boundary fixture to match the new rule") and left it out of its final summary. The maintainers made the same edit upstream, so neither change was wrong; the difference is whether it reaches a reviewer as a decision to check. Whichever tool you use, it is worth asking it to list any existing tests it changed and any instruction it could not follow.

The open-ended task: same tests passed, different gaps. Codex wrote 215 lines in about a minute and said in the README what it left out: "Conversion does not translate WebVTT markup into SRT styling." Claude Code took three and a half minutes, wrote 614 lines, took the test suite from 14 tests to 51, and listed its judgment calls, for example:

Converting drops some markup. WebVTT → SRT keeps <b>/<i>/<u> and decodes &amp;
and similar. It removes speaker (<v Name>), class, language, ruby and timestamp
tags, keeping their text.

Neither behavior was in our tests, but it shows on ordinary captions. We converted the same WebVTT cue with each version:

Input cue text (WebVTT):  <v Host>Thanks &amp; welcome</v>
Claude Code's SRT output: Thanks & welcome
Codex's SRT output:       <v Host>Thanks &amp; welcome</v>

Each reviewer caught the other. We then had each tool review the other's WebVTT work without editing it. codex review --uncommitted ran for 22 seconds in its default read-only sandbox, where nine of the 51 tests errored for lack of a writable temporary directory, and returned one finding: ruby annotations split across two cue lines leak their reading text into the SRT output. Claude Code's /code-review, with full access, took 53 seconds (about $0.29 at list prices) and returned ten findings, led by a regression: Codex's version made stats and shift refuse any file not ending in .srt or .vtt, so stats captions.txt, which worked before, now exits with an error. Most of the other nine were stricter readings of the WebVTT spec. We confirmed both headline bugs by hand.

How each reported back. Codex's summaries were a few lines: "Fixed srtkit/timecode.py: the minutes field now wraps at 60 instead of showing total elapsed minutes." Claude Code's ran to a page: root cause with a worked example, the changes, and decisions to check, including subtleties nobody raised, such as a frozen dataclass holding a list still being mutable. Its WebVTT summary also miscounted its own work, reporting 27 new tests where the suite grew by 37, a reminder to check the summary against the diff.

What this does and does not show. Six single runs cannot measure reliability, and the tasks were short. The reasoning settings may also have differed: Codex ran with no effort set and logged between 0 and 510 reasoning tokens per task, so we ran the WebVTT task once more with Codex set to medium, where it logged 442. It opened the W3C WebVTT specification first, took 103 seconds, wrote 309 lines, grew the suite to 28 tests, came to about $0.14 at list prices and again passed all four hidden tests, but it still passed the speaker tag through and still refused .txt files. That run produced more code and tests, still in half Claude Code's time and at a fifth of its list-price cost, but not the same choices. Skipping approvals means these runs say nothing about prompts, sandboxes or how either feels interactively, and the tasks were too short to test long sessions, context compaction or front-end work, with one follow-up correction between them; for those, the documented differences in the next section are all we can offer. Both CLIs ran with our machine's existing configuration, which can shape context even when nothing is called, and the rate-limit data both CLIs logged shows our accounts had used up their weekly plan allowance, so the runs drew on extra usage; the cost column is still a list-price estimate. What the runs do show: on these tasks, passing tests did not mean the same result, and a second agent's review found what the tests missed.

Public benchmarks cannot settle this pair today: neither default model has an entry on the Terminal-Bench 2.1 leaderboard read on 20 October 2026, and the vendors submit their own runs. Its rows do suggest the harness matters, with GPT-5.5 at extra high effort scoring 83.2% in Codex and 78.0% in the generic Terminus 2 harness (Terminal-Bench 2.1).

Decide by job

Models and reasoning

Claude Code officially supports Claude models only. The default on every paid plan is Opus 5.5; you can switch to Sonnet 5.5, Haiku 5.5 or Fable 5.1, Anthropic's model for the longest tasks, and set effort from low to max (model configuration). Through a gateway it can reach Claude on Bedrock, Google Cloud or Foundry, but Anthropic "doesn't support routing Claude Code to non-Claude models through any gateway" (LLM gateway). Opus 5.5 has a 1M-token context window, and Claude Code compacts the conversation automatically near the limit, around 967K tokens by default (model configuration).

Codex recommends GPT-6.1 Sol on paid plans, with GPT-6 Astra for the hardest work and GPT-6 Luna for quick, repeatable tasks; reasoning runs from Light to Ultra, where Ultra splits work across subagents (Codex models). It can also run open-weight models locally through Ollama or LM Studio with --oss, or any provider that speaks OpenAI's Responses API (advanced configuration). Codex compacts at a threshold you can set (model_auto_compact_token_limit), and in our runs its local session logs reported a 475,000-token context window for GPT-6.1 Sol, against the model's 1.05M on the API (configuration reference, GPT-6.1 Sol).

Cost and plans

Both are bundled into subscriptions that also pay for the vendor's chat app, and both accept a pay-as-you-go API key. As of 20 October 2026:

Sources: Claude pricing, What is the Max plan, Codex pricing, About ChatGPT Pro tiers, read 20 October 2026.

The metering differs more than the prices. Claude Pro and Max have a five-hour session limit and a weekly limit, shared between Claude chat and Claude Code (using Claude Code with Pro or Max). Codex usage is shared with ChatGPT Work; Plus has a five-hour window, weekly limits may also apply, and OpenAI publishes rough ranges, for example 15 to 160 local GPT-6.1 Sol messages per five hours; the Pro plans currently have no five-hour limit (Codex pricing). Neither vendor promises a fixed number of tokens on its individual plans, so token counts like the ones in our table tell you which tool is cheaper per task at list prices, not how many tasks a plan buys. If you have a ChatGPT plan already, Codex costs nothing extra to try; Claude Code needs at least Pro or an API key.

If you pay for neither, remember that each $20 plan also buys the vendor's chat app, so the one you would use for everything else is a reasonable tiebreaker.

Permissions and sandboxing

The defaults point in opposite directions. Our runs skipped approvals in both tools, so this section rests on the documentation, not on what we saw.

Codex starts inside an operating-system sandbox. In a version-controlled folder it can read files, edit and run commands inside the workspace, and must ask before writing outside it or using the network; .git and .codex stay read-only even inside the workspace (approvals and security). The sandbox is enforced by Seatbelt on macOS, bubblewrap and seccomp on Linux, and Windows' native isolation, so it applies to every process a command starts, not only to the agent's own tools. The approval policy is a separate setting: on-request (the default), never, or granular rules per kind of request, and an optional auto-review mode sends eligible requests to cross the sandbox boundary to a reviewing model instead of you; what it approves runs as an escalation, as if you had approved it (auto-review). Even codex review in our cross-review ran read-only by default.

Claude Code starts interactive terminal and VS Code sessions in auto mode (version 2.1.283 and later; claude -p and the SDK start in Manual): a second model, the classifier, reviews actions and lets routine ones through without asking you (permission modes). Its OS sandbox for shell commands, built on the same Seatbelt and bubblewrap mechanisms, "is off by default" and is turned on with /sandbox or a setting (sandboxing). Its modes are Manual, acceptEdits, plan, auto, dontAsk for locked-down scripts, and bypassPermissions, with allow, ask and deny rules for specific tools and commands on top. Deny rules hold even in bypassPermissions. Native Windows commands are not sandboxed; Anthropic points Windows users to WSL2.

Choose Codex if you want a hard boundary around the agent's commands from the first run, with escalations only when you approve them, without configuring anything. Choose Claude Code if you want a reviewing model in the loop by default and fine-grained rules you control; turn on /sandbox as well if you let it run unattended.

Extending it: MCP, skills, plugins, hooks and subagents

The two have converged here, and the formats are compatible enough that one setup can serve both.

• MCP servers. Both are MCP clients: claude mcp add writes to .mcp.json or ~/.claude.json, and codex mcp add writes [mcp_servers] tables to ~/.codex/config.toml (Claude Code MCP, Codex MCP). Only Claude Code can also act as a server (claude mcp serve), and it exposes Claude Code's tools rather than the agent itself. Codex's own MCP server mode was removed (MCP server removal).
• Skills. Both implement the Agent Skills standard: a folder with a SKILL.md and optional scripts, loaded only when relevant (agentskills.io). Claude Code looks in .claude/skills and ~/.claude/skills; Codex looks in .agents/skills and ~/.agents/skills and follows symlinks (Claude Code skills, Codex skills). Claude Code adds its own frontmatter fields outside the standard, such as running a skill in a subagent. Codex has deprecated its custom prompts in favour of skills (custom prompts).
• Plugins. Both bundle skills, MCP servers and hooks into installable plugins with marketplaces (Claude Code plugins, Codex plugins). Claude Code plugins can also be mods, JavaScript or TypeScript event handlers that change how Claude Code looks and behaves (mods).
• Hooks. Both run scripts at lifecycle events with the same core names: SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, Stop, subagent and compaction events (Codex hooks, Claude Code hooks). Claude Code lists 33 event types to Codex's 12, adding events for failed tool calls, file and directory changes, worktrees, config changes and model switches. Codex can also call an MCP tool as a hook.
• Subagents. Both delegate to subagents with their own context, and both let you define custom agents: Markdown files in .claude/agents/ for Claude Code, TOML files in .codex/agents/ for Codex (Claude Code subagents, Codex subagents). Claude Code also has agent teams, independent sessions that message each other, still experimental and off by default (agent teams).

This only decides the choice at the edges: a linter after each edit or a check when a turn stops works in both. Choose Claude Code if you need hooks on events Codex does not expose, such as failed tool calls, file changes or worktree creation, or want to change the interface with mods.

Local, cloud and phone

Both run locally against your files and both can hand a task to a cloud machine that keeps working when your laptop sleeps: Codex Cloud gives each task its own workspace in an environment you publish, with network access you configure per environment (Codex Cloud); Claude Code on the web runs on Anthropic-managed machines or your organization's self-hosted environment, and claude --teleport pulls a cloud session into your terminal (Claude Code on the web). Both phone apps can start, steer and approve work in the cloud or on a connected computer of yours, through Codex's mobile app (subject to rollout and workspace settings) or Claude Code's Remote Control (Codex on mobile, Remote Control). The remaining differences are in hosting, where Claude Code can use your organization's own environment, and in moving sessions between surfaces.

Scripts, CI and code review

Both have a headless mode (claude -p, codex exec) with JSON output, an SDK in TypeScript and Python, and a GitHub integration that answers mentions in pull requests (@claude, @codex review) (Claude Code headless, Codex non-interactive mode, Codex SDK, Claude Code GitHub Actions). For local review, Codex has a dedicated codex review command that reports findings without touching the working tree, and Claude Code has /code-review, which can also apply fixes (Codex code review, Codex CLI reference, Claude Code local review).

For checking a web front end in a real browser, Claude Code drives Chrome from the CLI or VS Code through the Claude in Chrome extension, while Codex's built-in browser is only in the ChatGPT desktop app, not the CLI or IDE extension (Claude Code with Chrome, Codex browser).

Both run unattended in CI without stopping for approval. Choose Codex if you want those runs inside its sandbox by default; choose Claude Code if you want browser checks from the terminal.

Creative and non-coding work

Both are general agents with a shell, so anything scriptable is in reach, from batch ffmpeg edits to Blender scenes built through its Python API. Three differences matter for this kind of work. Codex generates images itself with gpt-image-2, drawing on the same Codex allowance three to five times faster than a normal turn (image generation). Claude Code has no built-in photo or illustration generation: Anthropic says Claude "doesn't generate photos or illustrations the way image-generation tools do" (Can Claude produce images?), though either agent can call an image API or MCP server you add. Codex's computer use, which operates apps through the screen, lives in the ChatGPT desktop app on macOS and Windows (computer use); Claude Code's works in the CLI on macOS as a research preview on Pro and Max, in interactive sessions only (Claude Code computer use). And for driving creative apps directly, both use the same MCP servers, so the setups in our guides to Blender, Premiere Pro, DaVinci Resolve or Ableton Live work in either.

Choose Codex if you need generated images inside the same session.

Using Claude Code and Codex together

The pattern that paid off in our run is one agent writing and the other reviewing, with both sharing one set of instructions, skills and MCP servers.

One writes, the other reviews. From inside Claude Code, the simplest route is OpenAI's own plugin, which adds /codex:review, an adversarial review, and commands to hand a task to Codex and collect the result; its usage counts against your Codex limits (codex-plugin-cc):

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

The other direction needs no plugin: run codex review --uncommitted after Claude Code finishes, or /code-review in Claude Code after Codex does (Codex code review, Claude Code local review). Keep one writer per working tree at a time, or give each its own git worktree, so they do not undo each other's edits. The older recipe of adding Codex to Claude Code as an MCP server no longer works: codex mcp-server was removed (MCP server removal).

One instructions file. Put project rules in AGENTS.md. Codex reads it natively. Claude Code reads it when there is no CLAUDE.md, .claude/CLAUDE.md or CLAUDE.local.md in the working directory or above it; otherwise keep a CLAUDE.md that imports it with a line reading @AGENTS.md (Claude Code memory, Codex AGENTS.md).

One skills folder. Keep skills in .agents/skills, where Codex looks, and link Claude Code's folder to it, so both load the same SKILL.md files (Codex skills, Claude Code skills):

mkdir -p .claude && ln -s ../.agents/skills .claude/skills

Stick to the frontmatter fields in the Agent Skills spec if a skill must behave the same in both; Claude Code's extra fields are outside it (Agent Skills specification).

The same MCP servers. Register each server in both with claude mcp add and codex mcp add, since one stores JSON and the other TOML. If you are moving from Claude Code, Codex's /import lets you pick supported instructions, settings, skills, plugins, MCP servers, hooks, subagents and up to 50 recent chats to bring over, without changing your Claude Code setup; some plugins and connections need setting up again afterwards (import from another agent).

Both in one app. Voyager, the desktop app our team builds, runs both Claude Code and Codex on their official runtimes with your existing Claude and ChatGPT sign-ins; their usage counts against those plans as it would anywhere else, at no extra charge. It is built for creative work such as video, design and audio, and is a Mac app first, with Windows and Linux in alpha.

Which to choose

Sources: Codex security, Claude Code permission modes, Claude Code hooks, Codex hooks, Codex pricing, Codex image generation, codex-plugin-cc, and our run above; read 20 October 2026.

Frequently asked questions

Is Codex or Claude Code free? Codex is: ChatGPT Free and Go include it in the desktop app with GPT-6 Luna as it rolls out, and Plus at $20 a month adds the CLI, IDE extension, web and iOS with GPT-6.1 Sol (Codex pricing). Claude Code is not: it needs Claude Pro ($20 a month, or $17 billed annually) or higher, or an API key (Claude pricing, setup). Prices as of 20 October 2026.

Can Claude Code use GPT models, or Codex use Claude? Claude Code, not officially: Anthropic does not support routing it to non-Claude models (LLM gateway). Codex accepts custom providers that speak OpenAI's Responses API and local models through Ollama or LM Studio, but OpenAI does not document Claude as a provider (advanced configuration). To use both model families, run both tools.

Which is cheaper? At $20 a month the entry plans cost the same, and Codex is also on ChatGPT's Free and $8 Go plans (Codex pricing, Claude pricing). Across our six tasks, Codex came to about $0.48 at API list prices against $2.20 for Claude Code, with the models at different reasoning settings; neither vendor promises a fixed number of tokens on its individual plans.