Multi-agent coding orchestration for agencies: what Cursor Projects changes
A coordinator agent plans and delegates, parallel cloud subagents implement and test, and a local agent verifies on your own machine — that is the coordinator/subagent pattern Cursor Projects now ships in beta.
Cursor launched Projects in beta on September 10, 2026, the date on both its launch post and its changelog entry, with independent coverage dated September 11 agreeing. It is the clearest sign yet that Cursor is moving from editor-assistant to a managed multi-agent work surface: work lives in a Project for months while agents run against it.
The substrate is older than the product: subagents that run on their own virtual machines, each getting an "isolated copy of the project with clean context", shipped in the August 19, 2026 changelog entry, and the entry for August 27, 2026 is titled "Start from scratch, without a repo". Projects adds orchestration and persistence on top.
What the coordinator/subagent pattern actually is
Cursor's description is specific enough to plan delivery against. Agent stages run without a human; human stages are where agency time goes.
- Human: scoping. You start a Project from the left-hand nav and describe the body of work — a feature, a migration, "a full app".
- Agent: research into shared context. Project files "sync across every cloud and local machine its agents use", and agents add research, artifacts and what they learn.
- Agent: planning. The coordinator "creates a plan and sends agents to implement and test different parts of it in parallel" and is "never blocked and is always responsive to direction".
- Agent: fan-out. A Project "runs on its own computer, so closing your laptop doesn't stop it"; coordinators manage agents "running as many in parallel as the work needs".
- Agent: triggers instead of prompts. Subscriptions let the coordinator watch a Slack channel, run on a schedule, or follow your PRs and fix CI.
- Agent: local verification. When something needs testing on your machine, "the coordinator spins up a local agent to run it there".
- Human: the review gate, which narrows. "Early on, you review each PR closely." Later, "As the fixes hold up, you review less".
Nothing here lets the coordinator merge without review, and no published source measures that ramp: the pattern moves the bottleneck from writing code to reading it.
Coordinator, parallel subagents and local verification vs single-assistant coding
The difference from the single-assistant workflow most agencies standardised on is where work runs and what starts it.
| Dimension | Single-assistant coding | Coordinator + parallel subagents + local verification |
|---|---|---|
| Who plans | You, prompt by prompt | Coordinator agent plans and delegates |
| Where it runs | Your machine, your session | The Project's own cloud computer |
| Parallelism | One thread at a time | Agents implement and test in parallel |
| Testing | Your local checkout | Cloud VM first, then a local agent |
| What starts work | A prompt you type | Prompts, Slack, schedules, PRs |
| What you pay for | The seat | Seat plus metered tokens at API pricing |
| Human gate | You read every diff | You review PRs; review narrows |
Why agencies are being asked to sell this
The pitch clients hear is throughput. Cursor's launch post claims new users merge 30% more PRs and that users who primarily use Projects merge six times as many. Independent coverage is explicit that "Selection effects could influence the comparison" and that Cursor's figures "should therefore be treated as internal product evidence" — not an agency result.
What the coordinator/subagent pattern changes for an agency:
- Scoping is the product. The coordinator plans only inside the body of work it was handed; a migration's safe boundary stays human.
- The review gate is a line item. Throughput rises until review saturates; unreviewed output is backlog, not delivery.
- Environment handling is your edge. The local-agent leg exists because some tests cannot run in a cloud VM.
- Trigger design is new scope. Wiring a Slack bug channel or a PR subscription is configuration work that runs while nobody watches.
What it costs: the seat layer and the metered compute layer
Two lines in the bill, and only one has a published price per human.
- Seat layer. Pro is $20/mo, Pro+ $60/mo and Ultra $200/mo, all listing Cloud agents; Teams is $40/user/mo for Standard and $120/user/mo for Premium, which "adds 5x the Standard limits on Agent".
- Compute layer. The metered side is tokens, not a currency: cloud agents "are charged at API pricing for the selected model", a spend limit is required before first use, and a larger context window "can increase token usage and costs". Over the limit, on-demand usage continues at the same rates; Teams adds a $0.25 per million token Cursor Token Rate on top.
Cursor's only published band is individual: $60-$100/mo of total usage for daily Agent users, $200+/mo for power users running multiple agents or automation. The structural point: the seat price no longer bounds the bill — concurrency adds tokens, seat count does not move. Our AI coding agent pricing guide (updated September 14, 2026) has the per-developer math, and the three-layer AI bill shows where orchestration sits against model and tool spend. To price the parallel-agent compute line separately from the seat layer, the calculator takes seats, per-seat price, concurrent agents and token spend per agent, and reports the two lines apart.
Not disclosed: any price, allowance or per-project fee for Projects itself, any concurrent-agent ceiling, and how Projects draws on existing plan limits.
How this fits the Cursor/OpenAI split
Projects is model-agnostic where it matters to a coordinator/subagent fleet: the coordinator delegates, and agents run on whichever models the plan can reach. OpenAI intends to wind down its model contract with Cursor with a proposed November 12, 2026 cutoff, and Cursor says those models serve about 5% of its traffic — for a fleet of agents, a configuration change. We covered the dispute in what the OpenAI cutoff means for agency stacks and the workload costs in Cursor's OpenAI cutoff as a cost-shift event.
The pattern is not Cursor-exclusive. Anthropic ships in-session subagents that "work within a single session" plus agent teams coordinating "multiple Claude Code instances working together as a team", still "experimental and disabled by default"; OpenAI's Codex is the other platform on most shortlists, which our coverage of Codex passing 20 million users covers.
What to do this week
- Run one internal body of work as a Project, with the review gate written down first. Cursor says the product "works best on work that will outlive a single chat"; decide who reviews which PR before the agents start.
- Split seat spend from token spend in your pricing model. Set the required spend limit deliberately and pass metered concurrency through with a stated cap instead of absorbing it into a fixed fee.
- Inventory what cannot be verified in a cloud VM. Staging databases, devices and client environments mark the boundary of what parallel-agent throughput can promise.
Frequently asked questions
How do AI coding agents work in teams now?
Through a coordinator/subagent split. In Cursor Projects the coordinator agent "doesn't write code itself": it plans, delegates to subagents that implement and test parts in parallel, then brings "the finished work back to you to check". Cursor claims users who primarily use Projects merge six times as many PRs, a vendor-internal claim that independent coverage cautions may reflect selection effects. Anthropic's Claude Code agent teams do the same but stay "experimental and disabled by default".
Is Cursor worth it for agencies 2026?
It depends on whether you sell single-assistant work or coordinator/subagent throughput, not on the seat price. A seat is $20/mo on Pro or $40/user/mo on Teams Standard, with agent compute metered separately at API pricing. The test: if nobody reads the PRs, parallel subagents add backlog, not delivery speed.
What is a coordinator agent in Cursor Projects?
The agent that manages the work instead of doing it. Cursor describes a coordinator that "doesn't write code itself", plans, delegates, and creates agents on your behalf. It keeps running when your laptop is shut: the Project executes on its own cloud computer and calls a local agent for tests that must run on your machine.
Does a human still review the work in a coordinator/subagent setup?
Yes, and it is the part vendors measure least. Cursor has the coordinator bring "the finished work back to you to check", and review narrows only as trust builds: "As the fixes hold up, you review less". No source says agents merge on their own, so the review gate is a staffing input you set.
How do Cursor Projects and Claude Code agent teams compare?
Both implement the coordinator/subagent pattern and differ mainly in default state. Cursor ships Projects as a beta feature "rolling out to all users", with the coordinator, parallel subagents and local verification in the standard experience; Anthropic's agent teams are "experimental and disabled by default".
What has Cursor not disclosed about Projects pricing and limits?
Most of the operational detail an agency wants. No price, allowance or per-project fee is published for Projects itself, no concurrent-agent ceiling beyond "as many in parallel as the work needs", and no statement of how a coordinator/subagent workload draws on existing plan limits. Published: seats, and cloud-agent compute at API pricing.
Sources
- Cursor — Projects launch post and changelog entry (Sep 10, 2026), plus the changelog entries of Aug 19 and Aug 27, 2026.
- Cursor — docs: cloud agents, subagents, account pricing, pricing page (fetched Sep 15, 2026).
- Independent coverage — Pondero (Sep 11, 2026); Remio, source of the selection-effect caveat.
- Anthropic — Claude Code agent teams and subagents docs (fetched Sep 15, 2026).
- OpenAI — Codex pricing (fetched Sep 15, 2026).
Accuracy note: Cursor's productivity figures (30% more PRs, six times as many, 20 to 100 PRs a day) are vendor-internal with no published method and an independent selection-effect caveat, so they are reported as Cursor's claims; September 10, 2026 is the vendor-dated beta launch.