# Cursor vs Claude Code: IDE Agent or Terminal Agent in 2026?

> Cursor vs Claude Code, checked against docs in October 2026: plans and limits, models, cloud agents, CLI, rules files, privacy, and running both on one repo.

A year ago the Cursor vs Claude Code question had a one-line answer: Cursor was the editor, Claude Code was the terminal. That line has mostly washed out. Cursor now ships a terminal agent called `agent`, cloud agents that run in their own VMs, and a Projects coordinator. Claude Code ships VS Code and JetBrains extensions, a desktop app, cloud sessions and scheduled routines.

What still separates them is who sells you the model and how the usage is metered, and that decides your bill more than any feature does. I checked both vendors' pricing pages and docs on October 2, 2026; every price and limit below carries that date.

**The short answer:** Pick Cursor if you write much of the code yourself and want Tab completion plus Claude, GPT, Gemini and Grok models in one place, billed at API list prices from a monthly pool (Pro $20, Pro+ $60, Ultra $200). Pick Claude Code if you mostly hand over whole tasks and want Claude models at flat subscription prices (Pro $20, Max $100 or $200) with 5-hour and weekly limits instead of per-token bills. You don't have to choose: the Claude Code extension installs in Cursor, and Cursor imports Claude Code's hooks, skills and CLAUDE.md by default.

## Cursor vs Claude Code at a glance (checked October 2026)

Cursor is an editor that grew an agent; Claude Code is an agent that grew editor integrations.

| Decision point        | Cursor                                                                            | Claude Code                                                                                                 |
| --------------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| Home surface          | VS Code-based editor with Tab and Agent; also the `agent` CLI, web and iOS        | Terminal CLI; also a VS Code/Cursor extension, JetBrains plugin, desktop app and web                        |
| Entry paid plan       | Pro, $20/month                                                                    | Pro, $20/month ($17 billed annually)                                                                        |
| Heavy-use plans       | Pro+ $60, Ultra $200                                                              | Max 5x $100, Max 20x $200                                                                                   |
| How usage is metered  | Two monthly pools charged at API list prices, then on-demand at the same rates    | Rolling 5-hour windows plus weekly caps, shared with Claude chat; usage credits at API rates past the limit |
| Models                | Claude, GPT, Gemini, Grok, Muse Spark and Cursor's Composer                       | Claude only: Fable, Opus, Sonnet, Haiku (Opus 5.5 by default)                                               |
| Finding code          | Instant Grep, a local index, plus an Explore subagent                             | Search tools (file patterns, regex) and file reads, plus subagents                                          |
| Cloud agents          | Isolated VMs, started from the editor, web, iOS, Slack, GitHub, Linear or API     | Cloud sessions on Pro, Max and Team; routines fired by schedule, API call or GitHub event                   |
| Headless / CI         | `agent -p`                                                                        | `claude -p`                                                                                                 |
| Instruction files     | `.cursor/rules/*.mdc`, AGENTS.md (root and nested), team rules; imports CLAUDE.md | CLAUDE.md and `.claude/rules/`; reads AGENTS.md when no CLAUDE.md exists                                    |
| MCP config            | `.cursor/mcp.json`                                                                | `.mcp.json`                                                                                                 |
| Hooks                 | `.cursor/hooks.json`, and it runs Claude Code hooks too                           | `.claude/settings.json`                                                                                     |
| Undo                  | Checkpoints in the chat timeline                                                  | Checkpoints; press Esc twice to rewind                                                                      |
| Training on your code | Not with Privacy Mode on (zero retention with providers); possible with it off    | Consumer plans train unless you opt out; Team, Enterprise and API don't                                     |
| Source                | Proprietary                                                                       | Proprietary; the GitHub repo's license reads "All rights reserved"                                          |

The pattern: Cursor wins on model choice and completion inside the editor, Claude Code wins on flat-rate access to Claude and on CLI flags built for scripts, and both now cover the cloud.

## Choose Cursor if, choose Claude Code if

**Choose Cursor if:**

- You type a lot of code yourself and want Tab, which predicts multi-line and cross-file edits as you type ([Cursor Tab docs](https://cursor.com/docs/tab/overview)).
- You want GPT, Gemini or Grok next to Claude, and you'll use the cheaper first-party pool (Composer 2.5, Grok) for routine turns.
- Your team wants shared cloud environments ([Cursor cloud agent setup docs](https://cursor.com/docs/cloud-agent/setup)), Bugbot and Security Review on pull requests, and admin-enforced team rules.
- You'd rather pay in API dollars you can see than in usage windows you can't.

**Choose Claude Code if:**

- You mostly delegate: "add tests for the auth module, run them, fix failures" and come back to a diff.
- You'd use Claude for nearly every turn anyway, so a flat Max plan can beat paying list price per token.
- You keep your current editor: it runs in any terminal, in VS Code, in Cursor, and in JetBrains IDEs ([Claude Code overview](https://code.claude.com/docs/en/overview)).
- You script agents in CI and want flags like `--max-budget-usd` and `--permission-mode` on the CLI.

**Use both if** you want Cursor as the editor and Claude Code for long delegated runs. That is a supported setup on both sides; the file map is [below](#run-cursor-and-claude-code-on-the-same-repo).

## Cursor vs Claude Code pricing: what each costs at your usage level

On price, Claude Code vs Cursor comes down to the meter: both start at $20 a month. Cursor charges every model at its API list price against an included monthly pool. Claude bills a flat plan and rations it by time windows. This table maps each vendor's own usage guidance to a plan (prices checked October 2, 2026):

| How you work                              | Cursor                                                                                           | Claude Code                                                                                   |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| Mostly typing, agent a few times a day    | Pro $20; Cursor says Tab users and light agent users usually stay inside included usage          | Pro $20 ($17 annual); includes Claude Code with Opus and Sonnet, Fable only via usage credits |
| Agent all day, one session at a time      | Pro+ $60, which Cursor recommends for daily agent users; it puts their usage at $60–$100 a month | Max 5x $100, the step Anthropic's support docs suggest when Pro limits keep running out       |
| Several agents in parallel, or automation | Ultra $200; Cursor says power users often spend $200+                                            | Max 20x $200                                                                                  |
| Team of five, standard seats              | 5 × $40 = $200/month, plus $0.25 per million tokens on third-party models                        | 5 × $25 = $125/month billed monthly, $100 billed annually                                     |

Sources: [Cursor models and pricing docs](https://cursor.com/docs/models-and-pricing), [Cursor pricing page](https://cursor.com/pricing), [Claude pricing page](https://claude.com/pricing), [Anthropic's Max plan article](https://support.claude.com/en/articles/11049741-what-is-the-max-plan) and [Claude Code on Pro or Max](https://support.claude.com/en/articles/11145838-using-claude-code-with-your-pro-or-max-plan).

**Same Claude model, same list price, different meter.** Opus 5.5 costs $4 per million input tokens, $20 per million output tokens and $0.20 per million cached reads on both Anthropic's and Cursor's price lists. Anthropic's [Claude Code cost docs](https://code.claude.com/docs/en/costs) put average enterprise spend at API token rates at about $13 per developer per active day, $150–250 a month, with 90% of users under $30 a day. At $13 a day, 21 working days is $273 of usage at list price. In Cursor that $273 draws down the Other Models pool and then bills on-demand at the same rates. On a Claude Max plan it costs nothing extra until you hit a 5-hour or weekly limit.

So the rule is simple. If your Claude usage at list price would exceed the plan price and you stay inside the windows, a Claude subscription is the cheaper meter. If you'd accept Cursor's own models for most turns, Cursor is cheaper: Composer 2.5 lists at $0.50 input and $2.50 output per million, one-eighth of Opus 5.5 on both sides, and Cursor gives its first-party pool "significantly more included usage."

Three details change the math:

- **Cursor doesn't publish the dollar size of each plan's included pool** on the pages I checked. You see it in the editor settings and usage dashboard after you subscribe.
- **Claude's limits are shared.** Chat on web, desktop and mobile draws on the same pool as Claude Code, per the Claude pricing FAQ, and both Max tiers are billed monthly only.
- **Teams pay a Cursor Token Rate**: $0.25 per million tokens on top of API pricing for third-party models on Teams and Enterprise, including when you bring your own key. Cursor's first-party models are exempt.

If you already hit Claude walls, our breakdown of [Claude Code rate limits in 2026](/blog/claude-code-rate-limits-2026) covers the windows and the ways around them.

## Models: one menu across labs, or Claude only

Cursor lets you pick a lab per task; Claude Code is built for Claude models and nothing else. If model choice is the deciding factor, that settles it.

Cursor's [models page](https://cursor.com/docs/models-and-pricing) lists Claude Fable 5.1, Opus 5.5 and Sonnet 5.5; GPT-5.6 Sol, Terra and Luna; Gemini 3.1 Pro and 3.8 Flash; Grok 4.7, 4.6 and 4.5; Muse Spark 1.3; and Composer 2.5. Auto mode routes each request in Cost, Balance or Intelligence mode and bills the list price of whichever model it picked.

Claude Code takes aliases (`fable`, `opus`, `sonnet`, `haiku`, `opusplan`) and defaults to Opus 5.5 on Pro, Max, Team, Enterprise and the API, per its [model configuration docs](https://code.claude.com/docs/en/model-config). Enterprises can run it on Amazon Bedrock, Google Cloud or Microsoft Foundry, but the [LLM gateway docs](https://code.claude.com/docs/en/llm-gateway) are blunt that Anthropic "doesn't support routing Claude Code to non-Claude models through any gateway."

**Fable works differently in each.** In Claude Code on Pro, Fable bills usage credits; Max plans get it within 50% of their weekly limits. In Cursor with Privacy Mode on, Fable requests fail until an admin approves its data-retention policy, because Anthropic keeps Fable inputs and outputs for harm-prevention review ([Cursor privacy and data governance docs](https://cursor.com/docs/enterprise/privacy-and-data-governance)).

If you want a terminal agent like Claude Code without the single-lab limit, that's the gap Octomind fills. Octomind is ours: an Apache-2.0 CLI that takes any `provider:model` string. Here's [how it compares with Claude Code](/blog/octomind-vs-claude-code).

## Run Cursor and Claude Code on the same repo

Put your instructions in AGENTS.md, skills in `.claude/skills/`, hooks in `.claude/settings.json`, and keep two MCP files. Both tools then read the same rules, skills and hooks.

| File                             | Cursor reads it?                                            | Claude Code reads it?                             |
| -------------------------------- | ----------------------------------------------------------- | ------------------------------------------------- |
| `AGENTS.md` (root and nested)    | Yes                                                         | Yes, v2.1.277+, but only when no CLAUDE.md exists |
| `CLAUDE.md`                      | Yes, through the third-party import setting (on by default) | Yes                                               |
| `.cursor/rules/*.mdc`            | Yes                                                         | No; `/init` folds them into a new CLAUDE.md once  |
| `.claude/skills/<name>/SKILL.md` | Yes, for compatibility                                      | Yes                                               |
| Hooks in `.claude/settings.json` | Yes; event names are mapped automatically                   | Yes                                               |
| `.mcp.json`                      | Not documented                                              | Yes                                               |
| `.cursor/mcp.json`               | Yes                                                         | No                                                |

Sources: [Cursor rules docs](https://cursor.com/docs/context/rules), [Cursor skills docs](https://cursor.com/docs/context/skills), [Cursor third-party hooks docs](https://cursor.com/docs/reference/third-party-hooks), [Claude Code memory docs](https://code.claude.com/docs/en/memory), [Claude Code MCP docs](https://code.claude.com/docs/en/mcp). The CLAUDE.md import comes from a Cursor staff reply in a [Cursor forum bug report](https://forum.cursor.com/t/cursor-doesnt-respect-ignoring-claude-md-file/154952); the rules docs don't list it.

A repo set up for both looks like this:

```text
repo/
├── AGENTS.md                      # instructions for Cursor, Claude Code and Codex
├── .claude/
│   ├── settings.json              # hooks: Claude Code runs them, Cursor imports them
│   └── skills/
│       └── release/SKILL.md       # loaded by both
├── .mcp.json                      # MCP servers for Claude Code
└── .cursor/
    └── mcp.json                   # the same servers for Cursor
```

To add the Claude Code side of an MCP server from the terminal, `claude mcp add --transport http <name> <url> --scope project` writes `.mcp.json`; copy the same entry under `mcpServers` in `.cursor/mcp.json`. Inside Cursor itself, install the Claude Code extension by searching "Claude Code" in the Extensions view (Anthropic's [VS Code extension docs](https://code.claude.com/docs/en/vs-code) link a `cursor:` install URL), or run `claude` in Cursor's terminal.

Three failure modes to know before you commit this layout:

1. **A CLAUDE.md silently hides AGENTS.md from Claude Code.** If `CLAUDE.md`, `CLAUDE.local.md` or `.claude/CLAUDE.md` exists in the working directory or any parent, Claude Code skips AGENTS.md. If you need Claude-only instructions, start CLAUDE.md with the line `@AGENTS.md`, or set **Project instructions** to `claude-md-and-agents-md` in `/config`. Run `/context` to see which instruction files loaded into the session; when only AGENTS.md is picked up, an interactive session also prints a line like `no CLAUDE.md found; AGENTS.md loaded: …`.
2. **Cursor can load CLAUDE.md even when you don't want it to.** In March 2026 a Cursor staff member confirmed that `.cursorignore` didn't stop the third-party loader from pulling CLAUDE.md in; a June 3, 2026 reply in the same thread says it was fixed. The reliable off switch is the **Include third-party Plugins, Skills, and other configs** toggle, but it is all-or-nothing: turning it off also drops imported skills and MCP servers, per a May 2026 [feature request on the Cursor forum](https://forum.cursor.com/t/need-granular-control-over-imported-third-party-plugins-allow-disabling-mcp-import-while-keeping-skills-rules/159799).
3. **A blocking hook needs exit code 2 or a JSON deny.** Exit 2 is the only exit code that blocks on its own in both tools. A JSON decision also counts: Claude Code lets valid JSON output decide whatever the exit code, and Cursor reads the JSON when the hook exits 0. A hook that exits with any other non-zero code and prints no JSON decision fails open in both ([Claude Code hooks docs](https://code.claude.com/docs/en/hooks), [Cursor third-party hooks docs](https://cursor.com/docs/reference/third-party-hooks)).

For writing the AGENTS.md itself, see [AGENTS.md: stop re-explaining your project](/blog/octomind-project-config-context).

[AUTHOR: Do you run Claude Code inside Cursor on one of the Octomind repos? One concrete thing that worked or broke in that setup would help here.]

## Cloud agents: both keep working after you close the laptop

Older comparisons say Claude Code needs your terminal open and Cursor needs your IDE open. Neither is true in October 2026: both run agents on cloud machines you can start from a phone.

| Question            | Cursor Cloud Agents                                                                     | Claude Code cloud sessions and routines                                            |
| ------------------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Where it runs       | Isolated VMs managed by Cursor, or self-hosted machines (since Sep 2, 2026)             | Anthropic-managed infrastructure, or your organization's self-hosted environment   |
| Start from          | Editor, cursor.com/agents, iOS, Slack, GitHub or Bitbucket comments, Linear, API        | claude.ai/code, Claude mobile app, desktop app, `claude --cloud`                   |
| From the CLI        | Prefix a message with `&` to hand the conversation to a cloud agent                     | `claude --cloud` to send, `claude --teleport` to pull a session back               |
| Environment         | Agent-led setup, a snapshot, or a Dockerfile in `.cursor/environment.json`              | Saved cloud environment with network access level, variables and a setup script    |
| Scheduled/triggered | Subscriptions: watch PRs, a Slack thread or a schedule (cloud only, since Aug 19, 2026) | Routines: schedule, `POST /fire` API trigger, or GitHub events (research preview)  |
| Who owns it         | The Cursor team it started under; teammates can view runs                               | Your individual claude.ai account; runs count against your plan limits             |
| Limits              | Not stated on the pages checked                                                         | 100 scheduled runs per hour per account; 30 Run now/API fires per hour per routine |

Sources: [Cursor Cloud Agents docs](https://cursor.com/docs/cloud-agent), [Cursor changelog](https://cursor.com/changelog), [Claude Code cloud docs](https://code.claude.com/docs/en/claude-code-on-the-web), [Claude Code routines docs](https://code.claude.com/docs/en/routines).

The difference is ownership. Cursor's cloud is built for teams: shared environments (a repo's `.cursor/environment.json`, then a personal saved environment, then a team one, per the [Cursor cloud agent setup docs](https://cursor.com/docs/cloud-agent/setup)), team follow-ups, and since September 23, 2026, Rollouts and Security Review bots on Teams and Enterprise plans. Claude Code routines are personal automations that act as you on GitHub and in your connectors. Cursor's Projects (beta since September 10) and Claude Code's projects both coordinate many parallel cloud sessions toward one body of work, so that's no longer a differentiator.

## Cursor CLI vs Claude Code: headless commands side by side

Both run non-interactively with `-p`; they differ in how you let them write files and cap spend. I checked the Claude Code flags against `claude --help` on v2.1.287 and took its install line from the [Claude Code overview](https://code.claude.com/docs/en/overview). Cursor's commands are from its [CLI docs](https://cursor.com/docs/cli/overview) and [headless docs](https://cursor.com/docs/cli/headless), since I don't have Cursor installed.

| Task                       | Cursor CLI                                     | Claude Code                                       |
| -------------------------- | ---------------------------------------------- | ------------------------------------------------- |
| Install (macOS/Linux)      | `curl https://cursor.com/install -fsS \| bash` | `curl -fsSL https://claude.ai/install.sh \| bash` |
| Interactive session        | `agent`                                        | `claude`                                          |
| One-shot, print and exit   | `agent -p "..."`                               | `claude -p "..."`                                 |
| Machine-readable output    | `--output-format json` or `stream-json`        | `--output-format json` or `stream-json`           |
| Let it edit without asking | `--force` (alias `--yolo`)                     | `--permission-mode acceptEdits`                   |
| Pick a model               | `--model "<name>"`                             | `--model opus` (or another alias or full ID)      |
| Resume                     | `agent resume`, `agent --resume="<chat-id>"`   | `claude -c`, `claude -r <session>`                |
| CI authentication          | `CURSOR_API_KEY`                               | `ANTHROPIC_API_KEY`                               |
| Spend cap per run          | No flag in the docs I read                     | `--max-budget-usd <amount>` (print mode only)     |

Two traps. Cursor's print mode without `--force` only proposes edits and changes no files, so a CI job "succeeds" with nothing written. Claude Code's `-p` skips the workspace trust dialog and silently ignores settings files that fail validation, so run it only in directories you trust and validate settings separately.

## How each finds code in your repo

Both now search your code at task time. Cursor's docs describe a grep index kept on your machine with no stored code embeddings, and Claude Code's describe pattern and regex search tools. Older comparisons that credit Cursor with a vector-embedding index don't match its current search docs.

Cursor's tool is called Instant Grep ([Cursor search docs](https://cursor.com/docs/agent/tools/search)); for broad questions its agent spawns an Explore subagent with its own context window and a faster model. In Claude Code ([how-it-works docs](https://code.claude.com/docs/en/how-claude-code-works)), subagents keep big searches out of the main context, and `/context` shows what is using space.

What you control is how much instruction text loads every time. Cursor advises keeping each rule under 500 lines; Anthropic suggests CLAUDE.md under 200 lines. Scope the rest to paths so it loads only when relevant. In Cursor, `.cursor/rules/api.mdc`:

```markdown
---
globs: src/api/**/*.ts
alwaysApply: false
---
```

In Claude Code, `.claude/rules/api.md`:

```markdown
---
paths:
  - 'src/api/**/*.ts'
---
```

## Where Codex fits (Cursor vs Claude Code vs Codex)

OpenAI's Codex is sold the way Claude Code is: inside a chat subscription, on the web, in a CLI, in an IDE extension and on iOS. It also reads AGENTS.md and installs as an extension in Cursor.

|                  | Cursor                     | Claude Code                         | Codex                                    |
| ---------------- | -------------------------- | ----------------------------------- | ---------------------------------------- |
| Entry plan       | Pro $20                    | Claude Pro $20                      | ChatGPT Plus $20                         |
| Heavy plans      | $60, $200                  | $100, $200                          | Pro at $100, $200 or $500                |
| Models           | Several labs plus Composer | Claude only                         | OpenAI (GPT-6.1 Sol, GPT-6 Luna on Plus) |
| Instruction file | `.cursor/rules`, AGENTS.md | CLAUDE.md, or AGENTS.md without one | AGENTS.md                                |
| CLI source       | Proprietary                | Proprietary                         | Apache-2.0, 127,580 GitHub stars         |

Sources: [Codex pricing](https://developers.openai.com/codex/pricing), [Codex AGENTS.md guide](https://developers.openai.com/codex/guides/agents-md), [Codex IDE docs](https://developers.openai.com/codex/ide), [openai/codex on GitHub](https://github.com/openai/codex) (stars checked October 2, 2026). Pick Codex over Claude Code if you already pay for ChatGPT or want an open-source CLI; the full head-to-head is in [Codex vs Claude Code](/blog/codex-vs-claude-code).

## Privacy: what to switch on before you open company code

Turn on Cursor's Privacy Mode, and on a personal Claude plan turn off model training. Neither is a given on individual plans.

- **Claude Pro and Max** are consumer plans: the [Claude pricing page](https://claude.com/pricing) marks model training as "Opt-out" there and "None by default" on Team. Per the [Claude Code data usage docs](https://code.claude.com/docs/en/data-usage), consumer data is kept 5 years if you allow training and 30 days if you don't; Team, Enterprise and API data is kept 30 days and not used for training. Change it at claude.ai/settings/data-privacy-controls.
- **Claude Code also keeps transcripts on your disk** as plaintext files in `~/.claude/projects/`, deleted after 30 days unless you change `cleanupPeriodDays`.
- **Cursor's Privacy Mode** is available on free and Pro ([Cursor security page](https://cursor.com/security)) and is on by default for Enterprise teams. With it on, Cursor says your code isn't used for training and its model providers work under zero-data-retention agreements, with exceptions for abuse investigations ([Cursor data use page](https://cursor.com/data-use)) and for models that require retention, such as Fable ([Cursor privacy and data governance docs](https://cursor.com/docs/enterprise/privacy-and-data-governance)).
- **Bringing your own key doesn't bypass Cursor.** Its data use page says, "Even if you use your API key, your requests will still go through our backend!"
- **Cursor Cloud Agents store an encrypted copy of the repository** while they run and delete it afterwards; Cursor's governance docs call them the only feature that needs to store code.

## Honest limits

**Cursor.** Pricing has moved under users before: in July 2025 Cursor wrote that a June pricing change "hurt that trust" and offered refunds for surprise charges ([Cursor blog, "Clarifying our pricing"](https://cursor.com/blog/june-2025-pricing)). Today the included pool's dollar size isn't on the pricing pages, so you can't compute your break-even before you subscribe. Its terms forbid reverse engineering the service ([Cursor terms of service](https://cursor.com/terms-of-service)), and every request goes through Cursor's servers, own key or not.

**Claude Code.** You get one lab's models and a plan ceiling you can't see in dollars: limits reset on 5-hour windows with weekly caps on top, and chat usage draws on the same pool. Fable needs usage credits on Pro. The [anthropics/claude-code repo](https://github.com/anthropics/claude-code) has 148,912 stars but no open-source license: its LICENSE file reads "All rights reserved." Routines are still a research preview.

**Octomind**, if you're weighing a third option: it's a terminal agent with no Tab completion and no editor of its own. Its editor integrations cover Neovim through a plugin and Zed and JetBrains IDEs through ACP, with no VS Code entry listed, so Cursor users would run it in Cursor's terminal.

**[Get Octomind](https://octomind.run)** — a terminal agent that runs whichever model you point it at.

## FAQ

### Can I use Claude Code in Cursor?

Yes. Anthropic's Claude Code extension installs in Cursor (search "Claude Code" in the Extensions view), and the `claude` CLI runs in Cursor's integrated terminal. You sign in with your Claude subscription or Console account, so that usage bills Anthropic, not Cursor's pool. Cursor also loads Claude Code hooks from `.claude/settings.json` and skills from `.claude/skills/` by default, so the same repo setup works in both.

### Is Claude Code cheaper than Cursor?

It depends on the model. For heavy use of Claude models, a Claude Max plan is a flat $100 or $200 a month, while Cursor bills Claude at API list price (Opus 5.5 at $4 in and $20 out per million tokens). Once your Claude usage at list price passes the plan price, the flat plan wins as long as you stay inside its limits. For work you'd hand to Cursor's own Composer 2.5, Cursor is cheaper: it lists at one-eighth of Opus 5.5's per-token price. Prices were checked in October 2026.

### Does Cursor use Claude models?

Yes. Cursor's model list includes Claude Fable 5.1, Opus 5.5 and Sonnet 5.5, billed from its Other Models pool at Anthropic's API prices. With Privacy Mode on, Fable needs admin approval first because Anthropic retains Fable requests for safety review.

### Is Cursor or Claude Code better for beginners?

Cursor, if you're new to the terminal: it's a VS Code-based editor, with changes shown as diffs and checkpoints to roll back. Claude Code expects you to describe a task and review the result, which suits developers comfortable reading diffs and running commands. Its VS Code extension and desktop app lower that bar.

### Is Claude Code open source?

No. The anthropics/claude-code GitHub repository is public, but its LICENSE file reads "All rights reserved" under Anthropic's commercial terms. Cursor is proprietary too; OpenAI's Codex CLI is Apache-2.0.