What is the difference between Cursor Projects, Claude Code and the OpenAI Agents API?

They sit at three layers. Cursor Projects (beta from September 10, 2026) is an end-user product: a coordinator agent that never writes code itself, plans a body of work, delegates to cloud subagents, keeps a shared-context file set that syncs across machines, and can subscribe to Slack channels, schedules or PRs. Claude Code is Anthropic's terminal agent that does the work directly, with its own subagents, hooks, GitHub app and server-side remote sessions via Cowork. The OpenAI Agents API (public beta, also September 10, 2026) is infrastructure: it rents out the Codex harness — hosted sandboxes, compaction, subagents, MCP — so you can build your own long-running agents. Cursor is the product, Claude Code is the agent, the Agents API is the platform.

Which is best for a months-long migration across hundreds of PRs?

Cursor Projects is purpose-built for that as of September 2026: Cursor says it used Projects internally for migrations of a few hundred PRs and that users who primarily use Projects merge six times as many PRs. The coordinator applies an agreed approach incrementally and you review less as fixes hold up. Claude Code can do the same with a human or a script driving the loop, and the Agents API can host a custom coordinator, but neither ships a persistent, cloud-hosted coordinator with shared context and subscriptions out of the box.

How much do Cursor Projects, Claude Code and the Agents API cost?

Cursor has not published Projects-specific pricing; Projects run on Cursor's Cloud Agents and consume usage on Cursor plans, which start at $20 per month for Pro. Claude Code is included with Claude Pro ($20 per month) and Max ($100 and $200 tiers), or billed at API token rates. The OpenAI Agents API has no separate fee: you pay the model's token rates (GPT-6 Astra is $10 per million input and $50 per million output), built-in tools, and hosted-sandbox container rates, or bring your own sandbox from partners such as E2B, Modal or Cloudflare.

Which one keeps working when I close my laptop?

All three now do, in different ways. A Cursor Project runs on its own cloud computer and spins up a local agent only when something must be tested on your machine. Claude Cowork remote sessions (beta, Max plans first, September 2026) keep a Claude task running on Anthropic's servers with state synced across devices. The OpenAI Agents API is server-side by design — sessions retain state on OpenAI's side and can be resumed later — though it supports US data residency only and is not Zero Data Retention eligible in beta.

Quick Answer

Cursor Projects vs Claude Code vs OpenAI Agents API

Published: September 14, 2026

The short answer

Two launches on the same day — September 10, 2026 — pushed “fleets of coding agents” from demo to product. Cursor Projects gives you a coordinator you chat with while it directs thousands of subagents. OpenAI’s Agents API gives you the harness to build that coordinator yourself. Claude Code remains the strongest single agent that does the work, now with server-side sessions of its own.

	Cursor Projects	Claude Code	OpenAI Agents API
Status	Beta, rolling out to all users from September 10, 2026	GA; Fable 5.1 access since September 2026	Public beta since September 10, 2026; no GA date
What it is	Coordinator agent + cloud subagents + shared context + subscriptions, inside Cursor	Terminal coding agent with subagents, hooks, GitHub app, Cowork remote sessions	Hosted Codex harness: sandboxes, compaction, parallel subagents, MCP, resumable sessions
Who writes the code	Subagents; the coordinator only plans, delegates and reviews	Claude Code itself (or its subagents)	Your agent, running on OpenAI’s loop
Runs when laptop closed	Yes — Project has its own cloud computer	Yes via Cowork remote sessions (beta, Max first)	Yes — server-side sessions
Persistent memory	Shared-context files synced across every cloud and local machine	CLAUDE.md, memory files, Cowork persistent threads	Session state retained on OpenAI’s side
Triggers without prompting	Slack channel, schedule, follow all PRs / fix CI	Claude Code GitHub app on PRs; Cowork scheduled tasks	Whatever you wire up
Model choice	Cursor’s model menu (Anthropic access continues; OpenAI access ends November 12, 2026)	Claude only (Fable 5.1, Sonnet 5, Opus 5)	OpenAI models (GPT-6 Astra, GPT-5.6 line)
Pricing	Cloud Agent usage on Cursor plans from $20/mo; no Projects-specific price published	Claude Pro $20/mo, Max $100–$200/mo, or API tokens	Model tokens + tools + sandbox; GPT-6 Astra $10/$50 per MTok
Best for	Features, migrations and “gardening” that outlive one chat	Deep, interactive work in your own repo and terminal	Building your own agent product or internal fleet

Cursor Projects: the coordinator pattern, productized

Cursor’s pitch is that Projects is the “concrete implementation” of the third-era-of-software vision it published in February 2026. Three capabilities define it:

Cloud by default, local when needed. A Project runs on its own computer, so it can run more subagents in parallel than your laptop could and survives you closing the lid. When something needs testing locally, the coordinator spins up a local agent.
Shared context. Each Project maintains a set of files synced across every cloud and local machine its agents use. Agents write research, artifacts, codebase knowledge and your preferences into it — “if one agent figures out how to test a service, every future agent can use those instructions.”
Subscriptions. The coordinator can watch a Slack channel, run on a schedule, or follow all your PRs, fixing CI and acting when they open or merge.

Cursor’s internal numbers: new users merge 30% more PRs; users who primarily use Projects merge six times as many. One engineer’s design-system Project scans every new PR, extracts components, and adds a lint rule when it sees the same mistake twice, on track to touch 20–100 PRs a day.

The trade-offs: Projects is beta; the coordinator’s model selection and per-subagent costs are opaque compared with a CLI you meter yourself; and Cursor’s OpenAI model access ends November 12, 2026, so Projects’ model pool will be Anthropic, xAI, Cursor’s Composer line and open models after that.

Claude Code: the agent that does the work

Claude Code is still the tool most teams reach for when a human is in the loop. What it brings to the fleet question as of September 2026:

Subagents and hooks let you fan out research or parallel edits from one session, but orchestration is per-session and scripted, not a persistent coordinator.
Cowork remote sessions (beta, Max plans first, September 2026) keep tasks running server-side with state synced across desktop and mobile — the same “close your laptop” guarantee Cursor Projects offers.
Claude Code GitHub app reacts to PRs and issues, covering the “follow my PRs” subscription case.
Model quality: LogRocket’s September 2026 power rankings put Claude Code at #1 after it gained Fable 5.1 access.

What it lacks: a hosted, always-on coordinator with a shared-context store that grows across weeks of work and dozens of agents. You can build that with the Claude Agent SDK, but it is not a checkbox.

OpenAI Agents API: the harness for rent

The Agents API gives developers the same infrastructure that runs Codex and ChatGPT Work: create a session with model, instructions, tools, MCP servers and an environment, and OpenAI runs the loop — sandbox execution, context compaction, parallel subagents, mid-turn steering, resumable sessions. Sandboxes are OpenAI-hosted or from partners (Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, Vercel).

It is the right choice when you are building the coordinator rather than using one: internal migration fleets with custom policy, agent products, or anything that must run on OpenAI models after Cursor’s cutoff. Beta caveats: US-only data residency, no Zero Data Retention, no GA date.

Decision guide

You want the fleet today and live in Cursor: Projects. Start with a migration or a “gardening” job, review every PR early, and let the coordinator earn autonomy.
You want the best single agent and control over cost per run: Claude Code, with Cowork remote sessions for background work and the GitHub app for PR triggers.
You are building an agent product or a company-wide fleet with your own rules: the OpenAI Agents API (or the Claude Agent SDK if you standardize on Anthropic models).
You need OpenAI models inside a coordinator after November 12, 2026: not Cursor — build on the Agents API or Codex.

What to watch

Cursor Projects pricing. Cloud-agent-hour or per-subagent billing will determine whether “thousands of subagents” is a feature or a bill shock.
Shared context portability. If Project context files can be exported, they become the team’s agent memory; if not, they are lock-in.
Whether Anthropic ships a coordinator. Cowork persistent threads plus remote sessions are one step away from a Projects-style product.

Last verified: September 14, 2026.