The Sub-Agents You Did Not Know You Were Already Using in Claude Cowork

Those Parallel Workers Were Not a Glitch

If you have given Claude Cowork a heavy task and watched several workers appear in the progress view at the same time, you saw a real, intended feature — not a bug and not a fluke. Anthropic's own documentation lists sub-agent coordination as a core capability of Cowork: when work is complex, Claude breaks it into smaller tasks and runs parallel workstreams to complete them. On a substantial task, the interface makes this visible — you can watch multiple sub-agents executing at once, each handling its own slice. The reason this design exists is not just speed. When Claude splits a job across sub-agents, each one works over a narrower part of the problem with its own fresh context window. That compartmentalization keeps the pieces from interfering with each other, reduces accidental scope creep, and makes it far clearer what each workstream actually changed. So the parallel execution you noticed is the system working exactly as designed: decomposing something large into independent parts, running them side by side, and merging the results into the finished files delivered to your folder.

Fully Automatic — You Do Not Configure Anything

The single most important thing to understand about Cowork's sub-agents is that they are entirely Claude's decision. You never name a sub-agent, never assign one a task, never configure how many run or what each does. Claude evaluates the job on its own and, when it detects that the work contains independent pieces, it spins up parallel workers to match. The examples are easy to picture: instead of reading twenty files one after another, Claude might create five sub-agents that each process four files at once; or, on a research task, one sub-agent investigates a company while another pulls data from a connected source and a third scans for relevant context. Each runs in parallel or in sequence as appropriate, and critically, each carries its own focus and its own fresh context window. This is what separates it from a single agent grinding through everything in one crowded context: the work is distributed the way a small team would distribute it, but with zero setup on your part. The trade-off baked into that convenience is that you get the benefit without any of the controls — which is fine for the vast majority of tasks, and becomes a limitation only when you specifically want to dictate the structure yourself.

Not New — Just Newly Visible to You

It is natural to assume that because you only just noticed parallel sub-agents, the feature must have just launched. That is almost certainly not what happened. Sub-agent coordination has been part of how Cowork works since it became broadly available; what changed is what you fed it. Cowork only reached general availability on macOS and Windows through the Claude Desktop app in April 2026, with full feature parity to the version that launched earlier in the year. For most people, the first weeks of using it involve lighter tasks — a file cleanup here, a quick document there — none heavy enough to make Claude decide that fanning out is worth it. The moment you finally hand it something substantial — a multi-file synthesis, a large research cross-reference, a real reorganization job — is the moment the parallel machinery kicks in and becomes visible. So seeing several sub-agents at once is not evidence of a new feature; it is evidence that your usage has matured into the kind of work the feature was built for. Worth remembering: Cowork requires the desktop app kept open during a task, runs only on paid plans, and the more it parallelizes, the more tokens it consumes — heavier tasks simply cost more.

Where Cowork Ends and Manual Multi-Agent Control Begins

Cowork's automatic sub-agents are ideal precisely because they ask nothing of you — but that same automation is also their ceiling. In the Cowork interface, you cannot name a specific agent, you cannot give each agent its own tools or its own system prompt, and you cannot design by hand how the agents run concurrently. You get the coordination, but not the controls. When you genuinely need that level of control, you step over to the developer side, which is a separate capability and not exposed in the Cowork UI at all. There, through Managed Agents and multi-agent sessions on the Claude API — and related developer surfaces like Claude Code's sub-agents, Agent Teams with a shared task list, and dynamic workflows — you can define named specialist agents, each as a file with its own system prompt and permitted tool list, and run them concurrently by deliberate design. This is the path for anyone who wants to take a repeatable pipeline they currently run as a series of one-off calls — a content production workflow, for instance, where research, drafting, and formatting happen as separate steps — and formalize it into a single coordinated multi-agent system. The rule of thumb is simple: use Cowork's automatic sub-agents for the everyday heavy lifting where you just want the result, and reach for the developer-side tools only when the structure of the coordination is something you need to own and repeat.

Prompt

# CLAUDE COWORK SUB-AGENTS — WHAT IS HAPPENING & HOW TO USE IT
# Cowork = Claude Desktop app (macOS / Windows), paid plans only
# Switch the Cowork tab to Tasks, describe the job, let it run.

# ─── WHAT SUB-AGENT COORDINATION IS ───
# A documented CORE capability of Cowork. When a task is complex, Claude:
#   1. Analyzes the request and creates a plan
#   2. Breaks the work into subtasks
#   3. Spins up multiple sub-agents that run in PARALLEL
#   4. Each sub-agent gets its own focus + its own fresh context window
#   5. Merges the outputs and delivers finished files to your folder
# You SEE them running at once in the progress view on heavy tasks.

# ─── KEY FACT: IT IS FULLY AUTOMATIC ───
# Claude decides on its own when to fan out into sub-agents.
# You do NOT name them, assign them, or configure them.
# Example fan-outs Claude may choose:
#   - 5 sub-agents each processing 4 files (instead of 1 reading 20 in series)
#   - one researching a company, one pulling data, one scanning for context
# Why it matters: separate context windows = compartmentalized work,
#   less scope creep, and a clearer "what changed" per workstream.

# ─── HOW TO TRIGGER IT (give it heavy, decomposable work) ───
"Go through every file in /client-feedback, group the complaints into themes,
 pull 3 quotes per theme, and write a prioritized summary to feedback.md."

"Read the 6 PDFs in /research, cross-reference their findings, flag every
 contradiction, and build one combined brief with a sources table."

"Organize my /Downloads: categorize by type, propose folders, flag anything
 older than 30 days. Show me the plan before changing anything."
# Tip: add "show me the plan first" — Cowork has real write access to files.

# ─── WHERE COWORK'S CONTROL ENDS ───
# Cowork sub-agents: automatic, invisible to configure — benefit, no controls.
# You CANNOT (in the Cowork UI):
#   - name specific agents
#   - give each its own tools or system prompt
#   - design the concurrency by hand
# For that level of control, you move to the DEVELOPER side:

# ─── MANUAL MULTI-AGENT (developer-side, NOT in Cowork) ───
# Managed Agents / multi-agent sessions on the Claude API:
#   - define named specialist agents (each a markdown file + YAML frontmatter:
#     name, description, system prompt, permitted tools)
#   - run them concurrently by design
#   - formalize a repeatable pipeline (e.g. a content workflow) into a
#     coordinated multi-agent system instead of sequential one-off calls
# Related developer surfaces: Claude Code sub-agents, Agent Teams (shared
#   task list), and dynamic workflows (ultracode) — all give explicit control.

# ─── WHEN PARALLEL HELPS — AND WHEN IT DOES NOT ───
# Helps: many independent files/sources, distinct domains, large synthesis jobs
# Does not: short single-file tasks, tightly sequential steps (step 2 needs step 1)
# Note: parallel sub-agents multiply token usage — heavier tasks cost more.