deep-research-team
This skill should be used when the user asks for "deep research", "research team", "comprehensive analysis", "research report", "investigate thoroughly", "compare X vs Y in depth", or needs synthesis across multiple sources with verification.
Install / Use
npx skills add malob/nix-config --skill deep-research-teamInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Education & ResearchSupported Platforms
Tags
Our assessment of deep-research-team
deep-research-team scores 91/100 on our quality scale, 144th of 423 Education & Research skills we index (top 35%).
Its SKILL.md is 23 KB long, well organised into 31 sections with 13 code examples: a thorough specification that gives an agent plenty to work with.
It has 464 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so deep-research-team is actively maintained.
- Our last check on 2026-10-29 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-05. Automated pattern scan on 2026-10-05. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
deep-research-team compared with similar skills
All 4 of these similar skills score higher than deep-research-team; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| deep-research-team (this skill)by malob | 91 | 464 | 59d ago | SKILL.md |
| last30days-skillby mvanhorn | 100 | 69.2k | today | CLAUDE.md |
| algorithmic-artby anthropics | 100 | 177.9k | 56d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 56d ago | SKILL.md |
| prospectingby coreyhaines31 | 100 | 60.1k | 6d ago | SKILL.md |
Frequently asked questions
- How do I install deep-research-team?
- Run
npx skills add malob/nix-config --skill deep-research-team. The install tabs above show the steps for each supported agent. - Which AI agents does deep-research-team work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is deep-research-team safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is deep-research-team still maintained?
- The repository was last updated about 2 months ago, so deep-research-team is actively maintained.
Skill content
View source on GitHubname: deep-research-team description: > This skill should be used when the user asks for "deep research", "research team", "comprehensive analysis", "research report", "investigate thoroughly", "compare X vs Y in depth", or needs synthesis across multiple sources with verification. It spawns a coordinated team of researcher agents across multiple rounds, with the lead triaging findings and creating targeted follow-up tasks. Scales from Focused (2 researchers, 1-2 rounds) to Comprehensive (4 researchers, 3-4 rounds with cross-verification). Do NOT use for simple lookups, debugging, or questions answerable with 1-2 searches.
Deep Research Team (Lead Orchestrator)
Conduct thorough, iterative research by coordinating a persistent team of researcher agents across multiple rounds. This architecture enables mid-investigation steering, targeted follow-up based on emerging findings, and cross-agent verification.
Architecture Overview
Round 1: Investigation Round 2: Follow-up Synthesis
┌──────────┐ ┌──────────┐ ┌────────┐
│Researcher│ sends findings │Researcher│ sends findings │ │
│ A ├─────────┬───────>│ A ├─────────┬───────>│ │
└──────────┘ │ └──────────┘ │ │ │
│ │ │ │
v dispatches v │ │
┌──────────┐ ┌────────┐ ┌──────────┐ ┌────────┐ │ Lead │
│Researcher├───>│ Lead │───>│Researcher├───>│ Lead │───>│ synth │
│ B │ │triages │ │ B │ │triages │ │ esizes│
└──────────┘ └────────┘ └──────────┘ └────────┘ │ │
^ ^ │ │
┌──────────┐ │ ┌──────────┐ │ │ │
│Researcher├─────────┴───────>│Researcher├─────────┴───────>│ │
│ C │ sends findings │ C │ sends findings │ │
└──────────┘ └──────────┘ └────────┘
Key principles:
-
No peer-to-peer researcher communication. All coordination goes through the lead. This preserves the independence that accounts for 87% of multi-agent gains (Choi et al.) and avoids sycophancy failures (Wynn et al.). Researchers never see each other's findings.
-
Multi-round iteration. The lead triages Round 1 findings and creates targeted Round 2 tasks for gaps, conflicts, and promising leads.
-
Cross-agent verification (Comprehensive scope). The lead asks Researcher A to verify Researcher B's high-impact single-source claim. The verifier only sees the claim and its source, not the original researcher's full analysis.
-
Dynamic task evolution. The shared task list starts with pre-planned angles but grows organically as follow-up tasks emerge from findings. The lead dispatches follow-up tasks directly to specific researchers via SendMessage.
When to Use
Use this skill for:
- Complex questions that benefit from multiple research angles
- Topics where initial findings will reveal what to investigate next
- Research requiring cross-verification of contested claims
- Any question needing synthesis across 5+ sources
Do NOT use for:
- Simple factual lookups (use regular web search)
- Questions answerable with 1-2 searches
- Debugging or code questions
Effort Calibration
| Scope | Researchers | Rounds | Verification | Model | | ----------------- | ----------- | ------ | ------------ | ------ | | Focused | 2 | 1-2 | None | sonnet | | Broad | 3 | 2-3 | None | sonnet | | Comprehensive | 4 | 3-4 | Cross-agent | opus |
Round counts are heuristics, not targets. Stop early when you hit citation convergence -- additional rounds that don't surface new substantive findings waste tokens and context. A Broad run that converges in 2 rounds is a success, not a shortcut. After each round's triage, ask: "Would another round change the report's conclusions?" If not, proceed to synthesis.
Default scope is determined by question type (see references/question-types.md).
Present the recommended scope to the user and allow override.
Model selection:
- Lead: inherits user's session model (no override)
- Researchers:
sonnetfor Focused/Broad,opusfor Comprehensive
(Sonnet validated as viable override for Comprehensive when cost matters)
Output Directory
Research artifacts persist to disk for resumability and backup.
Directory resolution -- run this command FIRST, before creating anything. The output is
your {output_dir}. Only the fallback branch creates a directory; the others reuse what exists.
if [ -d "$(pwd)/deep-research" ]; then
echo "$(pwd)/deep-research"
elif [ -n "$CLAUDE_DEEP_RESEARCH_DIR" ]; then
eval echo "$CLAUDE_DEEP_RESEARCH_DIR"
else
mkdir -p "$(pwd)/deep-research"
echo "$(pwd)/deep-research"
fi
After resolving {output_dir}, create only the topic subdirectory in Phase 3.
Each session creates a subdirectory: {output_dir}/{topic-slug}/
Contents:
state.md-- triage checkpoint, cross-references, follow-up plan (written in Phase 4)researcher-{letter}-findings.md-- backup of each researcher's findingsreport.md-- final synthesized report (written in Phase 6)
Calibrated Confidence Language
Use Kent-style verbal probability expressions in all confidence assessments:
| Term | Range | Use When | | -------------- | ------ | ----------------------------------------- | | Almost certain | 93-99% | Multiple high-quality sources, no dissent | | Highly likely | 80-92% | Strong evidence, minor caveats | | Likely | 63-79% | Good evidence, some gaps | | Roughly even | 40-62% | Conflicting evidence, genuinely uncertain | | Unlikely | 20-39% | Limited or weak evidence |
Always pair the verbal term with the probability range in the final report.
Process
Phase 0: Classify Question Type
Silently classify the user's question before any interaction.
- Read
references/question-types.mdfor the full taxonomy. - Assign a primary type: Factual, Scientific/Health, Consumer, Technical, Opinion/Sentiment, Contested, or Emerging/Frontier.
- For compound questions, decompose into sub-questions and classify each.
- Note the default scope from the type-to-scope mapping.
Resume check: Before starting, list the subdirectories in {output_dir} and scan for any
that look related to the current question (similar topic, overlapping keywords). If you find
a plausible match, read its state.md and offer to resume: present what was completed, what
remains, and ask the user whether to resume or start fresh. If resuming, create a new team
and tasks for only the remaining work.
Topic slug: When creating a new session, generate a slug (lowercase, hyphenated, max 40
chars) for the subdirectory name: {output_dir}/{slug}/.
Classification is internal—do not present it to the user.
Phase 1: Clarify and Plan
Step 1: Make sure you understand the question. Before planning anything, ask yourself:
do I understand what the user is asking and why well enough to design research angles that
will actually be useful to them? If not, use AskUserQuestion to fill the gaps. This isn't
just about ambiguous wording -- a perfectly clear question can still lack enough context to
research well ("How does Nix handle dependencies?" means very different research depending on
whether you're evaluating Nix, debugging an issue, or writing docs). If the question and its
context are clear, skip this step.
Step 2: Scope and decompose. Determine the appropriate scope (Phase 2 has the details) and decompose the question into independent research angles. Default angle counts by scope:
- Focused: 2 angles
- Broad: 3 angles
- Comprehensive: 4 angles
These are defaults, not caps. If the decomposition reveals one more genuinely independent facet than the default, add it (e.g., 3 angles for a Focused run). If the question has fewer real facets, use fewer. Beyond ±1 from the default, re-scope rather than stretching -- the scope was probably wrong. Each angle must be independent and substantial enough to warrant a dedicated researcher; "I can think of another angle" isn't sufficient.
For compound questions, map sub-questions to angles. Multiple sub-questions can share an angle if closely related; a single sub-question can span multiple angles if it has distinct facets.
Step 3: Confirm if high-investment. For compound, contested, or Comprehensive-scope questions, present the research plan for user approval before spawning researchers:
Research plan for "{question}":
- Type: {type} | Scope: {scope} | {N} researchers, {M} rounds
- Angles: {list of planned angles}
- [If compound] Sub-question → angle mapping: ...
Proceed, or adjust?
For clear, low-scope questions, skip confirmation and proceed.
Phase 2: Calibrate Effort
Select the scope tier based on question type defaults from references/question-types.md,
then apply the scope modifiers from that file (de-escalation and escalation signals).
Also adjust for:
- User's explicit preference (if stated)
- Structural complexity (compound questions with 3+ sub-types escalate)
Announce the plan: "Starting {scope} team research with {N} researchers."
Phase 3: Team Setup
Step 1: Create the output directory
mkdir -p {output_dir}/{topic-slug}
Step 2: Create the team
TeamCreate:
team_name: "deep-research-{topic-slug}"
description: "Researching {topic} in {scope} scope"
Step 3: Create initial tasks
One TaskCreate per research angle:
TaskCreate:
subject: "Investigate {angle title}"
description: |
Research angle: {angle description}
Topic context: {brief topic summary}
Question type: {type from Phase 0}
Focus: {what specifically to investigate}
Return structured findings via SendMessage to the lead.
activeForm: "Investigating {angle title}"
Task brief clarity: Make scope boundaries explicit between researchers to avoid overlap and gaps. Flag name ambiguities (e.g., multiple products sharing a name). Mark optional sub-tasks clearly (e.g., "if time permits" vs required).
Step 4: Spawn researchers
Launch ALL researchers in a SINGLE message. Each researcher gets:
Task:
subagent_type: "general-purpose"
name: "researcher-{letter}"
team_name: "deep-research-{topic-slug}"
model: "sonnet" (or "opus" for Comprehensive)
description: "Spawn researcher {letter}"
prompt: |
You are a research agent on a team. Your job is to investigate research tasks
by searching the web, evaluating sources, and reporting structured findings.
FIRST: Read your methodology at: {absolute path to references/researcher-prompt.md}
Question type: {type from Phase 0}
Output directory: {output_dir}/{topic-slug}
Your researcher letter: {letter} (use LOWERCASE in filenames: researcher-{lowercase letter})
Lead name: team-lead (send all findings to this name via SendMessage)
Your assigned task is #{id}: "{subject}"
Use TaskGet for full details, then begin investigation.
After completing your task, go idle. The lead will message you directly
when new tasks are available.
Include the task ID, subject, question type, output directory, researcher letter, and lead name directly in each researcher's spawn prompt.
Phase 4: Investigation Loop
This is the core research cycle. Each iteration is a round: researchers investigate, the lead triages, then either dispatches follow-ups (another round) or exits to synthesis.
Round structure
Investigate: Researchers work on their assigned tasks. E
Truncated for display — read the full file on GitHub.
Related Skills
last30days-skill
69.2kAI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
prospecting
60.1kWhen the user wants to find and qualify prospects for outbound, or asks who to target first, which signal to prioritize, or where to spot buyers with the problem: buying signals, enrichment, verification, account research.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
