Claude Code agents: 5 ways to work in parallel and 3 prompts to copy

The documentation defines a subagent as a delegated agent inside your session that runs a side task in its own context and returns a summary. Use one when a task would flood the main conversation with search results, logs or file contents you will never read again. A subagent is not first about going faster: it is about keeping the conversation clean.

Like a skill, a subagent is a Markdown file: a header with the name, the description (the one Claude compares with your request to decide whether to delegate), the allowed tools and the model; then the body, the subagent’s instructions. It lives in the project (.claude/agents folder), on your machine, in a plugin, or it is deployed by the organization. It starts with a fresh context: it sees neither your history nor the files already read, Claude writes it a message that summarizes the task. The exception is the fork, a subagent that inherits the whole conversation. Either way, only the final result comes back.

At Adygital, our training plugin contains seven subagents written this way: a source checker, a deliverable reviewer, a commercial challenger, and the others. House rule: the agent that checks does not fix. The reviewer and the checker are not allowed to write.

A subagent works inside one session. Agent view is the floor above: several full Claude Code sessions running in the background, and one screen to see them all, grouped into three families: those that need you, those that are working, those that are done. The loop takes four moves: open agent view, type a task (each task starts its own session), peek at a row to read its latest output or answer its question, and attach when you want the full conversation.

A reassuring detail when you manage a repository: before editing a single file, a background session moves into its own worktree, an isolated working copy, and later pushes its work to a branch, never to the main branch. Two limits stated by the documentation itself: agent view is a research preview, and every session uses your quota like an interactive one.

Here one session acts as team lead: it splits the work, assigns tasks and synthesizes results. Teammates are each a full session with their own context window; they share a task list, message each other directly through a mailbox, and you can talk to any of them without going through the lead. The documentation compares: a subagent reports to whoever launched it; a teammate coordinates with the others, shares findings and challenges them. Cost follows, each teammate being a full session of its own.

When is it worth it? When parallel exploration adds real value: a review from several angles, competing hypotheses for a bug, one module per teammate. The documentation’s guardrails: experimental and off by default; three to five teammates; no worktree isolation, so each must own its own files; permission prompts bubble up to the lead. At Adygital we keep teams for research. For an SME’s daily work, a well-scoped, verified subagent does better, for far less.

With subagents, skills and teams, Claude decides turn by turn, and every result lands in a context window. With a workflow, the script decides: Claude writes it for the task you describe, a runtime executes it in the background, intermediate results live in its variables, and your conversation only receives the final answer. Scale changes too: dozens to hundreds of agents per run.

What creates the value: independent agents can challenge each other’s conclusions before they are reported to you. A result that survived a contradiction is worth more than a single pass. The script is a procedure written in black and white: you can read it, rerun it (finished agents return their saved result) and save it as a command. The limits are written down: sixteen concurrent agents by default, a thousand per run. And advice we follow to the letter: run the workflow on a small sample first to judge the cost.

The documentation gives three questions. Who coordinates the work? Your conversation, delegating: subagents. You, with independent tasks you check back on later: agent view. A lead session and its teammates: agent teams. A script: workflows. Do the agents need to talk to each other? Then cross-session messaging. Do they touch the same files? Then worktrees.

A worktree is a separate working copy of the same repository, with its own branch: what one session edits there never touches another’s files. You can request it for a subagent with one line in its file (isolation: worktree), and Claude Code enforces isolation with four checks that block any edit, command or git redirection aimed at the main checkout. Cross-session messaging lets one session write to another, on the same machine or elsewhere. A message is text one session writes to another, never the sender’s history or files; it cannot approve anything on your behalf, changes neither permissions nor configuration, and a command inside it stays text.

This is how the video itself was produced: a main conversation writes the script and keeps control of the words; it delegates everything that produces volume (documentation captures, crops, test renders, checks) to subagents, each coming back with a report of a few lines. Our rules fit in four lines: volume goes to subagents, writing stays in the conversation; the agent that checks does not fix; an agent that edits files works in its own copy, nothing merges without our approval; every extra agent multiplies tokens, so start with a sample.

Run it in a project where deliverables go out to clients. Claude writes the subagent file, with a description that triggers at the right moment and tools limited to reading. The prompt, to copy as is:

Create a project subagent in .claude/agents/ named reviewer. Its role: reread a deliverable before it goes to a client, check that figures are consistent from one page to the next, that every promise is kept later in the document, and that no sentence stays vague. It is read-only and changes nothing. It returns a list of defects ranked by severity, with the sentence concerned. Write its description in the third person, with the words I would use to ask for it.

Run it on a report, a proposal or a study that puts forward figures. The workflow assigns one agent per claim, then a second agent that has not seen the first and tries to refute it; the sample of the first two pages lets you judge the cost before going on. The prompt:

Use a workflow to verify every numerical claim in this document. One agent per claim looks for the exact source. Then a second agent, which has not seen the first, tries to refute each conclusion. Keep only what survives, and list the rest as unverified rather than false. Do it on the first two pages first so that I can judge the cost.

The one we use most. Three independent tasks go to three subagents, each in its own worktree, and only a synthesis comes back to the conversation; merging stays a human decision. Replace the brackets with your tasks. The prompt:

These three tasks are independent: [task A], [task B], [task C]. Run them in parallel in separate subagents, each in its own worktree so that they never touch the same files. Report back only each one’s summary: what is done, what remains, what blocked you. You merge nothing without my approval.

Anthropic, Run agents in parallel: https://code.claude.com/docs/en/agents. Create custom subagents: https://code.claude.com/docs/en/sub-agents. Manage multiple agents with agent view: https://code.claude.com/docs/en/agent-view. Orchestrate teams of Claude Code sessions: https://code.claude.com/docs/en/agent-teams.

Orchestrate subagents at scale with dynamic workflows: https://code.claude.com/docs/en/workflows. Run parallel sessions with worktrees: https://code.claude.com/docs/en/worktrees. Message your other Claude Code sessions: https://code.claude.com/docs/en/cross-session-messaging. Every claim in this guide can be found in one of these pages; the examples and house rules come from Adygital practice.