Sub-Agents in Claude Code

What sub-agents actually are

Most operators run Claude Code the way they run a single junior analyst: one task at a time, one thread of work, waiting for each step to finish before the next one starts. That's fine for simple tasks. But parallel work is where the real time savings appear, and most operators never touch it.

Sub-agents are Claude's built-in way to work on multiple tasks simultaneously. When you ask Claude to spin up sub-agents, it launches independent workers inside your session. Each one gets a specific task and runs it in parallel with the others. They don't wait for each other. They work at the same time.

The practical difference is time. Tasks that would run sequentially in 10 minutes can run in 3 when you parallelize them.

Claude handles all of this from a single prompt. You don't install anything. You don't configure infrastructure. You describe what you need, specify how many agents to deploy, and Claude coordinates the rest.

> When to reach for sub-agents. Research tasks and search tasks benefit most. Anything where you need to pull information from multiple places at once: competitive pricing, policy documents, market data, multi-client status checks. Execution tasks that depend on each other still need to run sequentially. Sub-agents are for work that can genuinely happen in parallel.

How to spin them up

The syntax is plain English. Tell Claude how many sub-agents you want and what each one should do.

You: Please spin up three sub-agents to do the following:
     - Agent 1: Search OpenAI for their latest model pricing
     - Agent 2: Search Anthropic for their latest model pricing
     - Agent 3: Search Google for their latest Gemini model pricing

Claude parses the instruction, launches all three, and begins working immediately. You don't wait for Agent 1 to finish before Agent 2 starts. All three run at once.

What you see in the UI. Each sub-agent appears as a task in Claude's task panel. You get a description of what it's doing, blinking gray indicators while it's working, and green confirmation when it completes. The panel gives you a live view of which agents are still running, which have finished, and what they're returning.

Once all agents complete, Claude synthesizes the results and presents them as a unified response.

You: Please spin up three sub-agents to do the following:
     - Agent 1: Research OpenAI latest model pricing
     - Agent 2: Research Anthropic latest model pricing
     - Agent 3: Research Google model pricing

[Task 1: OpenAI pricing research] ● ● ●
[Task 2: Anthropic pricing research] ● ● ●
[Task 3: Google model pricing research] ● ● ●

[Task 1: OpenAI pricing research] ✓
[Task 2: Anthropic pricing research] ✓
[Task 3: Google model pricing research] ✓

Here is the complete pricing breakdown across all three providers...

Permissions matter here. If web search isn't in your allow list, Claude will ask for permission before each external request. That's the permission system working correctly, not a bug. Add web search to your allow list once you've confirmed you're comfortable with the access scope. We cover the allow list in the permissions guide.

Token usage scales with agents. Each sub-agent runs its own thread, which means more tokens consumed per session. For most operators, the time savings outweigh the cost. But be deliberate: don't spin up five agents to do the job that two would handle cleanly.

Combining sub-agents with custom commands

Sub-agents get considerably more useful when you pair them with custom slash commands. Instead of typing the same multi-agent prompt from scratch each time, you build a reusable command once and deploy it with a single line.

Here's what that looks like in practice. Create a file called sub-agents.md inside your .claude/commands/ folder:

Please spin up sub-agents to do the following:

$ARGUMENTS

Save it. Now you have a /sub-agents command available in any Claude session.

You: /sub-agents Research OpenAI, Anthropic, and Google
     model pricing from their latest announcements

Claude reads the command file, injects your arguments where $ARGUMENTS appears, and launches the sub-agents. One line of input. The same structured behavior every time.

Why this matters for operators. You're not just saving keystrokes. You're building a repeatable workflow. Any time you need parallel research across multiple sources, you have a command ready. Add it to the CLAUDE.md for any client folder where you run this kind of competitive or market analysis regularly.

> Tip. Name your commands after the workflow, not the mechanism. /competitive-pricing-check is more useful than /sub-agents because it's self-documenting. Your future self, or a colleague picking up the workflow, knows exactly what it does.

Running multiple sessions in parallel

Sub-agents within a session are one layer of parallelization. The other layer is sessions themselves.

Nothing stops you from opening multiple terminal tabs, each running its own Claude Code session, each pointed at a different client folder. Four tabs, four sessions, each session running several sub-agents. Dozens of tasks moving at once.

This is worth knowing about, not because you'll need it on day one, but because it reframes how you think about capacity. The bottleneck in your workflow isn't Claude's processing speed. It's how clearly you can define the work and how quickly you can review the output.

The practical limit for most operators. Two or three active sessions at once is manageable. You can monitor them, review outputs in sequence, and redirect as needed. Beyond that, reviewing results becomes the bottleneck. Spinning up eight sessions and thirty sub-agents sounds powerful, but if the output sits unreviewed for an hour, you've gained nothing. Throughput is only as fast as your review cycle.

> What actually compounds. Getting comfortable with one sub-agent workflow, refining it into a reliable custom command, then deploying that command every time the situation calls for it. That's the pattern worth building. The exotic multi-session setups come later, if at all.

A practical workflow for fractional leaders

Here's how to deploy sub-agents in a real client engagement context.

Competitive landscape research. You're building a market positioning deck for a client. Instead of searching each competitor one at a time, spin up four or five sub-agents at once: one per competitor. Each agent pulls pricing, positioning language, and any recent announcements. By the time you've made a coffee, Claude has a synthesized competitive summary ready for review.

Multi-client status sweep. You're managing four active engagements and need a Monday morning briefing on each one. Create a custom command that spins up one sub-agent per client folder, each reading the latest notes and returning a status summary. Four clients in the time it would take to manually review one.

Pre-call research. Before a discovery call with a new prospect, spin up sub-agents to research the company, their recent news, and their key competitors simultaneously. Walk into the call with context that would have taken an hour to gather manually.

The mechanics are straightforward. The real shift is recognizing which tasks in your workflow are genuinely parallel, ones where the outputs don't depend on each other, and designing sub-agent prompts around those specifically.

> Start small. Pick one research workflow you run regularly. Build a custom command for it. Deploy it for two weeks. Once that's reliable, identify the next one. This is how you build an AI-assisted practice that compounds, one repeatable workflow at a time.

---

Author: FractionalSkill