Cursor 3.3's /multitask: Running Subagents in Parallel Without the Wait

Cursor 3.3 shipped a small command with a big workflow impact: /multitask. Instead of queuing follow-up prompts and waiting for the agent to chew through them one at a time, /multitask spawns each prompt as an async subagent. They all run at once, in parallel, and their results come back to the parent thread as they finish.

If you're coming from Claude Code subagents, the shape will feel familiar — separate context windows, isolated tool calls, summary back to the parent. The Cursor implementation has one big difference: it's woven into the editor, so you watch all the subagent windows tick along in the Agents panel while you keep working in your main thread.

The Syntax

/multitask takes a series of prompts separated by triple bars (|||). Each prompt becomes its own subagent. The parent agent stays put and gets back a summary block when all subagents are done — or you can configure it to stream results as each one completes.

/multitask
Find every usage of the old UserAuth class across the repo and list file paths
|||
Write a migration guide markdown doc explaining how to switch from UserAuth to AuthSession
|||
Update the test fixtures in tests/fixtures to use AuthSession instead of UserAuth
|||
Run the type checker and report any remaining UserAuth references it complains about

Four subagents launch in parallel. The first three each do their own piece. The fourth runs the type checker as a final sweep. Wall-clock time is roughly the slowest single task instead of the sum of all four.

When /multitask Beats Sequential

Three patterns where /multitask is a clear win. The first is read-heavy fan-out: searching for usages across many files, summarizing multiple documents, or pulling context from different parts of a repo. The work is naturally parallel and read-only, so no race conditions.

The second is independent generation: write a test, write a doc, write an example, all from the same spec. The outputs do not depend on each other, so parallel saves wall-clock time. The third is verification passes — running lint, types, and tests as three parallel subagents finishes in the time of the slowest one.

When /multitask Loses Hard

Three patterns where /multitask backfires. Sequential dependencies: if task B needs task A's output, parallel is impossible and you've paid for extra context. Shared file edits: two subagents both trying to rewrite the same file will conflict, and Cursor will pick one and discard the other.

The third is the sneaky one — what looks parallel but isn't. "Refactor module A and module B" sounds independent, but if both import the same shared types, a change to types from one subagent breaks the other's view of the world. Check whether your prompts touch overlapping surface area before fanning them out.

Token Cost and How to Limit It

Each /multitask subagent runs in its own context window with its own system prompt and tool definitions. Four subagents means roughly four parent-context-windows of overhead in addition to the actual work. On Cursor's usage-based pricing for Bugbot and similar parallel features, this adds up quickly.

Two configuration options keep this in check. /multitask --max 3 caps how many subagents can run at once even if you give it more prompts — the rest queue. /multitask --budget 50000 stops the run once total token use crosses the limit, returning partial results. Both flags are worth setting by default in your Cursor rules.

/multitask --max 3 --budget 75000
Prompt 1
|||
Prompt 2
|||
Prompt 3
|||
Prompt 4
|||
Prompt 5

A Workflow That Pays Off

The pattern I keep coming back to: use /multitask for the discovery phase of a refactor, then run the actual changes in a single agent thread. The discovery phase is naturally parallel — find usages, find tests, find docs, find related types — and the results all flow back as summaries. The change phase is naturally serial, with one agent holding the whole picture and making consistent edits.

# Phase 1: parallel discovery via /multitask
/multitask --max 4
List every file that imports the deprecated parseDate util
|||
Find every test that mocks parseDate and list the mock patterns used
|||
Search docs/ for any mention of parseDate and list the file paths
|||
Read the parseDate implementation and summarize its current behavior in 5 bullets

# Phase 2: single agent, sequential migration using the discovery results
Using the four summaries above, migrate every parseDate call to the new dateParser util.
Update tests, then docs. Do not commit; show me the diff first.

How /multitask Compares to Claude Code Subagents

Both tools run subagents in parallel with separate context windows. The main differences: Cursor /multitask is invoked explicitly in the editor with the ||| separator and gives you the Agents panel visualization. Claude Code spawns subagents implicitly when the parent agent decides to, which is more flexible but harder to predict. Cursor's pricing is usage-based by default; Claude Code subagents count against your plan's rate limit.

Pick the explicit approach (/multitask) when you know exactly which work can run in parallel. Pick the implicit approach (let Claude Code decide) when you're delegating a high-level task and want the agent to make the parallelism call. They're not competing — they're answering different questions about where you want the control to sit.