Cursor Built a Coordinator That Never Writes Code. It Just Directs Thousands of Agents That Do.

Most AI coding tools sell you a faster typist. Cursor just shipped something that acts more like a manager, and the pitch is unusual enough that it is worth taking seriously: an agent whose entire job is telling other agents what to do, and never touching a line of code itself.

The feature is called Projects, and Cursor rolled it out in beta on September 10. At the center of it sits a “coordinator” agent that reads a request, breaks it into tasks, spins up as many implementation agents as the work requires, and checks their output before handing the result back to a human. It can run for months on a single codebase without losing context, and it does not wait for you to open the editor to start working.

What the coordinator actually does

Cursor has offered background agents for a while: send off a task, walk away, come back to a finished diff. Projects is a step up from that. Instead of assigning one agent to one task, you hand the coordinator a goal, something the size of a feature, a large migration, or an entire small app, and it decides how to split that goal into pieces.

Each piece goes to its own implementation agent. The coordinator tracks what is done, what is blocked, and what needs a second pass, then assembles the finished work for a human to review. Cursor’s own framing is blunt about the division of labor: the coordinator plans and supervises, it does not write.

The part that separates this from a smarter autocomplete is persistence. A Project keeps its own memory of a codebase across weeks or months, so a coordinator returning to a repository in October can reference decisions it made in August without being re-briefed. Connect it to Slack or GitHub and it can also start work on its own, picking up a bug report the moment it lands in a channel or opening a fix the moment a flaky test starts failing on main.

The 30% number, and the six times number

Cursor’s headline stats are a 30% increase in merged pull requests for new users of Projects, rising to roughly six times as many merged PRs among developers who lean on it heavily. Those are Cursor’s own figures, drawn from its own beta cohort, and they measure merges rather than lines of code or feature completeness, which matters because merge counts can climb just by splitting the same work into smaller, easier to review chunks.

That caveat does not make the number meaningless. It does mean the honest reading is “teams are shipping more discrete units of reviewed work,” not “teams are six times as productive.” Cursor itself pitches three concrete use cases rather than a blanket productivity claim: building a full feature end to end, running a migration across hundreds of pull requests, and ongoing maintenance work like lint rule generation or pulling repeated code into shared components, the unglamorous jobs nobody schedules time for.

What it costs to run a thousand agents

Here is the part that tempers the excitement. Cloud agent runs in Cursor bill separately from the flat subscription tiers, and running them well requires MAX mode, which adds a 20% surcharge on top of whatever the underlying model call costs. One widely cited test found that a single large agent run against a 50,000 line codebase could burn through roughly a fifth of an entire $20 monthly credit allotment in one go. Multiply that by a coordinator dispatching dozens of agents at once and the math stops looking like a flat monthly bill.

None of that is unusual for cloud compute, but it is a real shift for developers used to a fixed monthly fee. Token prices have been falling for over a year, yet enterprise AI bills keep climbing, because cheaper tokens just make it economical to run far more of them. A coordinator that can legitimately spin up a thousand agents is the clearest illustration yet of that pattern, and it puts real pressure on whoever owns the engineering budget to set hard caps before a Project gets ambitious on its own.

Where Projects sits next to Devin, Copilot, and Claude Code

Cursor is not the first to promise autonomous coding at scale. Devin popularized the delegate-and-wait model, where you hand off a ticket and it comes back asynchronously with a pull request. GitHub Copilot’s workspace agent converts issues into PRs directly inside GitHub. Anthropic’s Claude Code works from the terminal, leaning on a large context window to understand sprawling codebases without an IDE at all. OpenAI, meanwhile, packaged its own Codex-based orchestration into a single API call this month, aimed less at individual developers and more at teams building agents into their own products.

The distinction that matters is fan out. Devin, Copilot’s workspace agent, and Claude Code all mostly operate as one agent per task. Cursor’s coordinator is explicitly designed to run many agents on many pieces of the same goal simultaneously, then merge the results. OpenAI’s new Agents API moves in a similar direction, exposing the same kind of session management and recovery logic Cursor is now offering inside an editor, which suggests orchestration, not raw model quality, has become the thing coding tools actually compete on. Cursor’s decision to add Grok 4.6, a model built for long running agent work, in the same release backs that up.

Who is actually watching a thousand agents

Handing a coordinator the ability to watch a Slack channel and start work unprompted is convenient right up until it isn’t. A Project that reacts to every bug report in a channel will eventually open a pull request nobody asked for, against a change nobody scoped, at a time nobody was looking. Cursor’s review step is the safety net here: agents write, a human still has to approve before anything merges. Whether that step holds up once a team is fielding dozens of autonomous pull requests a week is an open question, and it is the same question raised by a recent case where hundreds of AI agents were pointed at a single target and did more damage in four hours than a lone attacker could manage in a week. Scale cuts both ways, and a tool built to make benign automation cheap makes reckless automation cheap too.

What to watch next

• Whether the merge rate holds up under scrutiny. A 30 percent jump in a beta cohort self selected for enthusiasm is not the same as a 30 percent jump across a random engineering org.
• Whether cost controls get sharper. Anomaly detection that flags a runaway session after it has already spent real money is a weaker guarantee than a hard spending cap set in advance.
• Whether competitors add their own coordinators. If Devin or Copilot ship a similar fan out model within the next few months, Projects will have set the template rather than just shipped a feature.
• Whether review actually keeps pace. The bottleneck in agentic coding has quietly shifted from writing code to reading it. A coordinator that produces work faster than any team can review it just moves the problem downstream.

Cursor built Projects on a reasonable bet: that most software work is not actually bottlenecked on typing speed, it is bottlenecked on how many things one person can track at once. A coordinator that tracks a thousand things is a genuine answer to that problem. Whether it is an affordable one, and a safe one, is still being worked out in production, one merged pull request at a time.

Sources and further reading

• Cursor: Introducing Projects and the coordinator agent
• The New Stack: OpenAI and Cursor on agent coordinators

About this article: GeekBlog covers U.S. technology news, AI, phones, smartwatches and gaming. Every story is written and checked under our Editorial Policy. Spotted a mistake or have a story tip? Contact our editors.