TL;DR
- Claude Code documents five parallel-execution approaches: subagents, agent view, agent teams , dynamic workflows, and Projects [1]. Most teams need only two of them.
- Agent teams are experimental and disabled by default, and they add coordination overhead and token cost compared to a single session [2].
- Anthropic reports that Claude Tag, its Slack-native evolution of Claude Code, lands 65% of its product-engineering team’s internal PRs [6].
Claude Code team workflows are the next battleground for coding agents. Individual productivity was the easy win: autocomplete, refactoring, one-shot bug fixes. Coordination is the hard part: five developers running separate sessions on one repo produce merge conflicts, duplicated context, and no shared record of decisions. Claude Code ships explicit multi-user primitives that Cursor’s cited announcement does not describe, and Anthropic shares new features inside the company before wider release [6]. The thesis: the next edge comes from orchestration, not from a bigger model. What follows maps three things: the primitives that matter, a governance setup you can commit to a repo, and the approach that fits each team.
Why Claude Code Team Workflows Beat Solo Sessions
The individual coding-agent pitch is solved: anyone can open a terminal, describe a bug, and watch a model patch it. What remains unsolved is the handoff, the moment work changes hands: two engineers on one feature, a reviewer catching hidden assumptions, and a lead who needs every parallel session’s decisions. Who tracks all of that? The diagnosis: a coordination gap, not a capability gap.
Anthropic tests its own tooling internally before release: Claude Code features go to Anthropic employees and some early customers first, where the internal bar is active users and retention [6]. The team calls this “ant fooding”: it works in public through shared Slack channels [6]. One recent change, reported for the most frontier model generation only, was an 80% smaller system prompt, a shift from exhaustive negative constraints toward concise instruction [6].
Cursor chases the same problem from a different angle: Projects puts a coordinator agent in the cloud, and it delegates to subagents [7]. Claude Code documents its own multi-user machinery: agent teams, cross-session messaging, and a local-plus-cloud execution model [1][2]. One distinction drives everything below: local sessions versus a cloud coordinator.
Five Ways Claude Code Parallelizes Work
Claude Code ships five distinct ways to run work in parallel [1], and they are not interchangeable: pick the wrong one and you trade a clean multi-session workflow for a token bill with nothing merged. The diagram below sorts the five by who coordinates: Claude, you, or a script.
graph LR A[Parallel work in Claude Code] --> B[Claude coordinates] A --> C[You coordinate] A --> D[A script coordinates] B --> B1[Subagents
inside one session] B --> B2[Agent teams
lead plus workers] B --> B3[Projects
cloud threads] C --> C1[Agent view
background sessions] D --> D1[Dynamic workflows
subagent chains]
| Primitive | What it does | Best for |
|---|---|---|
| Subagents | Delegated workers inside one session with independent context | Splitting a single task into parallel research or edits |
| Agent view | Dispatch and monitor background sessions from one screen | Running a scan, test suite, or search while you keep working |
| Agent teams | Coordinated multi-session groups with a shared task list | Research and review that needs a lead and multiple workers |
| Dynamic workflows | Script-orchestrated chains of subagents | Work too large for turn-by-turn coordination |
| Projects | Ongoing cloud conversation where parallel threads each receive the project’s instructions | Long-running work that keeps running when your machine is off |
Anthropic’s original agent guidance describes an orchestrator-workers pattern: a coordinator breaks a task down and delegates the pieces to worker LLMs [10]. Claude Code’s “agent teams” features follow that pattern, and worktrees add isolation: each parallel session gets a separate git checkout and edits its own copy of the files, and subagents can each get their own worktree [1].
Cross-session messaging is a supporting tool, not a sixth approach: Claude can list and message other Claude Code sessions on the same machine, another machine, or the cloud, and sessions you run yourself can pass findings and status between themselves [1]. A review session could hand its findings back to the session that wrote the code, but treat that as an illustration, not a documented workflow.
Calibrate by coordination cost: start with subagents and agent view, then climb only when the task demands it.
Agent Teams: When More Sessions Beat More Tokens
Warning
Agent teams are experimental and disabled by default: enabling them adds coordination overhead and token cost compared to a single session [2]. Do not reach for them until a workload genuinely needs multiple coordinated workers.
Agent teams are the primitive built for coordinated multi-session work: a lead session coordinates multiple workers, which share a task list and can message each other directly [2]. Turning them on takes one thing: an environment variable.
# Enable experimental agent teams for coordinated multi-session work
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude
Two display modes exist: in-process on one screen, or split panes in tmux or iTerm2 [2]. The lead assigns work, and teammates message each other directly instead of routing everything through the lead, which is the difference that separates a team from a simple fan-out of workers. Peer-to-peer matters: a research sprint often justifies the extra machinery, while a routine refactor rarely does.
Cost is the catch: each teammate is a separate Claude instance, and token cost is higher than a single session [2]. Reserve teams for research and review workflows, where parallel exploration improves the result: a routine refactor rarely needs that, and one good session is usually the cheaper path.
Shared Context for a Claude Code Team That Persists
Parallel sessions are only as good as the context they share. Claude Code layers persistent instructions through “CLAUDE.md”, which loads at the start of every session, and a .claude/rules/ directory for path-specific scoped rules [3]. One more option: “AGENTS.md ” works as an interoperable alternative for teams that also use other coding tools [3].
Auto memory is a different layer: it lets Claude write notes from your corrections and carry them across sessions up to 200 lines or 25KB, stored under ~/.claude/projects//memory/, and it is machine-local, not shared across machines [3]. It is per developer, so it cannot carry a team convention: the shared layer is a committed CLAUDE.md that reaches the team through version control [3]. The docs describe that sharing only for CLAUDE.md, so confirm the same for rules and skills before relying on it.
Instructions are one boundary, and tooling is another: the Model Context Protocol , or “MCP”, is an open-source standard for connecting AI applications to external systems such as local files and databases [9]. One possible effect: a team may rely less on markdown files for shared context. Code intelligence plugins let Claude jump straight to a definition instead of reading through many files, which the docs recommend if you work in a typed language [5].
Guardrails and Governance at Team Scale
More sessions mean more chances for a destructive edit to slip through, so Claude Code’s answer is deterministic: nothing is left to model judgment. Hooks enforce rules that admit no exceptions: “PreToolUse” hooks block actions before they run, “Stop” hooks prevent ending a turn until checks pass, and “PostToolUse” hooks run after edits [5].
A second layer: a classifier in auto mode blocks high-risk actions such as production deploys and force pushes, and new terminal sessions start in auto mode by default [5]. The model proposes, and policy decides: hooks and the classifier carry the rule.
The best-practices page shows the formatter rule as a PostToolUse hook: it runs after every Edit or Write and calls npx prettier –write –ignore-unknown on the edited file [5]. The snippet below is a shortened version of that hook, committed to the repo so every session inherits it.
{
"hooks": {
"PostToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "npx prettier --write --ignore-unknown \"$(jq -r '.tool_input.file_path')\""
}
]
}
]
}
}
Who owns it? The page states that .claude/settings.json and the hooks in it belong to the repo: once you commit them, they apply to everyone who works in the repo [5]. The same page gives the migrations rule as a PreToolUse hook that exits with code 2 for any path under migrations/ [5], and it offers no worked example of a whole team’s governance setup, so the rest of the layout is yours to design. Rules in .claude/rules/ load every session or when matching files are opened [3].
Slack-Native Collaboration with Claude Tag
Not every team lives in a terminal: for Slack-centric teams, “Claude Tag” brings Claude directly into Slack channels, and access is admin-governed with limited availability, Team and Enterprise plans on Anthropic’s first-party service [4]. It is “multiplayer by default”, supporting proactive routines such as monitoring bug reports and opening PRs, and the Claude Code team describes it as “the evolution of Claude Code” [4][6].
The shift moves coordination out of individual sessions: a Slack channel becomes the shared task list, so anyone in the channel can watch a fix land or a review resolve. That visibility is the real change, because a teammate no longer has to ask which session is working on which problem, or wait for someone to paste a status update into a thread that everyone else must then read to catch up. It only pays off if the team already works in Slack, and threads then do the rest. Otherwise, Projects and cross-session messaging stay closer to home, because a team that lives in the terminal gains little from moving its coordination into a chat channel it rarely opens.
Claude Code Team Workflows vs. Cursor Projects
The two products diverge sharply once you look past autocomplete, and the table below is the functional comparison: the numbers after it come from the vendors themselves, not from independent measurement.
| Tool | Team coordination approach | Deployment model | Governance layer |
|---|---|---|---|
| Claude Code | Agent teams, cross-session messaging, Claude Tag in Slack [1][4] | Local sessions plus cloud Projects [1] | Hooks and auto mode [5] |
| Cursor Projects | Coordinator agent delegating to cloud subagents [7] | Cloud-by-default [7] | Not covered in cited announcement |
Cursor reports two figures, both self-reported: new “Projects” users merge 30% more PRs, and users who primarily use “Projects” merge six times as many [7], which are big numbers. One design-system Project is on track to touch 20 to 100 PRs a day, a number Cursor presents as a projection, not current throughput [7]. Cursor’s Agent SDK lets teams define agents in code with built-in evals: PGA Tour uses it as their software development factory [8].
Which approach fits which team? It depends on your bottleneck: Cursor describes Projects as cloud by default [7], which suits a cloud-first team that wants delegation without local setup. A team that owns its own policy and works in the terminal may prefer Claude Code’s hooks and committed CLAUDE.md, while a Slack-centric team has a third route: start with Claude Tag. That recommendation is our judgment, not a finding of any cited page.
Note
Read the benchmarks with their provenance in mind: the evidence here is vendor-originated. The 65% figure is self-reported by Anthropic’s Claude Code team, and the 30% and six-times figures come from Cursor’s product announcement. Each vendor is measuring its own tool, and no independent team-adoption study was found, so none of these figures has outside confirmation.
Practical Takeaways
- Start with CLAUDE.md and skills before touching any experimental feature: a committed CLAUDE.md is shared through version control [3], and auto memory stays on one machine.
- Use subagents and agent view for everyday parallel work: reserve agent teams for research and review, where their overhead is justified.
- Enable agent teams only with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1: measure the token cost against a single session before standardizing.
- Commit hooks in .claude/settings.json before you scale past a handful of engineers: one policy then applies to every session by construction.
- Adopt Claude Tag if your team already lives in Slack: keep Cursor Projects in the comparison when the problem is cloud-native delegation.
Conclusion
The single-developer phase is behind us, and coordination is the new bottleneck. What matters is not which vendor you choose, but whether parallel work gets deliberate design decisions. Climb cheapest first: committed instructions and hooks, then subagents and review loops day to day, then parallel groups only where the task genuinely splits. Measure one real repository before promoting any pattern to a standard, and revisit this ladder each quarter as vendors ship fast.
Frequently Asked Questions
Should I enable agent teams for my team?
Not by default: agent teams are experimental, off by default, and add coordination overhead and token cost over a single session [2].
What is the difference between subagents and agent teams?
Subagents are delegated workers inside a single session with independent context, whereas agent teams are multiple coordinated sessions that share a task list and can message each other directly [2]. The practical difference is coordination topology: teams are built for peer-to-peer communication between workers, which adds token cost. If your task does not need that lateral coordination, subagents are the cheaper call. Start there, and move to a team only when workers genuinely need to challenge or build on each other’s findings.
How do I keep context consistent across a team of Claude Code users?
CLAUDE.md and .claude/rules/ load at the start of every session or when matching files are opened, while skills load only when invoked or relevant [3]. Only CLAUDE.md is documented as shared through version control, so confirm rules and skills sharing against the current docs before relying on it. Auto memory is per developer: it persists corrections up to 200 lines or 25KB, but it is machine-local and not shared across machines [3].
What governance controls does Claude Code offer for organizations?
PreToolUse, Stop, and PostToolUse hooks enforce deterministic rules, and auto mode blocks high-risk actions such as production deploys and force pushes [5].
Does Claude Code run only on my machine?
No. Cross-session messaging reaches sessions on the same machine, another machine, or the cloud [1].
Sources
| # | Publisher | Title | URL | Date | Type |
|---|---|---|---|---|---|
| 1 | Anthropic | “Run agents in parallel — Claude Code Docs” | https://docs.anthropic.com/en/docs/claude-code/agents | 2026 | Documentation |
| 2 | Anthropic | “Orchestrate teams of Claude Code sessions — Claude Code Docs” | https://code.claude.com/docs/en/agent-teams | 2026 | Documentation |
| 3 | Anthropic | “How Claude remembers your project — Claude Code Docs” | https://docs.anthropic.com/en/docs/claude-code/memory | 2026 | Documentation |
| 4 | Anthropic | “Work with Claude Tag — Claude.ai Documentation” | https://docs.anthropic.com/en/docs/claude-code/claude-tag | 2026 | Documentation |
| 5 | Anthropic | “Best practices for Claude Code — Claude Code Docs” | https://code.claude.com/docs/en/best-practices | 2026 | Documentation |
| 6 | Simon Willison | “A Fireside Chat with Cat and Thariq from the Claude Code team” | https://simonwillison.net/2026/Jul/21/cat-and-thariq/ | 2026-07-21 | Blog |
| 7 | Cursor | “Introducing Projects” | https://www.cursor.com/blog/projects | 2026-09-10 | Blog |
| 8 | Cursor | “Introducing the Agent SDK” | https://www.cursor.com/blog/agent-sdk | 2026-10-20 | Blog |
| 9 | Model Context Protocol | “What is the Model Context Protocol (MCP)?” | https://modelcontextprotocol.io/introduction | 2026 | Documentation |
| 10 | Anthropic | “Building effective AI agents” | https://www.anthropic.com/engineering/building-effective-agents | 2024-12-19 | Blog |
Image Credits
- Cover photo: Image generated with gemini-3-pro-image (Agents’ Codex AI illustration)
