Cursor Projects vs Claude Code (2026)

Cursor Projects and Claude Code now ship the same core idea: one coordinator agent in the cloud that splits a big job into parallel agents and keeps working after you close the laptop. Cursor got there first (September 10) and wraps it in a team product with PR bots for security and deploy health. Claude Code shipped its own Projects a week later, but its strongest pieces are still the terminal: agent teams, routines, and review commands you control line by line.

Short version: pick Cursor if you are a team that wants managed bots on every pull request and in production. Pick Claude Code if you are a solo builder or small team who wants flat-rate pricing and a coordinator you can script.

What shipped in September 2026

Both tools had a busy month. Here is the timeline, because the comparison only makes sense in order.

1. September 10: Cursor launched Projects in beta, a cloud coordinator agent that delegates to other agents.
2. September 17: Anthropic relaunched Claude Code Projects, a coordinator that runs each task as a parallel cloud session.
3. September 23: Cursor shipped two "last mile" bots, Rollouts and Security Review, on Teams and Enterprise.
4. September 23: Claude Code cloud sessions left research preview and became generally available, with a one-time credit of $100 on Pro and $250 on Max.

So the "Cursor has cloud orchestration, Claude Code is a terminal tool" framing is two weeks out of date. Both now have a cloud coordinator. The differences are in who can use it, how it bills, and what surrounds it.

What Cursor Projects actually is

A Cursor Project lives in the left nav of the Agents Window. You pick a repository and a model for the coordinator, then describe the work in a chat.

Per Cursor's docs, the coordinator "doesn't write code itself. It plans the work, delegates it to agents that write the code, and brings the finished work back to you to check." Because it only delegates, it never blocks on a long task and stays responsive while its agents run.

Four design choices define it:

• Cloud by default. A Project runs on its own cloud computer, so closing your laptop does not stop it. When something must be tested on your machine, the coordinator starts a local agent for that step.
• Scale. Cursor's launch post says a Project can delegate "to thousands of subagents." That is Cursor's own claim, and it builds on their earlier research harness for coordinating many thousands of agents.
• Shared context files. Each Project keeps a set of files synced across every cloud and local machine its agents touch. If one agent works out how to test a service, every later agent inherits that note.
• Subscriptions. Tell the coordinator to watch a Slack channel, run on a schedule, or follow your pull requests and CI runs. A "Listening" pill above the chat shows every event it reacts to. Point it at a bug-report channel and it delegates a fix for each new bug.

Cursor frames the best fits as feature work spanning several PRs, migrations, and "gardening" (ongoing chores like lint cleanups or design system upkeep). For a one-off fix, a plain agent is faster and cheaper.

The gates matter. Projects is rolling out to all users but, per the docs, "isn't available on Enterprise plans" and does not work with Privacy Mode (Legacy), because Cloud Agents store code in the cloud while they run. Cloud Agents also require a paid plan.

What Claude Code brings to the same job

Claude Code does not have one feature that maps to Cursor Projects. It has four, and which one you reach for depends on where you want the work to run.

Claude Code Projects (cloud coordinator)

The closest match. A Claude Code project is one ongoing conversation. You paste in bugs, stack traces or a task list, and Claude starts a thread for each piece of work. Each thread is a full cloud session on its own branch, and threads keep running after you close the laptop. You can steer them from your phone.

Shared context comes from three places: project memory (files Claude writes itself, indexed by a MEMORY.md), project instructions (up to 16,000 characters sent to every new thread), and the repositories each thread clones, including their CLAUDE.md files. An Overview pane shows what is waiting on you, plus tabs for the Library, pull requests, and routines.

Defaults to know: every thread runs on Opus at high effort, and threads run in auto mode when the model supports it. There is no fixed thread count, but there is an enforced cap of 200 new threads per day across your projects.

The gate here is the mirror image of Cursor's. Claude Code Projects is in public beta on Pro and Max only, rolling out gradually, and not yet on Team or Enterprise.

Agent teams (local coordinator)

Agent teams are the terminal version. One session is the team lead. It spawns teammates, each a full Claude Code instance with its own context window, and they coordinate through a shared task list with dependencies and direct messaging. You can talk to any teammate without going through the lead.

They are experimental and off by default. You enable them with one setting:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

The limits are real and documented: one team per session, no nested teams, in-process teammates are not restored on /resume, and the lead is fixed for life. Anthropic's own advice is to start with 3 to 5 teammates. This is a precision tool for a few hours of parallel work on your machine, not a months-long cloud project.

Routines (scheduled and triggered cloud runs)

Routines cover Cursor's "subscriptions" idea. A routine is a saved prompt plus repositories and connectors that runs on Anthropic's cloud from three trigger types: a schedule (hourly minimum), an HTTP POST to a per-routine endpoint, or GitHub pull request and release events. You create them at claude.ai/code/routines or with /schedule in the CLI.

Routines are still a research preview, available on Pro, Max, Team and Enterprise, with a daily cap on runs per account. Each run starts a fresh session. Inside a Claude Code project, asking for scheduled work creates a routine that shows up on the project's Routines tab.

What routines do not have natively is Cursor's Slack channel subscription. On the Claude side, Slack-channel work lives in Claude Tag, which is Team and Enterprise only.

Cloud sessions (the substrate)

Cloud sessions are what threads and routines run on. Each session gets an isolated Anthropic-managed VM, checks out its own copy of the repo, and works on a separate branch. You start one from claude.ai/code, the mobile app, the desktop app, or claude --cloud in the terminal. Since September 23 they are generally available, and they draw from your plan's normal usage limits.

Security review: bot on every PR vs command on your branch

This is where the products differ most in shape.

Cursor Security Review is a managed bot. It analyzes each pull request in the context of the whole codebase, traces how user input flows through code paths, and reports findings with severity, attack path, and a proposed fix. Cursor lists coverage for SQL, command, template and LDAP injection, missing or broken auth on routes, committed secrets, unsafe deserialization, unvalidated redirects, vulnerable dependencies, and insecure infrastructure defaults. Teams can add custom rules. It is on Teams and Enterprise only.

Claude Code /security-review is a slash command. Per the command reference, it "reviews the diff between your branch and origin's default branch, identifying risks like injection, auth issues, and data exposure." You run it before you push. It is included on every Claude Code plan and costs nothing beyond normal usage.

To get Cursor-style coverage on every PR with Claude, you have three routes:

1. The open source claude-code-security-review GitHub Action, which runs in your own CI.
2. A routine with a GitHub pull_request.opened trigger and your own security checklist as the prompt.
3. Anthropic's managed Code Review on Team and Enterprise, where a fleet of agents checks each PR for logic errors and security issues. It averages $15 to $25 per review, billed through usage credits outside your plan. For deeper one-off passes, see ultrareview.

The honest read: Cursor packages this better for a team. Claude Code gives you more control and a lower floor, but you assemble it.

Rollouts: Cursor's feature with no direct match

Rollouts is the most original thing Cursor shipped this month. When a PR opens, it reads the diff and the systems it touches, then writes a monitoring plan as a PR comment, including flagging missing instrumentation before merge. After the deploy, it compares signals against a baseline in Datadog, Grafana or Honeycomb and reports each environment as "verified healthy, regression detected, or inconclusive."

When it finds a regression, it can ping the author, pause a progressive rollout, or open a revert PR, depending on how the team configures it. Teams get roughly 50 changes worth of trial credits and Enterprise roughly 500, for 10 days. Pricing after the trial was not spelled out in the announcement.

Claude Code has no packaged equivalent. The closest build is a routine with an API trigger: your CD pipeline POSTs to the routine after each production deploy, and the routine runs smoke checks, scans logs through a connector, and posts go or no-go. Anthropic's routines docs list exactly this "deploy verification" pattern. It works, but you own the prompt, the baseline logic, and the connectors.

Feature comparison table

Plan gates and pricing

Plan gates decide this comparison more than features do, because each company locked its coordinator out of a different tier.

Prices come from Cursor's pricing page and Claude's pricing page as of September 25, 2026.

The billing model is the real split. Cursor charges Cloud Agents at API rates for whatever model you choose, and Cursor notes that five parallel subagents cost roughly five times the tokens of one. A Project that fans out wide can get expensive fast, which is why Cursor asks you to set a spend limit the first time.

Claude Code Projects and cloud sessions draw from your flat subscription. Anthropic is clear that a project burns through limits faster than a single session, especially on Pro. But when a thread hits the limit it waits and resumes when the window resets. It only spends extra money if you turned on usage credits. For a builder running parallel work most days, a flat Max plan is easier to predict than per-token cloud billing.

Workflow differences in practice

Take one job: migrate a Next.js 16 app's data layer to oRPC with Zod across 40 routes.

In Cursor, you create a Project on the repo, pick a coordinator model, and describe the migration. The coordinator plans, spins up agents per route group in the cloud, and they share what they learn in the project files. Each change goes up as a PR. Security Review comments on each one. After merge, Rollouts watches each deploy and can open a revert PR if an endpoint regresses. Your whole team sees the same Project and bots.

In Claude Code, you have two choices. From the terminal, you can use /batch, which splits the work into 5 to 30 units and runs one background subagent per unit in its own git worktree, each opening a PR. Or you open a Claude Code project, paste the migration plan, and let it start a thread per route group in the cloud. You run /security-review or /code-review before merging, and optionally a routine to verify each deploy.

Same outcome. Cursor gives you more managed pieces around the edges. Claude Code gives you more ways to run the core loop, and all of them read the same CLAUDE.md, skills and hooks you already set up.

Who each one is for

Cursor Projects fits best if:

• You are a team on Cursor Teams and want Security Review and Rollouts on every PR without writing anything.
• You want to switch models per task, including Claude and Grok models, inside one tool.
• Your work arrives in Slack and you want the coordinator to pick it up automatically.
• You live in an IDE and want to review diffs visually.

Claude Code fits best if:

• You are a solo builder or small team who wants a flat monthly price instead of per-token cloud billing.
• You want to script and tune the coordination: agent teams, subagents, hooks and CLAUDE.md rules you version in git.
• You already run everything from a terminal, or want to steer cloud work from your phone.
• You want Claude models at full depth, with the settings (effort levels, model per thread) under your control.

When to pick the other one

Being fair to both sides:

Pick Cursor over Claude Code if your org is on a Team or Enterprise Claude plan and wants a cloud coordinator today. Claude Code Projects is Pro and Max only right now. Also pick Cursor if deploy monitoring is the problem you actually have. Rollouts has no Claude equivalent, and building one yourself is real work.

Pick Claude Code over Cursor if you are on Cursor Enterprise, where Projects is not available, or if your company requires Privacy Mode (Legacy). Also pick Claude Code if token costs from wide fan-out worry you. Flat plan limits with a pause-and-resume behavior are safer than an API bill on a runaway coordinator. If ownership of the tool is a concern after Cursor's SpaceX deal, that is another reason to weigh it.

Plenty of teams run both. Cursor in the editor with its bots on PRs, Claude Code in the terminal for the heavy agent work. If you are moving over fully, the Cursor to Claude Code migration guide covers rules, settings and habits. For the broader editor-vs-agent comparison, see Claude Code vs Cursor.

Both coordinators are betas that shipped two weeks ago. Recheck the plan gates before you commit, because that is the part most likely to change next.

Posted by @speedy_devv