Both OpenAI and Anthropic supercharged their models and harnesses recently. In this article, we will explore how Claude Code and Codex compare. These two harnesses offer similar feature sets, but with different implementations.

The model is now one part of the story and there are things like context management, memory, tool use, subagents, and execution environments increasingly define how capable the coding agent actually feels.

Comparison that matters in 2026

It's a comparison of two coupled systems: the model that generates the response, and the harness that decides what that model can see and do.

Codex runs OpenAI models. Claude Code runs Anthropic models. Neither harness will run the other's model. Many coding-agent leaderboards measure a coupled model-and-harness configuration. Unless the harness, tools, permissions, and retry budget are held constant, the result should not be attributed to the underlying model alone.

Some Developer focused areas are

• Correctness on your tasks: The only question most people actually care about, and the one nobody can answer for you. Artificial Analysis's Coding Agent Index, both Fable 5.1 (max) in Claude Code and Astra (max) in Codex score 62.

• Project-context retention: Whether project knowledge remains available and is followed across sessions. This can come from checked-in instructions such as AGENTS.md/ CLAUDE.md, generated local memory, or both. The harness determines what is reloaded; the model still has to use it correctly.

  • Claude Code loads the first 200 lines or 25KB of MEMORY.md, whichever comes first, and re-reads the root CLAUDE.md after compaction.

  • Codex assembles an AGENTS.md chain before work begins and keeps its local memory store separate. The memory storage differs, based on if you are using the desktop app or web/cli/vs code extension.

• Supervision Required: Supervision refers to the permission, approval, sandbox, and safety escalation frameworks that dictate how closely a human (or supervisor process) monitors and restricts agent actions. Claude Code defaults to a human-in-the-loop supervised model. It enforces boundaries at the tool level using configurable permission scopes. OpenAI's Codex CLI separates supervision into two distinct layers: Sandbox bounds (what the agent is technically restricted to touch) and Approval policy (when it must prompt you for human intervention).

• Cost per completed task: The base API list price is identical. Cost per completed task is not. $10 per million input tokens and $50 per million output on both sides. That difference is apparent at how agents actually spend tokens. Fable 5.1 reads cached context at $0.25 per million; Astra reads it at $1.00. Artificial Analysis Coding Agent Index based on current per-token API pricing sheds more light.

So these and some more aspects, we will explore in the article.

Codex vs Claude Code at a glance (The Harness)

OpenAI documents a 1.05-million-token context window, 128K maximum output, and five reasoning levels for GPT-6 Astra. Anthropic documents a 1-million-token window, 128K maximum output, always-on adaptive thinking, and a default high effort for Claude Fable 5.1. Both list the same base input and output price.

Product surfaces are a dated snapshot, not a promise that every feature exists on every plan. A reproducible benchmark would also pin client builds, reasoning settings, repository commits, permissions, and budgets.

What are OpenAI Codex and Claude Code?

OpenAI Codex

Codex is an agentic software-engineering system available through a CLI, editor integrations, a desktop app, and cloud execution. It can inspect repositories, edit files, run commands and tests, use Git, and return a reviewable diff.

Inside your terminal, move to the desired repository and type in this command.

Codex opens in your current directory and asks you to confirm you trust the folder before it does anything. Once inside, /init scaffolds an AGENTS.md,  the project instruction file Codex loads at the start of every run.

Codex CLI

Best for: developers already using ChatGPT, teams dispatching several independent tasks, and work that can run in an isolated checkout or cloud environment. Git worktrees for isolated parallel checkouts, cloud tasks in dedicated environments, and a shared MCP configuration across CLI, desktop, and IDE.

Claude Code

Claude Code is an agentic coding system that began in the terminal and now also runs in IDEs, a desktop app, and Anthropic-managed cloud sessions. It reads repository context, edits files, runs commands and tests, and can delegate to subagents.

Inside your terminal, move to the desired repository and type in this command.

The session starts in your current directory. If the repo has no CLAUDE.md, the welcome screen prompts you to create one, and /init generates it from your codebase.

Claude Code CLI

Best for: developers who want a terminal-centered loop, explicit plan review, long repository sessions, or configurable hooks and agent teams. Strongest documented capabilities: per-subagent model selection, lifecycle hooks, and agent teams, where named subagents launch as addressable teammates that share a task list.

How they evolved

TabNine was one of the first providers for Machine-assisted neural completion in 2018. What was new in 2021 was GitHub Copilot, running on OpenAI's Codex model.

The shift from suggestions to running commands happened over 2023 and 2024, and neither of the products in this comparison led it. Aider and Cursor were operating on codebases in 2023. Devin demonstrated autonomous multi-step work in early 2024.

Claude Code reached research preview in February 2025 and made the terminal-native agentic loop mainstream. OpenAI's Codex CLI followed in April 2025, with the cloud agent a month later.

2026 is the consolidation year. Both products now span CLI, IDE, desktop, and cloud.

The engineering question has shifted from can an agent edit a repository to

• Unattended runtime: How long can the agent loop without degrading or hallucinating?

• Governance & boundaries: What files, secrets, and system commands is it permitted to touch?

• Context persistence: What architectural constraints survive between distinct sessions?

• Concurrency: How many agents can work across a repository simultaneously without collisions?

Those four questions define how both systems actually perform in production.

How Claude Code and OpenAI Codex Evolved

Model and Harness results are different

A model produces the next response. Harness is the software around the model that assembles its context, the tools it can call, decides where commands run, and returns its changes to you.

Claude Code exposes model selection by alias or exact model name.

Codex keeps product configuration separate from project instructions.

Replacing GPT-6 Astra or Claude Fable 5.1 can change the result without changing either harness.

How both Harnesses Execute

Coding model and Reasoning

GPT-6 Astra is a general frontier model used for coding, computer use, research, and other end-to-end work. Claude Fable 5.1 is Anthropic's high-capability model for demanding reasoning and long-horizon agentic work. Both are multi-modal and can produce up to 128K output tokens.

Their reasoning controls are not equivalent: an Astra high run and a Fable high run do not imply the same compute budget.

Note: GPT-6 Astra usage inside Codex does not receive the additional >272K long-context multiplier, and Codex doesn't charge for cache writes.(Source)

Verdict: no primary source establishes a reasoning, debugging, speed, or code-quality winner for this exact pair under matched conditions. The specifications explain capacity and controls. they do not predict task success.

The Harness Changes How Each Model Works

The initial perception was that Codex was strictly a remote worker while Claude Code lived in a local terminal. That is no longer accurate. Codex runs local chats, Git worktrees, and isolated cloud environments. Claude Code runs locally, through a desktop interface, through Remote Control, and in Anthropic-managed cloud VMs.

Codex makes chats, tasks, and worktrees explicit in its desktop and cloud workflows. Claude Code starts from a session and can extend it with subagents or experimental agent teams. This is an interpretation of the documented workflows, not a hard product limit.

Codex(Filesystem / Worktree Isolation):

• A Worktree is an independent checkout while Git metadata remains shared.

• Codex creates isolated checkouts via Git worktrees or isolated containers

• Multiple concurrent agent tasks to run on the same repo without dirtying your active working branch.

• A cloud task can continue in a dedicated environment and return a diff for review.

Claude Code(Process / Swarm Coordination):

• Claude Code operates on the active working tree by default.

• It achieves concurrency via independent context windows (subagents) or horizontal peer swarms (Agent Teams).

• Agent teams add independent sessions, a shared task list, and direct messaging.

• They coordinate through a shared task queue and mailbox protocol.

Agentic Coding Capabilities

Both products implement the same broad control loop: understand the task, inspect the repository, plan, edit, run tests, diagnose failures, iterate, and return a result.

At the product level, the observable differences are primarily in context assembly, orchestration, isolation, permissions, and review workflow.

The practical difference is interruption and isolation.

Codex can place independent tasks in separate worktrees or cloud environments, then concentrate review at the diff.

Claude Code keeps a strong live-session path, while subagents isolate narrower investigations and report back. Agent teams allow peer sessions to coordinate directly, but remain experimental.

NOTE: Agent teams consume significantly more tokens (often ~3–5x) due to inter-agent messaging and task-board sync overhead compared to a single interactive session.

CLI and IDE experience

Claude Code has -p (headless prompt) and the programmatic Claude Agent SDK, whereas Codex CLI uses non-interactive flags (codex exec / script mode) and cloud task webhooks. Both cover mainstream IDE workflows.

MCP, hooks, and tool integrations

Both support Model Context Protocol servers for issue trackers, documentation, databases, browsers, design tools, and internal APIs.

Codex shares local MCP configuration across its desktop app, CLI, and IDE extension. Codex relies on sandbox boundaries and static approval policies rather than arbitrary pre/post shell hook interceptors.

Claude Code combines MCP with skills, lifecycle hooks, subagents, and distributable plugins. Lifecycle Hooks are currently unique to Claude Code (e.g., running PreToolUse or PostToolUse scripts to lint/format code or sanitize secrets before the agent executes tools).

Codex extension model

• STDIO and streamable HTTP MCP servers

• Codex reads local/global overrides from ~/.codex/config.toml (and project-level .codex/config.toml),

• Skills and plugins for reusable workflows

• Codex centralizes MCP at the host configuration layer across all entry point

Claude Code extension model

• MCP servers and graphical connectors

• Claude Code distributes configuration across ~/.claude.json, .claude/config.json, and the .claude/ directory structure.

• Claude Code bundles MCP servers directly into shareable project plugins/subagents.

An MCP logo on both products does not imply identical security. Each server adds tools, credentials, and data paths that must be governed separately.

Context is a storage system

“Which agent has memory?” is the wrong question. Ask what is stored, when it is loaded, whether it is authoritative, and whether it survives compaction or a new session.

Codex

Codex reads an instruction chain from AGENTS.md files before work begins. Guidance is assembled from global and project scopes, with files closer to the current directory taking precedence.

The default combined project-instruction limit is 32 KiB. Separately, local Codex clients can maintain a local memory store. OpenAI explicitly says that rules which must apply should remain in checked-in documentation, not memory alone.

Codex Memory Hierarchy

Claude Code

Claude Code loads CLAUDE.md instructions and maintains machine-local auto memory per project. Its documentation states that the first 200 lines or 25 KiB of MEMORY.md, whichever comes first, are loaded at conversation start.

Topic files are retrieved on demand. The root CLAUDE.md is read again after compaction. nested files reload when Claude next reads within their directory.

Claude Code Context Memory Architecture

These systems are similar in purpose but different in mechanics. For dependable work, durable project rules belong in version control. Generated memory is recall, not policy.

Context Memory: Codex vs Claude Code

A July 2026 ablation tested 288 runs across 17 tasks and three repositories. It found no measurable correctness gain from always-on or selectively retrieved context files for either tested agent. That is not a reason to delete project instructions: the study tested task correctness, not policy compliance, team consistency, or setup time. It is evidence that a larger instruction file does not repair weak implementation reasoning.

A Little Experiment

The comparison above describes the current Claude Code and Codex ecosystems, including their newest frontier models. My hands-on test uses a slightly different pair: Claude Opus 5 and GPT-5.6 Sol, because these were the strongest models I could consistently access in both coding harnesses under my normal developer subscriptions.

This is therefore not a benchmark of Opus 5 against Sol, nor an attempt to determine which underlying model is more capable. The experiment asks a narrower question: when a developer teaches each coding system a project-specific constraint, does that constraint survive a fresh session?

Because the model and harness cannot be separated in normal use, the result should be read as the behavior of these two tested configurations—not as a general claim about either model family.

Experiment scope: This test is illustrative, not conclusive. It shows how these two harnesses behaved in one controlled setup and should not be treated as evidence of broader model superiority.

Experiment configuration

Claude Code Version: v2.1.236

Model: Opus 5/Sonnet 5

Effort: High

Codex Version: v0.153.4

Model: gpt-5.6-sol/ gpt-5.6-luna

Effort: High

The Setup: A Self-Contained Local Tool

Create an empty directory with one script: a small CLI or worker script (e.g., batch_worker.py or worker.ts). No external dataset or pre-existing codebase needed.

The 3-Prompt Negative Cache Protocol

Prompt 1: The Trap (Establish the Baseline)

Natural Agent Behavior: Both agents output the textbook concurrent primitive (e.g., multiprocessing.Pool or spawning sub-threads with signal.alarm).

Prompt 2: The Negative Rule Injection (The Incident)

Outcome: The agent acknowledges the environment constraint, rewires the code to use asyncio, runs the test, and exits clean.

• -- Hard Session Reset / New Thread —

(Restart Claude Code / Codex CLI in the same directory to drop the transient context window.)

Prompt 3: The Probe (Testing the Negative Cache)

Clear Judgement & Scoring

This section answers one simple question: “Did the agent remember what not to do across sessions?”

Comparing Results

What Does This Reveal About Harness Memory?

Claude Code’s pass was driven by its active auto-memory subsystem (MEMORY.md). When prompted with the negative constraint in Session 1, the harness extracted it as persistent project knowledge. After the hard context wipe, Session 2 initialized by reloading that memory layer. The agent didn’t just choose asyncio. It explicitly cited the negative rule in its chain-of-thought “No signal... consistent with the project rule to use asyncio rather than multiprocessing or signal.”

Codex’s pass, by contrast, was not memory retention, it was codebase pattern matching. By design, Codex does not autonomously mutate its AGENTS.md instruction chain based on conversational turns. OpenAI explicitly treats project instructions as version-controlled policy that humans curate. After the hard reset, the new Codex session had zero historical recall of the prompt. It chose asyncio simply because it inspected worker.py, detected the existing asynchronous event-loop primitives from Prompt 2, and naturally conformed to the surrounding code structure.

Takeaway: Claude Code remembers your rules via an autonomous, machine-managed context store (MEMORY.md). Codex remembers your code style by strictly inspecting the repository state, leaving policy governance explicitly to human-maintained AGENTS.md files.

Code quality and performance

Vendor benchmarks support narrow claims about GPT-6 Astra or Claude Fable 5.1 under the vendor's stated setup. They do not establish which model wins when both run the same task through Codex and Claude Code. The result can change with context assembly, allowed tools, network access, retry budget, tests, and human intervention.

“Code quality” also needs decomposition. Correctness can be tested against hidden cases. Maintainability and architecture need a blinded review rubric. Test generation must be scored against independent tests, or an agent can write a patch and a test that confirm the same mistaken assumption. Refactoring needs behavioral equivalence checks, not diff size.

Cross-model review only delivers measurable improvements when the reviewer is granted access to the execution sandbox to run regression tests independently. Even with frontier engines like Astra and Fable 5.1, model diversity is no substitute for deterministic CI gates and human oversight at the merge boundary.

Codex vs Claude Code pricing

Which is Cheaper in Practice?

Headline API rates look identical, but effective cost per completed task diverges depending on how you work:

For Interactive, Terminal-Heavy Workflows (API Billing): Claude Code is cheaper. Because iterative agent loops repeatedly reload repository context files and conversation history, prompt cache hits account for up to 90% of total input volume.

For Heavy, Unattended Cloud Execution (Subscription Billing): Codex is more cost-predictable. For developers using monthly subscriptions, Codex bundles dedicated cloud environments and parallel worktree runs without exposing you to variable API token spikes.

Real-world use cases

Pros and cons

OpenAI Codex

Pros

• Explicit worktree and cloud-task isolation

• Wide desktop, CLI, IDE, web, and integration surface

• Unified host-level configuration in ~/.codex/config.toml applies across all local surfaces.

• Bundled cloud runs within standard ChatGPT subscription tiers.

Cons

• No Native Policy Memory, does not autonomously update project guidelines from conversational prompts. requires manual AGENTS.md curation.

• Relies on static sandbox bounds rather than dynamic pre/post execution lifecycle hooks.

• Hosted containers reset after task completion or 12 hours, cannot maintain a persistent background dev daemon.

Claude Code

Pros

• Unmatched terminal UX with plan review, full-screen diffs, and conversational steering.

• Hooks, skills, MCP, plugins, and explicit agent configuration

• Supports lifecycle hooks (PreToolUse, PostToolUse) for custom linting, automated validation, and secret redaction.

• Built-in Agent Teams enable coordinated multi-agent workflows with synchronized task boards and direct messaging.

Cons

• Persistent execution requires keeping your local terminal open or managing remote Linux/VM instances.

• Multi-agent swarms multiply context consumption (often 3–5×) due to peer mailbox messaging.

• Stringent automated safety classifiers can occasionally interrupt or refuse sensitive cybersecurity and vulnerability auditing tasks.

Which one should you choose?

Use both when the review is worth its cost: Independent review can expose different failure modes, but model diversity alone is not a guarantee. A 2026 study found that the stronger reviewer helped the weaker writer in its tested pair, while the reverse ordering introduced regressions. If you use both, preserve the writer's tests, give the reviewer the requirement and diff, let it run tests, and keep a human at the merge boundary.

Final verdict

There is no universal winner in 2026. The choice comes down to your operational model:

OpenAI Codex is the superior harness for parallel, delegated, and branch-isolated development. Its ability to run background tasks in disposable cloud environments or isolated Git worktrees makes it the top choice for asynchronous, diff-first workflows and fixed-cost subscription budgeting.

Anthropic Claude Code is the superior harness for interactive, deep-context terminal engineering. With native persistent auto-memory (MEMORY.md), flexible lifecycle hooks, and coordinated Agent Teams, it excels at complex architectural refactors and hands-on repository exploration.

—

Mem0 is an intelligent, open-source memory layer designed for LLMs and AI agents to provide long-term, personalized, and context-aware interactions across sessions.

Get your free API Key here: app.mem0.ai or self-host mem0 from our open-source GitHub repository.

—

Frequently Asked Questions

Q. Which is better for coding, Codex or Claude Code?

Neither dominates universally. Codex is better for parallel, asynchronous tasks and automated cloud runs. Claude Code is better for interactive debugging, architectural planning, and hands-on terminal steering.

Q. Is Codex cheaper than Claude Code?

It depends on how you pay. For fixed-rate subscribers, Codex bundles hosted cloud environments and parallel executions into standard ChatGPT Plus/Pro plans. For per-token API usage, Claude Code is significantly cheaper on long multi-turn sessions due to a 90% prompt caching discount ($0.25/Mtok cache reads vs. $5.00/Mtok on OpenAI).

Q. Which has better performance on large codebases?

Both support ~1M token context windows. Claude Code handles exploratory architectural comprehension better via its plan mode and dynamic topic-file memory retrieval. Codex handles multi-branch isolation better by executing changes across dedicated Git worktrees without context bleed.

Q. Can Codex and Claude Code run autonomously?

Yes, but with different guardrails. Codex runs unattended tasks in sandboxed cloud containers and returns reviewable diffs. Claude Code runs headless loops via -p or the Agent SDK, and can coordinate autonomous swarms via Agent Teams, but primarily defaults to a human-in-the-loop permission model.

Q. Can you use Codex and Claude Code together?

Yes, and it is a common pattern in 2026. Engineers often use Claude Code's plan mode for architectural design, delegate parallel feature implementations to Codex across isolated worktrees, and bring the completed diffs back into Claude Code or CI test suites for final review.

Q. Which AI coding agent should beginners use?

Codex is more approachable for beginners due to its native desktop application, clean IDE integrations, and automated sandbox safety. Claude Code is designed for developers comfortable working directly inside a terminal environment.