Skip to content
Skills Library
Programming · Research

efficient-multi-agent-research

/efficient-multi-agent-research

Use when investigating, auditing, or reviewing more than 6 items across a codebase - function call sites, pattern usage, file reviews, or any research task with partitionable items that would pollute the main agent's context if read directly" # source: claude-plugin/skills/efficient-multi-agent-research/SKILL.md # generated-by: scripts/sync-skills.sh

Repository
thrum ↗
Licence
MIT
Last repository change
23.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when investigating, auditing, or reviewing more than 6 items across a codebase - function call sites, pattern usage, file reviews, or any research task with partitionable items that would pollute the main agent's context if read directly" # source: claude-plugin/skills/efficient-multi-agent-research/SKILL.md # generated-by: scripts/sync-skills.sh

Triggers from the description

s context if read directly
Original author description

Use when investigating, auditing, or reviewing more than 6 items across a codebase - function call sites, pattern usage, file reviews, or any research task with partitionable items that would pollute the main agent's context if read directly" # source: claude-plugin/skills/efficient-multi-agent-research/SKILL.md # generated-by: scripts/sync-skills.sh

How it works

  1. Efficient Multi-Agent Research
Original SKILL.md headings · 142 lines, 729 words
SKILL.md preview
---
name: efficient-multi-agent-research
description:
  "Use when investigating, auditing, or reviewing more than 6 items across a
  codebase - function call sites, pattern usage, file reviews, or any research
  task with partitionable items that would pollute the main agent's context if
  read directly"
# source: claude-plugin/skills/efficient-multi-agent-research/SKILL.md
# generated-by: scripts/sync-skills.sh
---

## Efficient Multi-Agent Research

### Overview

When investigating N items (N > 6), reading everything into the main agent's
context pollutes it and degrades decision-making. Instead, partition the work
across parallel sub-agents that write findings to disk, then consolidate into a
single report.

**Core principle:** The coordinator decides, sub-agents investigate. Keep
investigation results out of the main context until consolidated.

**REQUIRED BACKGROUND:** You MUST understand
superpowers:dispatching-parallel-agents before using this skill. That skill
covers general parallel dispatch. This skill extends it with a specific research
workflow: partition, investigate to disk, consolidate, then decide.

### When to Use

**Use when:**

- Investigating many call sites of a function (N > 6)
- Auditing usage of a pattern across a codebase
- Reviewing multiple files for a common issue
- Any research task with partitionable items

**Don't use when:**

- Simple searches (just use Grep/Glob)
- Tasks with 6 or fewer items (single agent is fine)
- Deeply interdependent items that can't be partitioned cleanly

### Core Pattern

#### Partition > Parallel Investigate > Consolidate > Decide

1. **Create output directory:** `mkdir -p dev-docs/<topic>/` — if re-running,
   archive previous `findings_*.md` to a subdirectory (e.g., `run-01/`) before
   starting so the consolidation glob only picks up current results.

2. **Launch investigation agents** — all in one message, all
   `run_in_background=true`:

   ```text
   Agent(run_in_background=true,
     prompt="Investigate items A-D. Write to dev-docs/<topic>/findings_1.md
     using table schema: [columns]. Flag uncertainties.")

   Agent(run_in_background=true,
     prompt="Investigate items E-H. Write to dev-docs/<topic>/findings_2.md ...")
   ```

   Specify exact table columns and consistent formatting in every prompt.

3. **Wait** for all background agents to complete.

4. **Launch consolidation agent** — always request these four elements:

   ```text
   Agent(prompt="Read all dev-docs/<topic>/findings_*.md.
     Create consolidated_report.md with:
     1. Unified table merging all agent tables
     2. Cross-cutting patterns across findings
     3. Summary statistics (e.g., '12/17 need fixes')
     4. Prioritized recommendations")
   ```

5. **Review only `consolidated_report.md`** — never read individual findings
   files into the main context.

### Quick Reference

| Aspect        | Guidance                                                  |
| ------------- | --------------------------------------------------------- |
| Group size    | 4-5 items per agent                                       |
| Agent count   | Typically 3-5                                             |
| Agent mode    | Always `run_in_background=true`                           |
| Output        | `dev-docs/<topic>/findings_N.md` per agent                |
| Consolidation | Always a dedicated agent writing `consolidated_report.md` |

### Model Selection

Research dispatches almost always want `sonnet` (sometimes `haiku` for pure
mechanical gather-and-tabulate work). Opus is rarely justified for research —
the investigation prompts are narrow and the output is tabular, so frontier
reasoning buys nothing.

Every `Agent` dispatch must pass `model` explicitly; never let sub-agents
inherit the parent (often Opus) by default. See
`~/.claude/CLAUDE.md § Sub-Agent Model Selection` for the full tier table and
decision rule.

### Common Mistakes

**Skipping consolidation** - Reading 4 separate findings files into main context
defeats the entire purpose. Always launch a consolidation agent.

**Groups too large** - More than 5 items per agent gives diminishing returns.
Partition further.

**Using foreground agents** - Blocks the main agent and loses parallelism.
Always use `run_in_background=true`.

**Reading intermediate files** - The main agent should only read the
consolidated report, never individual findings files.

**Not specifying output format** - Agents produce inconsistent formats that are
hard to consolidate. Specify table columns in every prompt.

**Not specifying output file paths** - Agents may write to the working directory
or not at all. Always include the exact output path in every prompt.

### Example: Auditing 17 Call Sites

**Task:** Investigate 17 call sites of `resolveLocalAgentID()`

**Partition:** 4 agents (4-5 call sites each, grouped by source file)

**Table schema specified in every prompt:**

| Line | Command | How ID Is Used | Behavior for 0/1/multiple | Needs Fix? |
| ---- | ------- | -------------- | ------------------------- | ---------- |

**Result:** Main context stayed clean. Consolidation agent identified
cross-cutting pattern: "8/17 calls use identity for message filtering." Final
report provided prioritized recommendations.

### Variations

| Variant       | When                                   | How                                                                       |
| ------------- | -------------------------------------- | ------------------------------------------------------------------------- |
| **Quick**     | Items are independent, output is small | Lightweight consolidation: brief merged summary instead of full synthesis |
| **Deep**      | Very large N (50+)                     | Multi-level: 8 agents > 2 meta-agents > 1 final report                    |
| **Iterative** | Need to refine criteria                | Run first pass, update prompts based on patterns, re-run                  |

### See Also

- `adversarial-critique` — decision-shaped sister pattern. Use this skill when
  investigating _what's there_ across N>6 items; use `adversarial-critique` when
  deciding _which option wins_ among 2-3 design forks.
Files in this package (2)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · leonletto/thrum100MIT
leonletto/thrum100MIT

Database snapshot: 13.11.2026 · package version f80b6a37f95d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100researcher-investigating
    Use when investigating, exploring code, working on a research task, when asked to find me X, or to investigate Y. Loads researcher-specific discipline for running an investigation cleanly." # source: claude-plugin/skills/researcher-investigating/SKILL.md # generated-by: scripts/sync-skills.sh
  • 100kastell-research
    Read-only Kastell codebase exploration. Use when tracing a bug across files, mapping callsites before refactoring, or exploring unfamiliar subsystems. Runs in isolated context with Explore agent.
  • 100design-pattern-implementation
    Reviews how design patterns are used or misused across the codebase and where patterns would help. Use when evaluating architecture, pattern fit, or over-engineering.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.