agent-swarm-deployer — Claude Code skill: features and setup
agent-swarm-deployer deploys parallel sub-agent swarms for heavy data jobs like bulk document summarization, dataset processing, and multi-record content generation.
MIT 247 installs ★ 440 updated 2026-10-20
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a claude-codeWhat agent-swarm-deployer does
The skill coordinates parallel sub-agents to process independent data units like documents, dataset rows, or catalog items. It focuses strictly on data processing tasks rather than code modifications—the author recommends agent-army for editing project codebases. It relies on standard tools including Read, Write, Bash, Agent, Glob, and Grep.
Before launching work, the deployer checks a small sample of records to evaluate structure and estimate token counts. It caps each execution wave at 20 sub-agents, running them through the Agent tool with run_in_background: true. Larger task queues get split into successive waves to stay within context limits.
Outputs return as structured JSON, which the coordinator validates, deduplicates, and aggregates. If individual items fail, a retry agent runs up to two additional attempts before flagging items as unrecoverable. Final results export to CSV, JSON, Markdown, or separate files.
What it helps with
- process thousands of text documents or rows in parallel
- extract structured data across large file batches into JSON or CSV
- generate bulk text content across hundreds of records
- re-run failed data tasks automatically with a two-attempt retry limit
Example prompts for the agent
- Deploy a swarm to score leads from leads.csv and export results to JSON
- Process all reports in the docs/ folder in parallel and write a combined summary
- Run sub-agents across dataset items to generate descriptions and export as Markdown
How to install agent-swarm-deployer
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a claude-code2Manually: put the files in place
~/.claude/skills/agent-swarm-deployer/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/agent-swarm-deployer/
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a codex2Manually: put the files in place
.agents/skills/agent-swarm-deployer/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a cursor2Manually: put the files in place
.cursor/skills/agent-swarm-deployer/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install OneWave-AI/claude-skills agent-swarm-deployer2Manually: put the files in place
.github/skills/agent-swarm-deployer/SKILL.md1Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a gemini-cli2Platform CLI
gemini skills install https://github.com/OneWave-AI/claude-skills --path agent-swarm-deployerManually: put the files in place
.devin/skills/agent-swarm-deployer/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about agent-swarm-deployer
How do I install agent-swarm-deployer in Claude Code?
Run npx skills add OneWave-AI/claude-skills --skill agent-swarm-deployer -a claude-code in your terminal.
How does agent-swarm-deployer differ from agent-army?
This skill processes bulk data, records, and files. For source code changes and repository refactoring, use agent-army instead.
How many parallel agents run at once?
Execution is capped at 20 sub-agents per wave, dispatched simultaneously via the Agent tool using background execution.
Source text
SKILL.md · MIT
--- name: agent-swarm-deployer description: Deploys swarms of sub-agents for massive parallel data processing tasks. Unlike agent-army (which is for code changes), this is for DATA tasks -- processing 1000 documents, analyzing datasets, bulk content generation. Configurable swarm size, task distribution, result aggregation, progress tracking, and error recovery. tools: Read, Write, Bash, Agent, Glob, Grep user_invocable: true --- # Agent Swarm Deployer Deploy a swarm of parallel sub-agents to process massive, independent data tasks (documents, records, rows, items) and aggregate the results. Use this for data operations; use agent-army for code changes. ## Contents - `references/overview.md` -- swarm vs army comparison, use cases, architecture diagram - `references/swarm-design.md` -- input/output schemas, batch-size and swarm-size formulas, scaling guidelines - `references/agent-brief.md` -- agent brief template, data distribution methods, progress tracking - `references/aggregation-recovery.md` -- merge logic, completeness validation, retry strategy, error-handling table - `references/output-formats.md` -- CSV/JSON/Markdown/individual-file outputs, final summary report - `references/task-configs.md` -- ready-made configs for sentiment, lead scoring, content generation, summarization ## Workflow 1. Understand the task. Pin down five things before deploying anything: data source, operation per item, output format, output destination, and quality/validation requirements. If any is ambiguous, ask the user first -- a wrong spec wastes all agent compute. 2. Intake and inventory. Glob/Bash to locate and count items. Read 3-5 samples to learn structure. Estimate tokens per item and total. Report an intake summary (source, total count, item format, sample structure, token estimate). 3. Detect input schema and define output schema. Derive the input schema from samples; define the exact output schema the task requires. See `references/swarm-design.md`. 4. Design the swarm. Compute batch size from token budget (70% of ~200K usable context per agent) and swarm size from total items. Cap at 20 agents per wave; split into waves beyond that. Present the swarm plan and agent assignments, then get approval. See `references/swarm-design.md`. 5. Prepare agent briefs. Build a self-contained brief per agent: role, task, input data, output schema with example, quality rules, error protocol, and strict JSON output format. See `references/agent-brief.md`. 6. Distribute data and deploy. Choose a distribution method for the source type (pre-split CSVs/JSON with Bash; embed inline for small sets; pass file paths for directories). Launch up to 20 agents in parallel via the Agent tool with `run_in_background: true`, sending all calls in one message. Run later waves after the prior wave completes. See `references/agent-brief.md`. 7. Track progress. As agents return, record status, processed counts, and cumulative coverage. See `references/agent-brief.md`. 8. Collect and aggregate. Parse each agent's JSON; validate schema, completeness, and duplicates. Merge into one ordered output and extract failures. Report an aggregation summary with a coverage check and failure analysis. See `references/aggregation-recovery.md`. 9. Recover failures. Queue all failed and skipped items, deploy a retry agent with enhanced instructions, cap at 2 retries, and mark survivors "unrecoverable". Flag the user if unrecoverable items exceed 10%. See `references/aggregation-recovery.md`. 10. Write output and summarize. Produce the requested format (CSV, JSON, Markdown, or individual files) plus a final summary covering execution, results, quality metrics, patterns observed, and cost. See `references/output-formats.md`. ## Anti-Patterns to Avoid 1. Do not use a swarm for sequential tasks. If item N depends on item N-1, use a chain instead. 2. Do not deploy one agent per item. Batch items; one-per-agent wastes overhead. 3. Do not skip schema definition. Without a schema, merging results from many agents becomes unreliable. 4. Do not ignore failures. At 99% success, 1% of 10,000 items is still 100 failures. Always run retries. 5. Do not deploy without a sample run. Process 5 items manually first to validate the task and output quality before scaling.
© OneWave-AI · MIT · OneWave-AI/claude-skills