# Claude Code Agent Teams vs Cursor Background Agents

> Claude Code's experimental agent teams run multiple subagents in parallel inside one session on your machine; Cursor Background Agents run one agent per task in a remote cloud VM. Different coordination models, different setup, different token cost. Side-by-side breakdown.

Canonical: https://www.agentickit.co/compare/claude-code-agent-teams-vs-cursor-background-agents
Last updated: 2026-11-18

Claude Code's agent teams spin up several subagents that work in parallel inside a single local session, each in its own context window, coordinated by the main agent that dispatched them. Cursor Background Agents take the opposite shape: one agent per task, each running in its own remote cloud sandbox, kicked off from the editor, Slack, or the web and left to finish on its own. One scales out inside a session you're watching; the other scales out across tasks you're not watching. Last updated 2026-11-17 by Rakshit Yadav.



## Verdict in one line
**They parallelize different things.** Agent teams parallelize the steps inside one task you're actively running — review this PR from three angles at once, say — and report back into the same session. Background Agents parallelize across separate tasks you'd rather not babysit at all — kick off three unrelated refactors and go to lunch. Picking between them is really a question of whether you're still in the loop or not.

## Feature definitions, side by side
<table><thead><tr><th></th><th>Claude Code agent teams</th><th>Cursor Background Agents</th></tr></thead><tbody><tr><td>**What it is**</td><td>The main agent dispatches multiple subagents at once for one task, each in its own context window, on your machine (or your terminal's session)</td><td>A full agent run moved off your machine entirely, into a remote cloud VM with its own clone of the repo</td></tr><tr><td>**Who starts it**</td><td>The main Claude Code agent, deciding a task benefits from splitting work across roles (e.g. one subagent reviews security, another checks tests)</td><td>You, explicitly — from the editor, a Slack handoff, or the Cursor web dashboard</td></tr><tr><td>**Where it runs**</td><td>Locally, inside the session you're watching — subagents return a final report into the main thread</td><td>A remote sandbox you are not watching live; it typically opens a PR when done</td></tr><tr><td>**Lifespan**</td><td>Lives for the duration of the task that spawned it, then its context closes</td><td>Can run long — minutes to much longer — unattended, independent of your editor session</td></tr><tr><td>**Isolation unit**</td><td>Context window per subagent, same machine</td><td>Full VM per task, separate machine entirely</td></tr></tbody></table>

## Setup and flag requirements
Agent teams in Claude Code are an extension of the ordinary [subagent](https://www.agentickit.co/compare/claude-code-skills-vs-subagents-vs-hooks) mechanism: you define roles as `.claude/agents/*.md` files (or let the main agent's built-in general-purpose agent act as the parallel worker), and the main agent decides when a task is worth splitting across more than one of them. There's no separate account tier or remote infrastructure to provision — it's a local capability, gated by how many subagents you've defined and how the main agent judges the task, not by a toggle you flip once for the whole project.
Background Agents are the opposite: they're a hosted Cursor product feature, which means access and limits are controlled by your Cursor plan rather than by anything in your repo. The repo itself needs nothing special to support it beyond being a normal git repository Cursor's infrastructure can clone — no additional config file is required for the feature to work, though any rules or skills already committed will load the same way inside the sandbox as they would locally.

## Token and cost shape
Both features cost more than a single agent doing the same work serially, but for different reasons. Agent teams multiply *token usage within one task*: each parallel subagent carries its own context window and its own round of tool calls, so a review split three ways burns roughly three subagents' worth of tokens instead of one, even though it finishes faster in wall-clock time. That cost is visible in the same session, against the same API usage, as soon as the subagents return.
Background Agents multiply *compute, not model calls* — the token cost of the agent's reasoning is comparable to running the same task locally, but each task now also pays for a dedicated remote VM running for however long the task takes. The practical tradeoff is the same shape either way: paying more to get work done without your direct attention, whether that premium shows up as extra tokens in one session or extra compute minutes on a separate machine.

## Coordination model differences
Agent teams coordinate through the main agent that dispatched them: it decides who does what, waits for each subagent's report, and reconciles the results into one answer back to you. The subagents don't talk to each other directly, and they don't survive past the task — there's no persistent "team" object, just a main agent that happened to delegate to several workers this one time.
Background Agents coordinate through you, or through whatever tool kicked the task off (Slack, the web dashboard, your editor). There is no main agent reconciling multiple Background Agents into one answer — each one is independent, and if you fire off three of them for three different refactors, you are the one who ends up comparing the three resulting PRs. That's a feature for truly unrelated tasks and a gap if the tasks actually depend on each other's output.

## When to pick each, for a solo SaaS repo
<table><thead><tr><th>Situation</th><th>Pick</th><th>Why</th></tr></thead><tbody><tr><td>Reviewing one PR from several angles (security, tests, style) before merging</td><td>Agent teams</td><td>One task, several perspectives, you want the reconciled answer in the same sitting</td></tr><tr><td>Three unrelated backlog items (a migration, a flaky test fix, a landing page copy pass)</td><td>Background Agents</td><td>No dependency between them, and you don't want to wait for any of them live</td></tr><tr><td>A task that needs to keep running after you close your laptop</td><td>Background Agents</td><td>Remote sandbox survives independent of your local session</td></tr><tr><td>A task where the subresults need to be merged into one coherent output right now</td><td>Agent teams</td><td>Reconciliation happens inside the same session automatically; nothing to compare by hand afterward</td></tr><tr><td>Budget-sensitive single task with no real parallel benefit</td><td>Neither — run it as one agent</td><td>Both add overhead (token or compute) that only pays off when the split actually saves wall-clock time or lets you walk away</td></tr></tbody></table>If you're on Claude Code and deciding between a single subagent and a full team, [Claude Code Subagent Limits: Concurrency and the Model Setting](https://www.agentickit.co/compare/claude-code-subagent-concurrency-model-setting) covers how many can run at once and what that does to context and cost. If you're deciding whether AgenticKit's role-scoped agents are worth layering under either feature, see [AgenticKit vs Cursor Background Agents](https://www.agentickit.co/compare/agentickit-vs-cursor-background-agents).



## FAQ

### Are Claude Code agent teams the same thing as Cursor Background Agents?
No. Agent teams split one task across several subagents running in parallel inside a single local session, reconciled by the main agent. Background Agents move one whole task off your machine into a remote cloud sandbox, run independently of your editor, and typically finish by opening a PR.

### Which costs more, agent teams or Background Agents?
Both cost more than a single serial agent, but differently: agent teams multiply token usage within one task, since each parallel subagent carries its own context window and tool calls. Background Agents add dedicated remote compute time per task rather than multiplying the model calls for the same work. Check current Anthropic and Cursor pricing for exact rates before relying on either at scale.

### Can I use both agent teams and Background Agents together?
Not directly — agent teams are a Claude Code mechanism and Background Agents are a Cursor product feature, so they belong to different tools. If you run both tools across a project, the same role and skill files can inform either one; see AgenticKit vs Cursor Background Agents for how that overlap works.

### Do I need a special flag or plan to use agent teams in Claude Code?
Agent teams build on the existing subagent mechanism (.claude/agents/*.md files and the main agent's own judgment about when to split work) rather than a separate toggle. Background Agents, by contrast, are gated by your Cursor plan since they run on Cursor's hosted infrastructure.

### Which one should a solo founder reach for first?
Agent teams for a single task you want reviewed or built from multiple angles right now, in the same sitting. Background Agents for independent tasks you'd rather hand off and come back to later, especially ones that don't need to be reconciled with each other.

## Related
- [The 34 AgenticKit agents](https://www.agentickit.co/agents)
- [Claude Code Subagent Limits: Concurrency and the Model Setting](https://www.agentickit.co/compare/claude-code-subagent-concurrency-model-setting)
- [CLAUDE.md vs Skills vs Subagents vs Hooks](https://www.agentickit.co/compare/claude-code-skills-vs-subagents-vs-hooks)
- [AgenticKit vs Cursor Background Agents](https://www.agentickit.co/compare/agentickit-vs-cursor-background-agents)
- [Cursor Agents vs Commands](https://www.agentickit.co/compare/cursor-agents-vs-commands)
- [tech-lead agent](https://www.agentickit.co/agents/tech-lead)
