Contents
- Three ways to work in parallel
- Subagents vs. agent teams
- Where Claude Project threads fit
- What parallelism costs
- A small test before scaling up
- When to use each option
- Questions people ask
Running several Claude agents at once can shorten the time to a result, but it does not make the work free or automatically better. Claude Code has subagents that work inside one session, agent teams made of cooperating Claude Code sessions, and Claude Projects threads that can run separate cloud sessions. They differ in coordination, isolation, availability, and how quickly they use your plan allowance.
This guide is a documentation-based comparison, not a report of a benchmark we ran. The previous version presented stopwatch timings, token counts, and a dollar estimate as our own test results; we could not verify a reproducible record for those measurements, so they have been removed.
Three ways to work in parallel
“Parallel agents” is an umbrella phrase, not one feature with one concurrency limit. Start by identifying which product path you mean.
| Option | How it works | Best fit | Main trade-off |
|---|---|---|---|
| Subagents | Workers run in their own context windows inside a single Claude Code session and return results to the parent. | Bounded research, code review, tests, or exploration where one coordinator should combine findings. | They still consume the session’s usage. Their results need parent review; they are not independent project sessions. |
| Agent teams | A lead coordinates multiple Claude Code instances. Teammates have separate context windows, a shared task list, and direct messaging. | Work that needs independent investigation, discussion, or separately owned implementation areas. | Experimental, opt-in, and more token-intensive. Coordination, permissions, and integration add work. |
| Claude Project threads | In the redesigned Projects experience, a coordinator can delegate work to parallel cloud threads; each thread is a Claude Code cloud session on its own branch and repository copy. | Long-running work where you want a project-level coordinator and reviewable thread outputs. | Availability is rolling out in beta; multiple threads consume plan usage faster and overlapping edits still need merge resolution. |
Subagents and agent teams are easy to confuse because both show multiple agents in the interface. The deciding question is whether workers only need to return findings to one session, or need to coordinate with one another as independent teammates. Anthropic describes subagents as a lighter option and recommends agent teams when the task benefits from discussion and coordination.
Subagents vs. agent teams
A subagent is a focused worker with its own context and configurable instructions, tools, permissions, and model. It works within its parent session; the parent remains responsible for assigning work and synthesizing the result. A subagent is useful when a search or log review would otherwise flood the main conversation, or when a small task can be handed off with a clear output.
An agent team is a more independent arrangement. One session leads, while teammates work in their own contexts, share a task list, and message one another. The current Claude Code documentation labels agent teams experimental and disabled by default, and documents limitations such as imperfect task-status updates and session-resumption behavior. Treat it as a feature to evaluate, not a guarantee that every task can be delegated safely.
There is no useful universal rule that “N agents equals N times faster.” Parallel work helps when tasks can proceed independently. If every worker must wait for an earlier result, edits the same files, or needs extensive handoffs, coordination can erase the time saved. Anthropic explicitly warns that agent teams use significantly more tokens and recommends a single session or subagents for sequential or tightly coupled work.
Where Claude Project threads fit
The redesigned Projects beta adds a project-level coordinator that can route work to threads. Anthropic says each thread is a full Claude Code cloud session on its own branch and copy of the repository. That isolation makes separate work easier to inspect, but it does not eliminate integration: changes that overlap still have to be reconciled like other branch changes.
Do not assume every account has this experience yet. Anthropic’s help page says the new version is rolling out in stages, beginning with selected Pro and Max users of Claude Code. Existing Projects can behave differently while the rollout continues.
Projects, Claude Code, and Claude Desktop usage draw from the plan’s usage limits. The Help Center describes a five-hour session limit and weekly limits; running several Project threads at once uses the allowance faster. The exact amount depends on factors such as model, task length, context, and tools, so an agent count alone cannot predict when a limit will be reached.
What parallelism costs
There are two different “costs” to keep separate:
- Subscription usage: Claude plan usage is shared across supported Claude surfaces. Parallel sessions can use that allowance more quickly. Anthropic’s Max plan is described in multiples of Pro’s session capacity, not as a fixed number of agents or a fixed token budget.
- API charges: API usage is billed separately based on model and token use. Do not apply an API per-token price to a subscription session, and do not treat the plan price as the marginal cost of one extra agent.
Research gives a useful caution, but not a universal verdict. A 2025 empirical comparison of agent frameworks found meaningful differences in effectiveness, efficiency, and token overhead; some orchestration designs incurred longer trajectories and more correction attempts. A 2026 ESEM study of agents sharing a Git workspace reports that coordination design matters and that simply adding agents is not the same as improving collaboration. These studies evaluate particular frameworks and tasks, not Claude’s current features, so use them to shape a local test rather than predict your result.
A small test before scaling up
Before setting a high concurrency level, choose a repeatable task that resembles your real work. Compare one sequential run with a small parallel run, and record:
- Task boundaries: list which parts are independent and which files or decisions are shared.
- Elapsed time: measure from dispatch until an integrated result is ready, including review and merge fixes—not just the first agent’s response.
- Quality: run the same tests or acceptance checklist and have a reviewer assess omissions and contradictions.
- Usage: note the model, plan surface, session/weekly usage before and after, and API token totals if using the API.
- Coordination: count duplicate work, blocked dependencies, conflicting edits, retries, and corrections.
Keep the parallel setup only if it improves an outcome that matters—such as verified completion time or review quality—enough to justify the additional usage and integration work. If a task is mostly sequential, a single agent with a clear checklist is often the simpler baseline.
When to use each option
| Situation | Starting point |
|---|---|
| Summarize several independent documents | Subagents, each assigned a separate source and a fixed summary format. |
| Review security, tests, and performance independently | Subagents first; use an agent team only if reviewers need to debate or coordinate findings. |
| Implement independent components in separate branches | Project threads or manually isolated worktrees, followed by integration and tests. |
| One complex change touching shared files and dependent decisions | One lead session or a carefully staged subagent workflow. |
| Need an exact time or dollar estimate | Run a representative pilot and measure the full integrated task; product documentation cannot supply your project’s actual rate. |
Questions people ask
Does one subagent equal one separate Claude subscription session?
No. Subagents have separate context windows but work within a parent Claude Code session. Agent-team teammates and redesigned Project threads are separate Claude Code instances or cloud sessions. “Separate context” does not by itself mean a separate paid account or independent usage allowance.
Can I calculate the exact price from the number of agents?
No. Agent count does not reveal token use, model, cached context, retries, or whether you are on a subscription or API billing. For a subscription, inspect Claude’s usage page. For API work, use the actual input/output usage reported by the API and the current rate for the model used.
Will more agents always finish sooner?
No. Parallelism reduces the critical path only when enough work is independent. Shared files, dependencies, permissions, review, and merge conflicts can add time or lower quality.
Sources and scope
Product behavior checked against Anthropic documentation and Help Center on October 13, 2026. Features and plan limits can change; check the linked pages before making a purchase or setting organization policy.
- Anthropic: Create custom subagents
- Anthropic: Orchestrate teams of Claude Code sessions
- Anthropic Help Center: Usage and length limits
- Anthropic Help Center: Projects
- Anthropic: Projects redesigned
- Yin et al. (2025), “A Comprehensive Empirical Evaluation of Agent Frameworks on Code-centric Software Engineering Tasks”
- “Coordinating Agents on a Shared Git Workspace: An Empirical Study of Action-Space Observation for Agentic Software Engineering” (ESEM 2026)
Limitations: this article compares documented product behavior and summarizes research on specific agent frameworks. It does not claim to benchmark Claude Code, predict an individual account’s remaining allowance, or recommend enabling experimental features without a pilot.