| name | squall-research |
| description | Multi-agent research swarm via teams. Use when asked to 'research', 'squall research', 'investigate topic', 'deep dive on', or when broad multi-vector research is needed. Spawns parallel agents each using WebSearch + Squall review. (project) |
| one_liner | N vectors x M models -- research at the speed of parallel agents. |
| activation_triggers | ["squall research","research this","investigate topic","deep dive on","research swarm","When user wants multi-vector research on a topic","When user wants parallel investigation of a question"] |
| related_skills | ["[squall-unified-review](../squall-unified-review/SKILL.md) (for code review, not research)","[squall-deep-research](../squall-deep-research/SKILL.md) (for single-agent deep research)"] |
Squall Research
TL;DR - QUICK REFERENCE
| Concept | Translation |
|---|
| Research swarm | Team of 3-5 agents each investigating one angle of a topic |
| Vector | One independent research angle/facet of the topic |
| Fan-out | Each agent uses WebSearch + Squall review (3 models) in parallel |
| Synthesis | Team lead reads all reports and combines into coherent answer |
Entry criteria:
- User wants broad research on a topic (not code review)
- Topic has 3+ independent angles worth investigating
- Depth matters more than speed (this spawns real agents)
Multi-agent research swarm that decomposes a topic into independent vectors, assigns each to
a parallel agent, and combines their findings. Each agent amplifies its own research with
WebSearch and Squall's multi-model review tool, producing N vectors x M models worth of
perspectives.
Proven pattern from 2026-02-21: 5 agents researched ensemble methods, multi-agent debate,
LLM routing, structured output, and feedback loops -- all in parallel, all writing to disk,
all completed within minutes.
Workflow
┌─────────────────────────────────────────────────────────────────┐
│ SQUALL RESEARCH SWARM │
│ │
│ 1. DECOMPOSE Topic ──► 3-5 independent vectors │
│ │
│ 2. SPAWN TeamCreate + TaskCreate + Teammates │
│ │ │
│ ┌──────────┼──────────┐ │
│ ▼ ▼ ▼ │
│ 3. RESEARCH Agent A Agent B Agent C (parallel) │
│ │ │ │ │
│ WebSearch WebSearch WebSearch │
│ + + + │
│ Squall Squall Squall │
│ review review review │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ 4. WRITE report-a.md report-b.md report-c.md │
│ (.squall/research/) │
│ │ │ │ │
│ └──────────┼──────────┘ │
│ ▼ │
│ 5. SYNTHESIZE Team lead reads all reports │
│ │ │
│ 6. CLEANUP Shutdown teammates + TeamDelete │
│ │ │
│ 7. OUTPUT .squall/research/ directory + synthesis │
└─────────────────────────────────────────────────────────────────┘
Step 1: Decompose the Topic
Before decomposing, call memory category "patterns" to check if prior research exists on related topics. This prevents re-researching known ground and helps identify which angles are genuinely novel.
Break the research topic into 3-5 independent vectors. Each vector should be:
- Researchable on its own (no dependency on another vector's findings)
- Distinct enough that two agents won't return the same results
- Specific enough to guide WebSearch queries
Example for "How do production systems aggregate multi-model LLM output?":
- ML ensemble weighting methods (Condorcet, stacking, mixture of experts)
- Multi-agent debate protocols (academic papers, when debate helps vs hurts)
- LLM routing strategies (RouteLLM, Martian, rule-based approaches)
- Structured output schemas (JSON enforcement, provider support matrix)
- Feedback loop architectures (CodeRabbit, Copilot, SonarQube patterns)
Step 2: Create the Team
TeamCreate:
name: "squall-research-<topic-slug>"
description: "Research swarm for <topic>"
Then create one task per vector:
TaskCreate:
subject: "Research: <vector name>"
description: |
Investigate <specific angle>. Focus on:
- <key question 1>
- <key question 2>
Write findings to: .squall/research/<vector-slug>.md
activeForm: "Researching <vector name>"
Step 3: Spawn Teammates
Spawn one general-purpose agent per vector, all in parallel. Each agent's prompt must include:
- What to research (their specific vector)
- ToolSearch instructions for loading Squall MCP tools
- Exact model names for the Squall review call
- Output file path where they must write their report
Agent prompt template:
You are a research agent investigating: <VECTOR DESCRIPTION>
Your workflow:
1. TaskList to find your task, then TaskUpdate it to in_progress
2. Use WebSearch to find papers, docs, blog posts, implementations
3. Use ToolSearch with query "squall" to load Squall MCP tools
3a. Call `listmodels` to verify exact current model names
3b. Call Squall `memory` category "tactics" to get proven system prompts for the review models
4. Use the Squall `review` tool to get multi-model perspectives:
- models: ["grok", "kimi-k2.6", "glm-5.1"]
- system_prompt: "You are a research advisor specializing in <VECTOR TOPIC>.
Analyze the research findings provided and add your own knowledge.
Cite sources where possible."
- prompt: <paste your WebSearch findings as the prompt>
5. Write your complete findings to:
.squall/research/<FILENAME>.md (relative to working directory)
Format: markdown with sources cited, key findings highlighted
6. TaskUpdate your task to completed
7. SendMessage to "team-lead" with a 2-3 sentence summary
Step 4: Wait and Monitor
The team lead waits for all agents to complete. Monitor via:
- TaskList to check task statuses
- Incoming SendMessage notifications from agents
Step 5: Synthesize
Once all agents report back:
- Read all output files from
.squall/research/
- Identify themes that span multiple vectors
- Note contradictions between agents/models
- Produce a unified summary for the user
- Call
memorize with category "pattern" for key research findings worth remembering across sessions
Step 6: Cleanup
- SendMessage type: shutdown_request to each teammate
- TeamDelete the team
The .squall/research/ files persist for future reference.
Key Principles
Principle 1: Vectors Must Be Independent
If vector B depends on vector A's results, they aren't independent -- merge them or
sequence them. Independence enables parallelism, which is the whole point.
Principle 2: Teammates Have Full MCP Access
Confirmed 2026-02-21: agents spawned with general-purpose subagent_type inherit all MCP
tool access. They can use ToolSearch to discover and load Squall tools, then call review,
chat, clink, and listmodels directly.
Principle 3: Disk Is the Integration Layer
Agents write to .squall/research/. This survives context compaction, agent shutdown, and
session restarts. The team lead reads files, not message history.
Principle 4: 3 Models Is the Sweet Spot for Research
The review call uses Grok (fast, broad), Kimi (contrarian), and GLM (architectural framing).
This gives diverse perspectives without the latency cost of Gemini/Codex (which are better
for code review than research advising).
Reference Tables
Model Selection for Research Review
| Model | Strength | Speed | Use For |
|---|
grok | Fast, broad knowledge | 20-65s | Always include |
kimi-k2.6 | Contrarian, edge cases | 60-300s | Alternative perspectives |
glm-5.1 | Architectural framing | 75-93s | Big-picture structure |
Agent Count Guidelines
| Topic Breadth | Agents | Example |
|---|
| Narrow (1-2 angles) | Use /deep-research instead | "How does RouteLLM work?" |
| Medium (3 angles) | 3 | "Compare 3 specific approaches" |
| Broad (4-5 angles) | 4-5 | "Survey an entire problem space" |
| Very broad | 5 max, decompose topic first | "State of AI in 2026" |
Anti-Patterns
| Don't | Do Instead |
|---|
| Spawn more than 5 agents | Cap at 5; diminishing returns, resource heavy |
| Research overlapping vectors | Ensure each vector is clearly distinct |
| Forget to TeamDelete after | Always clean up; orphan processes waste resources |
| Skip the Squall review step | 3 model perspectives >> WebSearch alone |
| Have team lead duplicate agent work | Team lead synthesizes, agents research |
| Use Gemini/Codex for research review | Use Grok/Kimi/GLM (faster, better for advising) |
| Put all findings in messages only | Write to disk; messages don't survive compaction |
| Use this for narrow single-angle questions | Use /deep-research for single-vector depth |
| Skip memory check before decomposing topic | Call memory category "patterns" — prior research may exist on related topics |
| Finish synthesis without memorizing findings | Call memorize for reusable patterns discovered during research |
Examples
Example 1: Researching Multi-Model Aggregation Strategies
User: "squall research how production systems aggregate multi-model output"
Decomposition:
Vector 1: ML ensemble weighting (Condorcet, stacking, MoE)
Vector 2: Multi-agent debate (academic papers, effectiveness)
Vector 3: LLM routing (RouteLLM, Martian, rule-based)
Vector 4: Structured output schemas (JSON enforcement)
Vector 5: Feedback loops (CodeRabbit, Copilot patterns)
Team: "squall-research-aggregation" with 5 agents
Output: .squall/research/{ensemble-methods,multi-agent-debate,llm-routing,
structured-output,feedback-loops}.md
This was the actual first run of this pattern (2026-02-21). All 5 agents completed
successfully, producing detailed reports with cited sources and multi-model perspectives.
Example 2: Researching a Narrower Topic
User: "research the state of WebAssembly for server-side AI inference"
Decomposition:
Vector 1: WASM runtime performance for ML (wasmtime, wasmer benchmarks)
Vector 2: WASM-compatible ML frameworks (ONNX, TFLite, custom)
Vector 3: Production deployments (Fastly, Cloudflare, Fermyon case studies)
Team: "squall-research-wasm-ai" with 3 agents
Output: .squall/research/{wasm-runtimes,wasm-ml-frameworks,wasm-deployments}.md
Three vectors is enough for a focused topic. No need to force 5 agents.
Related Skills
Session Learnings Archive
Insights captured during skill execution:
2026-02-21: First Research Swarm Validation
Origin: Five-agent research swarm run on multi-model aggregation topic
Core insight: Teammates inherit MCP tool access via ToolSearch. The pattern works end-to-end: TeamCreate, parallel agents with WebSearch + Squall review, disk-based output, team lead synthesis.
Harvested -> Encoded as the core workflow in this skill
