How to use the Parallel Agent Dispatch agent skill (dispatching-parallel-agents)

What does the skill make the AI do?

Agent skills are folders of instructions that an AI assistant loads when a request matches them. This skill covers one pattern: splitting independent work across sub-agents. A sub-agent is a separate agent with its own isolated context. The source says sub-agents should not inherit your session history, so the brief you write must contain everything they need.

The core rule is to dispatch one agent per independent problem domain and let them work concurrently. The skill also covers how to write each brief, and how to review the results afterwards.

• Identify independent problem domains, for example failures grouped by test file or subsystem.
• Give each sub-agent a clear scope, a clear goal, constraints such as not modifying other code, and a stated output format.
• Dispatch the sub-agents in parallel.
• When they return, read each summary, check for conflicts, run the full test suite, and spot-check for systematic mistakes.

Install the skill (ZIP download or Claude apps)

Download the ZIP file from this page. The skill package contains a single file, SKILL.md. There are two ways to install it, depending on how you use Claude.

For a personal setup, unzip the folder into ~/.claude/skills/. To limit it to one project, unzip it into that project's .claude/skills/ folder. In the Claude apps, you can instead upload the skill under Settings → Capabilities → Skills.

• Personal: ~/.claude/skills/ (available across your projects).
• Project only: .claude/skills/ inside the project folder.
• Claude apps: Settings → Capabilities → Skills, then upload.

How do you trigger it with a natural request?

You do not need a special command. The skill's description tells the assistant to use it when there are two or more independent tasks with no shared state or sequential dependency. Describe your situation plainly and mention that the tasks are separate.

Be specific about the separate pieces of work. Naming the files or subsystems helps the assistant see that the problems are independent.

• "I have three test files failing for different reasons after the refactor. Can you handle them in parallel with separate agents?"
• "These five unrelated bugs are in the billing, search and export modules. Split them across sub-agents so they run at the same time."
• "Use parallel agents for the failing tests in tool-approval and abort, but keep the auth tests out of it."

Worked example: a batch of failing tests after a refactor

The source gives a real case. After a large refactor, six tests failed across three files. The failures had different causes: a timing problem, an event-structure bug, and a missing wait for asynchronous tool execution. The causes were independent, so the work was split into three agents.

Each agent received a focused brief. The source shows the pattern as a markdown brief that lists the failing tests, explains the likely cause type, and asks for a root-cause summary. It also says not to just raise timeouts. Each agent returned a summary, the fixes did not conflict, and the full suite passed.

• Agent 1: fix agent-tool-abort.test.ts (replaced a timeout with an event-based wait).
• Agent 2: fix batch-completion-behavior.test.ts (fixed an event structure bug).
• Agent 3: fix tool-approval-race-conditions.test.ts (added a wait for async tool execution).

How to write a good sub-agent brief

A good brief is focused, self-contained and has a clear output requirement. The skill's common mistakes list shows the fixes: name a specific file rather than "all tests", paste the error messages and test names rather than saying "fix the race condition", set explicit constraints such as "only fix the tests", and ask for a summary of root cause and changes rather than "fix it".

• Focused: one clear problem domain, such as one test file.
• Self-contained: include the error text, test names and the context needed to understand the problem.
• Constrained: for example "do not modify production code" or "only fix the tests".
• Explicit output: ask for the root cause and what was changed.

Check the results before you merge

Parallel work still needs review. The skill asks you to read each summary, check whether any two agents edited the same code, run the complete test suite to confirm the fixes work together, and spot-check for systematic errors an agent might have made.

• Read every summary and understand what changed.
• Check for conflicts: did two agents edit the same code?
• Run the full test suite.
• Spot-check the changes for mistakes that could repeat across agents.

When not to use it

The skill is explicit about when parallel dispatch is wrong. If failures are related, one fix may solve the others, so investigate them together. If you do not yet know what is broken, use normal debugging first. Agents that edit the same files or use the same resources can interfere with each other, so do not run them in parallel in that case.

• Related failures that may share one root cause.
• Exploratory debugging where you do not yet know what is broken.
• Tasks that need understanding of the whole system.
• Tasks where agents would edit the same files or shared resources.