Cursor Projects Review: A Coordinator Agent That Manages Thousands of Subagents (2026)

What Cursor Announced

On September 10, 2026, Cursor launched Projects in beta. The framing Cursor uses is "the third era" of AI-assisted development, but the mechanism is simpler and more interesting than the slogan: a coordinator agent that does not write code.

The coordinator plans the work, delegates implementation to subagents, and hands finished results back for you to review. It creates and manages those agents on your behalf and runs as many in parallel as the work requires — Cursor's own description says it can delegate to thousands of subagents across work that spans months.

That single architectural choice explains most of the behavior that follows. Because the coordinator delegates rather than executes, it is never blocked waiting on one long task — it can keep planning, keep spawning, and keep responding to you while work proceeds elsewhere.

The Three Pillars

Cloud-first execution

Every Project runs on its own machine in the cloud. Closing your laptop does not pause the work. When something needs testing on your machine specifically, the coordinator spins up a local agent to handle it and folds the result back into the Project.

This is the difference between "an agent running in my editor" and "a workload I own." It also means the ceiling on parallelism is no longer your laptop's.

Shared context

Each Project maintains a set of files synced across every cloud and local machine its agents use. Agents write back research findings, artifacts, their understanding of the codebase, and — notably — your preferred ways of working.

The example Cursor gives is the clearest illustration: once one agent works out how to test a particular service, every subsequent agent inherits that procedure automatically. Institutional knowledge about a codebase is exactly what makes senior engineers valuable and new hires slow; a context layer that accumulates it is the most consequential part of this release, and the part most worth watching skeptically — a stale instruction propagates to every future agent just as faithfully as a good one.

Subscriptions

The coordinator can watch a Slack channel, follow your pull requests, or run on a schedule, then act on signals without waiting for a prompt. Point it at a bug-report channel and each incoming report dispatches work on its own.

How Teams Actually Use It

Cursor has been running Projects internally for months and describes three patterns.

Feature development. The Project researches the codebase, builds shared context, produces a plan, then sends agents to implement different parts in parallel. After shipping, the same Project monitors logs and handles bug reports with full knowledge of the original design decisions.

Migrations. Cursor used Projects internally to adopt new frameworks and replace styling systems across hundreds of pull requests. The pattern is deliberately incremental: establish a safe approach with the coordinator, then let it apply that approach repeatedly. Review closely at first, less as the fixes hold.

"Gardening." The maintenance work that never ends. One Cursor engineer runs a design-system Project that scans every new PR, extracts components that belong in the design system, and adds a lint rule when it sees the same mistake twice. That Project is on track to touch 20 to 100 PRs a day.

The Numbers

Cursor's reported productivity figures:

The six-fold figure is the one that travels. Two things to hold in mind: these are vendor-reported numbers from internal dogfooding, not an independent study, and PR count is a volume metric — it says nothing about correctness, review burden, or whether more PRs were a goal. A design-system Project generating 100 PRs a day is impressive coordination and also 100 things someone may need to look at.

Where the Model Breaks Down

Three limits are worth naming before you hand over a migration.

1. Cost is invisible at the coordinator level. The coordinator is cheap to talk to; the subagents are not. Thousands of parallel agents spending tokens and compute is a budget line, and the interface does not foreground it.
2. Review discipline has to front-load. The migration pattern works because humans review closely early and slacken later. Teams that skip the early phase will discover systemic problems at PR number 200.
3. Shared context is a double-edged asset. It compounds expertise and it compounds mistakes. Version it, audit it, and treat it like code.

There is also a strategic consideration: Projects is a bet that multi-agent orchestration belongs inside the editor, not in a framework you assemble. GitHub Copilot, Codeium (Windsurf), and Replit are all pushing agentic features, but most still operate at the single-agent, single-task level. A persistent coordinator accumulating months of project knowledge is a genuinely different shape.

Who Should Use It

Summary

Cursor Projects moves the unit of AI-assisted work from the task to the project — a coordinator that plans, delegates to parallel subagents, runs in the cloud while you are away, and gets more useful as its shared context accumulates. The migration and maintenance patterns are where it earns its keep immediately; feature development benefits most when the work genuinely parallelizes.

The six-fold PR figure is worth remembering and worth discounting: it is self-reported, and it measures volume rather than quality. The real test for your team is not how many PRs a Project can produce, but whether your review process scales to match what it produces.

For the tool it extends, see our Cursor review and the Windsurf vs Cursor comparison. For the harness underneath OpenAI's competing approach, see the Agents API guide.

Related Articles

• Cursor Review
• Windsurf vs Cursor
• Devin vs Claude Code
• Best AI Coding Agents 2026