Cursor Projects vs Claude Code Agent Teams: two takes on AI-directed development

Both tools route software work across multiple AI agents. Both launched in 2026 from teams with deep AI coding expertise. That is where the similarity runs out. Cursor Projects and Claude Code Agent Teams represent genuinely different views on what multi-agent software development should look like - who plans the work, who controls the execution, and what it means for the result to be "done."

Cursor Projects is AI-directed. You describe a goal; a coordinator agent plans the work, breaks it into tasks, delegates to subagents, and continues executing on cloud infrastructure whether your laptop is open or not. Claude Code Agent Teams is developer-directed. You set up a lead session and peer sessions; each agent gets independent scope; they coordinate through a shared task list while you steer. The difference is not just architecture - it is a different answer to the question of who controls what ships.

Cursor Projects: autonomous, cloud-persistent, AI-planned

Cursor launched Projects in September 2026. The core design: a coordinator agent that does not write code itself. Instead it reads your goal, plans a body of work, breaks it into subtasks, and delegates each subtask to a subagent. Those subagents execute in parallel on cloud virtual machines. The session continues when you close your laptop - there is no local process to keep alive.

The cloud execution model is the defining feature. Cursor Projects can subscribe to external signals: Slack channel messages, GitHub PR activity, recurring schedules. A message in a Slack channel can trigger a body of work; a PR opening can trigger a review pass. The AI decides how to respond to those signals, not just execute instructions you gave it before you left.

Where Cursor Projects is strong:

• Runs asynchronously. Work continues when the developer is not present. You can set a goal at the end of the day and return to results in the morning. For long-running tasks - sweeping migrations, large test generation passes, bulk documentation - the cloud persistence removes the constraint of keeping a terminal session alive.
• AI-planned parallelism. You do not have to break the work into tasks yourself. The coordinator agent reads the goal and decomposes it. For tasks where the breakdown is not obvious, or where it would take meaningful time to plan manually, this saves a planning step.
• External trigger subscriptions. The ability to wire agent work to Slack, PRs, and schedules turns Projects into something closer to a background automation layer, not just a parallel coding session. Teams with recurring tasks benefit here.
• Credit-based, no separate pricing. Projects is included in existing Cursor plans (Pro $20/month, Pro+ $60, Ultra $200). No additional billing tier to unlock the feature during its beta period.

Where Cursor Projects adds friction:

• AI-directed means less predictable. The coordinator agent plans the work - which also means you may not know what it planned until the agents have run. For tasks where scope definition matters (what exactly should change, in which files, following which conventions), the AI-planned decomposition can drift from what you wanted.
• Still in beta. Cursor Projects launched September 2026 and is rolling out gradually. The feature surface and behavior are likely to change. Teams relying on it for stable workflows are betting on a moving target.
• Token costs scale with parallelism. Each parallel subagent uses its own context and burns tokens independently. Running many agents simultaneously multiplies token usage proportionally - a useful point to model before running large batches on an API-billed plan.
• Judgment is delegated. If the coordinator misreads the goal, all the downstream subagents execute on that misreading. There is no intermediate gate where you approve the plan before execution begins.

Claude Code Agent Teams: peer collaboration, developer-orchestrated

Claude Code Agent Teams is an experimental feature in Claude Code, disabled by default and enabled with an environment flag. The design is different from Cursor Projects in a meaningful way: there is no coordinator agent. Instead, multiple independent Claude Code sessions work as peers. One session acts as the lead; the others are teammates. All of them can communicate with each other directly, claim work from a shared task list, and report results back - not just report up to a caller.

That peer-to-peer model means Agent Teams is more interactive and developer-orchestrated. You set up the sessions, define what each teammate should focus on, and can steer mid-run. Agents can ask each other questions, flag dependencies, and coordinate on shared context. The tradeoff is that it is session-bound: if the terminal session ends, the team does too, with no cloud layer to continue independently.

Where Agent Teams is strong:

• Peer communication, not just delegation. Teammates can message each other directly, not just report results up to a coordinator. For research tasks, parallel hypothesis exploration, or multi-pass review (one agent checks security, another reviews architecture), the inter-agent communication can surface disagreements or connections that a delegation model would not capture.
• Developer-controlled scope per agent. You decide what each teammate is responsible for. If you want one agent reviewing security surface, one checking performance, and one reviewing naming conventions, you wire that explicitly. The AI does not decide how to decompose the work.
• Built into Claude Code directly. No separate tool or additional service - Agent Teams runs inside the Claude Code terminal you already use. Teams already standardized on Claude Code can use it without adding a new platform to their stack.
• No additional cost structure. Token usage counts toward your existing Claude Code quota (Pro/Max subscription or API billing). There is no separate pricing tier to unlock the feature.

Where Agent Teams adds friction:

• Experimental and disabled by default. The feature requires setting CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. It is not production-stable and carries the risks of any experimental feature: behavior changes, undocumented edge cases, limited support. Most teams should not build stable workflows on it yet.
• No cloud persistence. Agent Teams is session-bound. The work stops when you stop. There is no background execution, no trigger-based automation, no continuation when the laptop closes. For long-running or async work, this is a hard limit.
• Higher token cost per agent. Each teammate runs its own full Claude Code session with its own context window. A team of five agents uses roughly five times the tokens of a single agent for the same task. For teams watching API spend, this math adds up quickly on complex tasks.
• Coordination overhead beyond 3-5 teammates. The official guidance recommends starting with 3-5 teammates. Beyond that, the inter-agent coordination overhead increases: more shared task state to maintain, more potential for conflicting actions, more output to synthesize. Cursor Projects's coordinator model handles larger parallelism more cleanly at the dispatch layer.

Which to pick

The practical split: if the task is "run this while I sleep," Cursor Projects fits; if the task is "three agents should evaluate this from different angles while I watch," Agent Teams fits. They are not competing for the same use case so much as solving adjacent problems - asynchronous autonomous execution versus synchronous orchestrated collaboration. A team could reasonably use both in the same workflow. For more on the broader landscape of patterns - from supervised single-agent to skills frameworks to dedicated runners - which agentic coding patterns actually scale covers where each approach holds up under different constraints. The Claude Code orchestrators roundup also places both tools in context alongside the wider category.

The layer both leave open

Cursor Projects dispatches agents efficiently; Claude Code Agent Teams coordinates them effectively. What neither addresses is the structure that lives before and around the execution: deciding what to build before the agents start, a design gate that validates direction before implementation runs, a review step that checks agent output against intent before it merges.

A parallel runner or a multi-agent coordinator moves work through agents quickly. It does not decide whether the work was worth doing, whether it matched the original goal, or whether it is ready to ship. That process layer - story, design, architecture, implementation, review, release - is where defract operates: a structured lifecycle that runs on top of Claude Code, with enforced stage gates, a visual design stage, and agents reviewing each other's work before you sign off. It is not a replacement for Cursor Projects or Agent Teams, and the three are not direct competitors. Cursor Projects and Agent Teams are execution models; a gated lifecycle is the frame around the execution. For teams running agents at scale and finding the coordination overhead rising, why AI coding agents need hard stage boundaries is a useful read on what the execution layer cannot cover on its own.