parallel-agents

Dispatch parallel subagents for independent, scoped subtasks with structured briefs.

2|Updated Apr 10, 2026
One-click install
npx skills add https://github.com/t0lab/harness-kit --skill parallel-agents-t0lab
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: parallel-agents
Source: https://github.com/t0lab/harness-kit/tree/main/.agents/skills/parallel-agents
Command: npx skills add https://github.com/t0lab/harness-kit --skill parallel-agents-t0lab

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When a task naturally splits into multiple independent domains, the main conversation context can become noisy, slow, and unwieldy; this Skill provides a protocol to dispatch isolated subagents so independent work runs concurrently and returns narrowly structured results ready for integration.

Core Features & Use Cases

  • Scoped parallelization: Run 2+ isolated Claude instances, each with a single narrowly defined goal to avoid context bloat.
  • Briefing checklist: Enforce a required brief structure (one-sentence goal, necessary context, constraints, explicit output contract, and optional length cap) so subagents produce verifiable outputs.
  • Dispatch rules & safety: Batch tool calls to ensure concurrency, partition work by file/module to avoid edit conflicts, and prevent subagent recursion.
  • Use Cases: Finding call sites across modules (one agent per symbol), researching multiple libraries concurrently (one agent per library), or auditing tests across packages (one agent per package).

Quick Start

Brief three read-only subagents with one-sentence goals to find all file:line matches for the symbols X, Y, and Z and return a concise bullet list of matches.

Frequently Asked Questions about parallel-agents

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run parallel research tasks across multiple libraries without cluttering the main context?

You can dispatch parallel subagents where each agent receives a self-contained brief with a one-sentence goal, necessary context, explicit constraints, and an exact output contract. This runs isolated research concurrently and returns narrowly structured results ready for integration.

What is the best way to find call sites for different symbols across multiple modules concurrently?

Finding call sites concurrently is done by dispatching one read-only subagent per symbol. Each subagent receives a scoped brief to find all file and line matches, batch tool calls for concurrency, and return a concise bullet list of matches to prevent context bloat.

How do I brief subagents to ensure they return verifiable outputs for parallel code audits?

Briefing subagents for parallel code audits requires a one-sentence goal, necessary context, explicit constraints, an exact output contract, and an optional length cap. This strict brief structure ensures subagents produce verifiable, narrowly scoped outputs.

Can I partition a multi-module code audit so subagents work on independent files without edit conflicts?

Yes, you can partition work by file or module to avoid edit conflicts during a code audit. Dispatch rules require partitioning independent domains and batching tool calls to ensure concurrency while preventing subagent recursion.

Why does spawning subagents for concurrent research keep the main conversation context clean?

Spawning subagents keeps the main context clean because each isolated Claude instance handles a single narrowly defined goal. The structured output is returned only after the scoped subtask completes, preventing intermediate noise from flooding the main conversation.

What are the limitations of using parallel subagents for independent task delegation?

Limitations include a strict prohibition on subagent recursion, the requirement for self-contained briefs, and the need to partition work by file or module to avoid edit conflicts. Tasks must split into independent domains to achieve concurrency.