Cursor vs Claude Code vs Codex CLI (2026): IDE, Terminal, or OpenAI's Own Agent?

The deepest difference here is not features or price — it is **where the agent lives**. That choice cascades into setup friction, daily workflow shape, tool access, and what kinds of tasks each tool is good at.

**Cursor lives in an IDE.** You open a folder, you see a file tree, you see open tabs, you see a diff. The agent operates inside that mental model — multi-file edits inside Composer, chat with codebase context, inline completion at the cursor. The IDE is doing a lot of the work: indexing your repo, tracking which files you've edited, surfacing language-server diagnostics. The agent is a feature inside a familiar shape.

**Claude Code lives in your terminal.** You `cd` into a repo, you run `claude`, and a CLI starts a conversation that can read files, write files, run shell commands, edit configs, drive your existing tooling (git, npm, docker, kubectl, gh, your test runner). The agent doesn't index your repo into a vector store — it greps, reads, and reasons over what it pulls. Everything is auditable in your scrollback. You can pipe it. You can run it over SSH. You can pin a session to a tmux pane and watch it work.

**Codex CLI lives in your terminal too**, but rooted in OpenAI's stack. Same shape as Claude Code at first glance — `cd` into a repo, run `codex`, get a tool-use agent that can read, write, exec. The differences show up in the model behind it (GPT-5 family rather than Claude), the approvals UX (Codex defaults to asking before destructive actions, with policies like 'auto-approve reads, ask before writes'), and the deeper tie-in to ChatGPT account billing.

**Consequences for daily work.** If most of your day is in an IDE writing application code, Cursor's shape is the lowest-friction win — the agent is one keybind away. If most of your day is in a terminal driving infra, CI, scripts, deploys, multi-repo workflows, or anything where the IDE is not the center, the CLI agents (Claude Code and Codex CLI) match your existing workflow without forcing you into a new editor. If you live in the OpenAI ecosystem (ChatGPT account, OpenAI API for everything else), Codex CLI is the lowest-context-switch CLI. If you want the deepest agent stack — hooks, skills, subagents, slash commands, MCP, custom tool definitions — Claude Code is currently the most opinionated and most capable CLI agent shipping in 2026.

Most senior engineers we know end up running two of these in parallel — Cursor for application code, Claude Code (or Codex CLI) for everything else. It is not an either/or for power users; it is a question of which is your primary.

**Cursor setup**: download the IDE, sign in with Google or GitHub, optionally import your VS Code settings, open a folder. That is the entire flow. First Composer prompt under 3 minutes from a fresh install. If you live in VS Code already, it is essentially zero friction — your extensions, keybinds, and theme port over.

**Claude Code setup**: `npm i -g @anthropic-ai/claude-code` (or use the install script), run `claude` in any directory, the CLI walks you through OAuth-style auth into either a Claude Max plan or an API key. Under 5 minutes from a fresh shell. First-run config also includes optional setup of MCP servers, hooks, skills, and project-level CLAUDE.md memory files that the agent reads on every run.

**Codex CLI setup**: `npm i -g @openai/codex` (or the brew formula on macOS), `codex login` to authenticate against your ChatGPT account, run `codex` in any directory. Under 5 minutes. First-run config asks you to pick an approvals mode — fully manual, ask-on-writes, or full-auto — which becomes your daily default.

**First-run friction winner**: Cursor for IDE-first developers. Claude Code and Codex CLI are nearly identical first-run experiences, with a slight edge to Codex CLI on first auth if you already have a ChatGPT account, and to Claude Code on first-run if you want the agent to immediately pick up project conventions via a CLAUDE.md file you already have in the repo.

**Ongoing config friction**: the CLIs reward investment. Claude Code's CLAUDE.md memory, hooks (shell scripts that fire on session start, before-tool-use, after-tool-use, etc.), skills (versioned skill definitions the agent can compose), and subagents (specialized agents the main agent can spawn) all reward 2-3 hours of one-time setup with weeks of multiplied output. Codex CLI's tool definitions and approvals policies work similarly. Cursor's config is mostly handled in-IDE — less hackable, more polished.

All three tools are 'agentic' in 2026 — they can call tools, edit files, run commands, and execute multi-step plans. The differences are in the depth of the tool/agent stack each ships.

**Cursor's agent mode** is the in-IDE equivalent. Composer for multi-file edits is the headline. Agent mode runs longer-form tasks with the editor as the canvas — you watch diffs accumulate in the file tree. Tool use is mostly file ops + shell, with MCP for external tool integration. The mental model is 'an agent that operates on the project I have open.'

**Claude Code's agent stack** is the deepest currently shipping. (1) **Hooks**: shell scripts that fire at well-defined lifecycle points — `SessionStart`, `PreToolUse`, `PostToolUse`, `Stop`, `Notification`. Use these to inject context, gate dangerous commands, log every action, or trigger downstream automation. (2) **Skills**: versioned, composable units of agent capability — a skill is a markdown file with frontmatter that describes when to use it and what it knows; the agent picks skills automatically based on the task. (3) **Subagents**: specialized agents the main agent can spawn with their own tool sets — useful for parallel research, isolated experiments, or scoped tasks. (4) **Slash commands**: user-defined `/foo` triggers that bundle a prompt, tool set, and skills. (5) **MCP**: full Model Context Protocol support — point at any MCP server and it becomes a tool. The agent ships with a strong default set: bash, file edit/read/write, glob, grep, web search/fetch.

**Codex CLI's agent stack** sits between. Tool use is first-class — exec, file ops, web fetch, custom tools defined in your config. The signature feature is the **approvals model**: every tool call can be gated by policy (auto-approve read-only commands, ask before any write or destructive action, fully manual). For teams worried about an agent running `rm -rf` somewhere it shouldn't, this is the right mental model. MCP support is on the roadmap; as of June 2026, custom tools are defined via OpenAI's own tool-definition schema. No hooks/skills/subagents in the Claude Code sense — Codex CLI is intentionally a leaner shape.

**Which one wins for which workload?** If you want an agent that watches your IDE and edits multiple files conversationally → Cursor. If you want the deepest customization — agents that know your conventions, fire hooks on every action, spawn subagents for parallel work, ship as repo-versioned skills → Claude Code. If you want OpenAI-native tool use with strong approvals defaults and minimum config surface → Codex CLI.

Pricing models are different enough that the right answer depends entirely on your usage shape. Let's compute three scenarios at June-2026 list pricing. (Forecast your own spend with our Claude API cost calculator and the OpenAI calculator on the Cursor vs Copilot cost calculator page.)

**Light usage** (~10 prompts/day, 2K input + 1K output each, 20 working days): 400K input + 200K output per month. — **Cursor Pro**: flat $20/mo regardless. — **Claude Code on Sonnet 4.6 API**: 400K × $3/1M + 200K × $15/1M = $1.20 + $3.00 = **$4.20/mo**. — **Claude Code on Claude Max $100**: $100/mo — overkill at this volume. — **Codex CLI on GPT-5 API**: 400K × $1.25/1M + 200K × $10/1M = $0.50 + $2.00 = **$2.50/mo**. — **Codex CLI on ChatGPT Plus $20**: flat $20/mo. **Light-user winner**: Codex CLI on API pay-as-you-go ($2.50/mo), Claude Code on API ($4.20). Cursor wins on IDE experience but not cost.

**Medium usage** (~30 prompts/day, 5K input + 2.5K output, 20 days): 3M input + 1.5M output per month. — **Cursor Pro**: $20/mo flat. — **Claude Code on Sonnet API**: 3M × $3 + 1.5M × $15 = $9 + $22.50 = **$31.50/mo**. — **Claude Code on Max $100**: typically fits inside Max limits comfortably at this volume. — **Codex CLI on GPT-5 API**: 3M × $1.25 + 1.5M × $10 = $3.75 + $15 = **$18.75/mo**. — **Codex CLI on ChatGPT Plus**: $20/mo, fits inside Plus request ceiling. **Medium-user winner**: Codex CLI on API or ChatGPT Plus (~$18-20/mo), Cursor Pro tied at $20. Claude Code on API is ~50% more expensive at this tier; Claude Code on Max is overkill unless you also use Claude on the web/desktop heavily.

**Heavy usage** (~60 prompts/day, 10K input + 5K output including agent runs, 20 days): 12M input + 6M output per month. — **Cursor Pro**: $20/mo flat (you will hit soft caps on premium models at this volume; expect throttling or auto-routing to cheaper models). — **Claude Code on Sonnet API**: 12M × $3 + 6M × $15 = $36 + $90 = **$126/mo**. — **Claude Code on Max $200**: the 20x-Pro-limits tier, designed for this user. — **Codex CLI on GPT-5 API**: 12M × $1.25 + 6M × $10 = $15 + $60 = **$75/mo**. — **Codex CLI on ChatGPT Pro $200**: covers this volume comfortably. **Heavy-user winner depends on model preference**: if you want Claude, Claude Max $200 is the right shape (predictable, deep limits, no surprise bills). If you want GPT-5, Codex CLI on API at $75/mo beats ChatGPT Pro $200/mo unless you also need ChatGPT Pro for non-CLI reasons (image gen, advanced voice, etc.).

**Very heavy / autonomous agent runs on Opus 4.7** (20M input + 10M output): 20M × $15 + 10M × $75 = $300 + $750 = **$1,050/mo on API**. Claude Max $200 is the only humane way to run this kind of workload — at API rates, four days of heavy Opus burns the full month's Max allowance. The takeaway: subscriptions exist for a reason at the heavy tier; API-rate Opus is for occasional surgical use, not as a daily driver.

**The crossover map**: light users want pay-as-you-go API (especially Codex CLI on GPT-5). Medium users want Cursor Pro or Codex CLI on ChatGPT Plus — both ~$20/mo flat. Heavy users want Claude Max $200 (if Claude) or ChatGPT Pro $200 (if GPT-5) — both designed for the upper tier and both far cheaper than the equivalent API spend.

Solo dev. Application code + occasional infra. Wants AI assistance daily without thinking about per-prompt cost. Budget: under $50/mo.

**Cursor Pro at $20/mo**: flat rate, Composer for multi-file edits, the most polished IDE flow. Best for: solo devs whose daily work is mostly inside an editor and who want the IDE itself as the multiplier.

**Claude Code on Claude Max $100**: overkill for a typical solo at this budget. Only the right answer if you also use Claude heavily on the web (long docs, research, design). For pure coding, drop to API pay-as-you-go.

**Claude Code on Anthropic API pay-as-you-go**: ~$5-30/mo at typical solo volume. Best for: terminal-first solo devs, devs working across multiple repos, devs who want the hooks/skills/subagents stack and don't mind paying per token.

**Codex CLI on ChatGPT Plus $20**: lowest-friction CLI if you already have ChatGPT Plus. Best for: solo devs already in the OpenAI ecosystem who want a CLI agent without a second subscription. The approvals model is genuinely useful for solo work where there is no second human to review destructive commands.

**Verdict for solo**: pick *one* primary and *one* secondary. Most senior solos we know run **Cursor Pro + Claude Code on API pay-as-you-go** as the standard pair — Cursor for app code, Claude Code for everything that lives outside the IDE (infra, scripts, multi-repo refactors, CI debugging). Total burn: $20 Cursor + $10-30 Claude Code API = **$30-50/mo**. If you are deep in the OpenAI ecosystem, swap Claude Code for Codex CLI on ChatGPT Plus — same shape, GPT-5 instead of Claude.

Production team. Application + infra. Need cost predictability and basic audit. Budget: $1.5-3K/yr/dev range.

**Cursor Teams at $40/user/mo × 5** = $200/mo team = **$2,400/yr**. Composer for every dev, model picker, centralized billing. The IDE experience for the whole team.

**Claude Code on per-dev Anthropic API** (org account, dev-tagged API keys): 5 devs × ~$31/mo medium usage on Sonnet = $155/mo = **$1,860/yr**. Plus a per-dev Claude Max for power users who exceed API rates. Full hooks/skills/subagents stack, repo-versioned CLAUDE.md memory, audit trail via Anthropic's console.

**Codex CLI on ChatGPT Business at $25/seat/mo × 5** = $125/mo = **$1,500/yr**. Approvals model is a genuine win for a team — you can set org-wide policy on which tools an agent can call without human review. Lowest-cost team option of the three on subscription billing.

**Mix-and-match works**: 5 seats of Cursor Teams ($200/mo) + a shared Anthropic org API budget for Claude Code use ($150/mo) = $350/mo = $4,200/yr. Every dev gets the IDE AND the terminal agent. For a 5-person team this is rounding error and the productivity lift is meaningful.

**Verdict for 5-person teams**: if budget is the binding constraint, **Codex CLI on ChatGPT Business** is the cheapest production-grade option. If IDE experience matters, **Cursor Teams + shared Claude Code API budget** is the best-of-both. Pure-CLI shop with deep customization needs → **Claude Code on per-dev API** + a CLAUDE.md committed to the repo so every dev's agent shares the same conventions.

Engineering org with platform team, security review, procurement. Budget conversations are real.

**Cursor Teams at $40/user/mo × 50** = $2,000/mo = **$24,000/yr org**. Polished IDE for everyone, centralized admin, basic compliance posture.

**Claude Code via Anthropic org API + selective Claude Max for heavy users**: 50 devs × ~$31/mo medium usage = $1,550/mo on API + 10 Max-tier devs × $200/mo = $2,000/mo = $3,550/mo = **$42,600/yr org**. Higher than Cursor Teams but includes a much deeper agent surface and the full Anthropic enterprise compliance posture (BAA, data-not-used-for-training, AWS Bedrock private deployment optional).

**Codex CLI via ChatGPT Business at $25/seat × 50** = $1,250/mo = **$15,000/yr org**. Cheapest of the three on raw subscription. Approvals model gives platform/security a way to set org-wide tool-call policies. OpenAI's enterprise posture (SOC 2, data not used for training on Business+) covers most procurement requirements.

**Mix that most 50-person orgs actually run**: 30 seats of Cursor Teams (app devs who live in the IDE) + 20 seats of Claude Code on org API (platform/infra/DevX) + a small Codex CLI pilot for the team that already lives in ChatGPT. Total: $1,200 Cursor + $620 Claude Code + $250 Codex Business = ~$2,070/mo = **$24,840/yr org**. Each group gets their preferred shape. For a 50-person eng org, this is rounding error in the engineering budget and the per-group productivity lift pays it back in days, not months.

**The compliance call at this scale**: Anthropic and OpenAI both have enterprise tiers with the standard surface area (SOC 2, BAA, data residency conversations). Cursor is adding enterprise compliance fast but is the youngest vendor relationship of the three. Most platform teams we talk to default to 'agent runs against our existing model-provider relationship' (Anthropic via Bedrock, OpenAI via Azure) which structurally favors Claude Code and Codex CLI over Cursor's bundled inference.

Claude Code is built specifically to reward heavy customization. The stack of hooks + skills + subagents + slash commands + MCP gives you more agent surface area than any other CLI on the market in 2026. A few specific wins:

**1. Hooks make every action gateable and observable.** A `PreToolUse` hook can block any `rm -rf /` style command before the agent runs it. A `PostToolUse` hook can log every file edit to your audit system. A `SessionStart` hook can inject the current sprint goals or on-call rotation. A `Stop` hook can fire your test suite. This is the most production-friendly agent design — every action has a clear lifecycle point.

**2. Skills are versioned, composable, and discoverable.** A skill is a markdown file with frontmatter describing when to use it. The agent picks skills automatically based on the task. Skills can be repo-versioned, org-versioned, or globally versioned — your team's conventions become composable units the agent uses without per-prompt reminders. Vercel ships their entire stack as skills (vercel:deploy, vercel:env, vercel:ai-sdk, etc.) — the pattern works.

**3. Subagents enable parallel research and isolated experiments.** The main agent can spawn specialized subagents — a code-reviewer, a researcher, a runtime-verifier — with their own tool sets and their own context windows. Useful for any task where you want isolated exploration without polluting the main thread.

**4. Slash commands turn workflows into one-keystroke triggers.** `/deploy`, `/review`, `/verify`, `/loop` — these are user-defined commands that bundle a prompt, a tool set, and a skill selection. Two months of disciplined slash-command building turns a Claude Code session into a deeply personalized command surface.

**5. MCP support is first-class.** Any MCP server becomes a tool the agent can call. The MCP ecosystem in 2026 is the strongest it has ever been — connectors for every major SaaS, every dev tool, every database.

**The honest counterpoint**: all of this rewards investment. A first-day Claude Code user gets a competent agent. A user who has spent two weeks tuning CLAUDE.md, building 3-5 hooks, writing a handful of skills, and defining their core slash commands has a workflow multiplier no IDE agent currently matches. If you are not going to invest those two weeks, Cursor's out-of-the-box experience will feel more polished. The Claude Code design is for power users who want maximum agent surface area and are willing to build their workflow.

Codex CLI is OpenAI's first-party answer to Claude Code. It launched in late 2025, matured through 2026, and is now the recommended terminal agent for anyone whose primary model is GPT-5. The design philosophy is different from Claude Code's — leaner, more opinionated about safety, less hacker-customizable.

**Tool use is first-class.** Codex CLI ships with exec, file read/write, web fetch, and a custom-tool schema for defining your own. The tool definitions follow OpenAI's standard function-calling schema, which means anything you have already defined for the OpenAI Assistants API can be ported in.

**Approvals are the signature feature.** Every tool call can be gated by policy. Default modes: 'auto-approve reads, ask before any write' is the recommended starting policy. 'Fully manual' (every tool call requires approval) is the safe default for production systems. 'Full auto' is for trusted environments. The approvals UX is genuinely well-designed — a clear single-key approve/reject prompt with a diff or command preview before execution.

**Billing is account-tied.** If you have a ChatGPT account, you can authenticate via OAuth and Codex CLI billing flows through your existing subscription. No second key to manage. For pay-as-you-go, drop in an OpenAI API key.

**What's missing vs Claude Code**: no hooks (yet — on the roadmap), no skills (yet), no subagents (yet), MCP support is in early preview as of June 2026. Codex CLI is intentionally leaner. The bet: most users want tool use + approvals + good defaults, not a hackable agent stack. For 70% of users that bet is right. For the other 30% (power users who want maximum customization), Claude Code is still the deeper tool.

**When Codex CLI is the right call**: if your primary model is GPT-5 or GPT-5-mini, if you already pay for ChatGPT Plus or Pro, if you want strong approvals defaults out of the box, if you want a CLI agent that 'just works' without two weeks of CLAUDE.md tuning. If you want the deepest agent stack and don't care about which model is upstream, Claude Code wins on customization surface.

**Mistake 1: treating this as an either/or.** Most senior devs we know run two of the three. The IDE-vs-CLI question is not 'which one' — it is 'which is your primary and which is your secondary?' Cursor + Claude Code is the most common pair in 2026. Cursor + Codex CLI is common in OpenAI-heavy shops.

**Mistake 2: paying for Claude Max $200 when you would burn $30 on the API.** Max pays back if you actually consume the included usage daily. Most light-to-medium users would save money on the API. Run the math against your typical week.

**Mistake 3: ignoring Codex CLI because it's newer.** Codex CLI matured a lot in 2026. The approvals model is genuinely well-designed. For GPT-5-first developers it is the right CLI agent in 2026, not Claude Code.

**Mistake 4: not setting up CLAUDE.md.** A Claude Code session without a project CLAUDE.md is operating without your team's conventions. Adding a CLAUDE.md is a 30-minute investment that improves every subsequent session. Same logic applies to Codex CLI's per-project config.

**Mistake 5: leaving approvals on 'full auto' in production.** Both Claude Code (via PreToolUse hooks) and Codex CLI (via approvals policy) support gating dangerous commands. Use that surface. The minutes you spend approving destructive commands are cheaper than the hours you spend recovering from an agent that ran a `git reset --hard` in the wrong branch.

**Mistake 6: ignoring prompt quality.** Whichever tool you pick, prompt quality determines 60% of the output. Our code prompt builder writes refactor/explain/scaffold prompts tuned to your stack — works in Cursor Composer, Claude Code, or Codex CLI.

**Cursor**: pricing sourced from https://cursor.com/pricing, fetched 2026-06-21. The $20 Pro tier has held since launch; the Pro/Pro+/Ultra collapse on the public pricing page reflects a 2026 simplification. Teams at $40/user/mo and Enterprise (custom) have been stable.

**Claude Code**: product page at https://claude.com/claude-code, docs at https://docs.claude.com/en/docs/claude-code. Claude Max plans (https://claude.com/upgrade): Max $100/mo gives 5x Pro usage limits; Max $200/mo gives 20x Pro limits. API pricing (https://docs.claude.com/en/docs/about-claude/pricing): Opus 4.7 $15/$75 per 1M, Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5, all with 90% cache discount on cached reads. Claude Code shipped hooks in 2025, skills and subagents matured through early 2026, MCP support has been first-class since launch.

**Codex CLI**: repo at https://github.com/openai/codex, docs at https://platform.openai.com/docs/codex. ChatGPT plan pricing at https://openai.com/chatgpt/pricing: Plus $20/mo, Pro $200/mo, Business $25/seat/mo. API pricing at https://openai.com/api/pricing: GPT-5 $1.25/$10 per 1M, GPT-5-mini $0.25/$2 per 1M. Codex CLI launched late 2025 and added the approvals model + custom tool schema through 2026; MCP support is in preview as of June 2026.

**Live-verify before procurement**: open each vendor's pricing page and confirm rates. Cursor Enterprise and Anthropic/OpenAI enterprise tiers are negotiable; the public rates are starting points. For API usage, forecast spend with our Claude API cost calculator or the cost section of the Cursor vs Copilot cost calculator page.

**Our position**: the DDH engineering team runs Cursor + Claude Code as the standard pair. Cursor for app code (Next.js, React, TypeScript), Claude Code for infra, multi-repo refactors, CI/CD work, ops scripts, and everything that lives outside the editor. We have no affiliate or paid placement with any of these vendors.