Skip to content
Skills Library
AI & agents · Automation

parallel-agents

/parallel-agents

Runs Cardume agents singly, in sequence or in parallel and merges the results. Use when subtasks need different expertise or a review needs several perspectives.

Repository
cardume ↗
Licence
MIT
Last repository change
04.11.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 04.11.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

Runs Cardume agents singly, in sequence or in parallel and merges the results. Use when subtasks need different expertise or a review needs several perspectives.

Original author description

Runs Cardume agents singly, in sequence or in parallel and merges the results. Use when subtasks need different expertise or a review needs several perspectives.

How it works

  1. Overview
  2. When to Use Orchestration
  3. Native Agent Invocation
  4. Orchestration Patterns
  5. Available Agents
  6. Claude Code Built-in Agents
  7. Synthesis Protocol
  8. Best Practices
  9. Key Benefits
Original SKILL.md headings · 169 lines, 701 words
SKILL.md preview
---
name: parallel-agents
description: "Runs Cardume agents singly, in sequence or in parallel and merges the results. Use when subtasks need different expertise or a review needs several perspectives."
allowed-tools: Read Glob Grep
---

# Native Parallel Agents

> Orchestration through Claude Code's built-in Agent tool

## Overview

This skill covers coordinating multiple specialized agents through Claude Code's native agent system. Unlike external scripts, this keeps all orchestration inside Claude Code.

## When to Use Orchestration

✅ **Good for:**
- Complex tasks requiring multiple expertise domains
- Code analysis from security, performance, and quality perspectives
- Comprehensive reviews (architecture + security + testing)
- Feature implementation needing backend + frontend + database work

❌ **Not for:**
- Simple, single-domain tasks
- Quick fixes or small changes
- Tasks where one agent suffices

---

## Native Agent Invocation

### Single Agent
```
Use the security-auditor agent to review authentication
```

### Sequential Chain
```
First, use the explorer-agent to discover project structure.
Then, use the backend-specialist to review API endpoints.
Finally, use the test-engineer to identify test gaps.
```

### With Context Passing
```
Use the frontend-specialist to analyze React components.
Based on those findings, have the test-engineer generate component tests.
```

### Resume Previous Work
```
Resume agent [agentId] and continue with additional requirements.
```

---

## Orchestration Patterns

### Pattern 1: Comprehensive Analysis
```
Agents: explorer-agent → [domain-agents] → synthesis

1. explorer-agent: Map codebase structure
2. security-auditor: Security posture
3. backend-specialist: API quality
4. frontend-specialist: UI/UX patterns
5. test-engineer: Test coverage
6. Synthesize all findings
```

### Pattern 2: Feature Review
```
Agents: affected-domain-agents → test-engineer

1. Identify affected domains (backend? frontend? both?)
2. Invoke relevant domain agents
3. test-engineer verifies changes
4. Synthesize recommendations
```

### Pattern 3: Security Audit
```
Agents: security-auditor → penetration-tester → synthesis

1. security-auditor: Configuration and code review
2. penetration-tester: Active vulnerability testing
3. Synthesize with prioritized remediation
```

---

## Available Agents

| Agent | Expertise | Trigger Phrases |
|-------|-----------|-----------------|
| `orchestrator` | Coordination | "comprehensive", "multi-perspective" |
| `security-auditor` | Security | "security", "auth", "vulnerabilities" |
| `penetration-tester` | Security Testing | "pentest", "red team", "exploit" |
| `backend-specialist` | Backend | "API", "server", "Node.js", "Express", "REST", "GraphQL" |
| `frontend-specialist` | Frontend | "React", "UI", "components", "Next.js" |
| `test-engineer` | Testing | "tests", "coverage", "TDD" |
| `devops-engineer` | DevOps | "deploy", "CI/CD", "infrastructure" |
| `database-architect` | Database | "schema", "Prisma", "migrations" |
| `mobile-developer` | Mobile | "React Native", "Flutter", "mobile" |
| `debugger` | Debugging | "bug", "error", "not working" |
| `explorer-agent` | Discovery | "explore", "map", "structure" |
| `documentation-writer` | Documentation | "write docs", "create README", "generate API docs" |
| `performance-optimizer` | Performance | "slow", "optimize", "profiling" |
| `project-planner` | Planning | "plan" for multi-domain work with no spec or PRD |
| `seo-specialist` | SEO | "SEO", "meta tags", "search ranking" |

---

## Claude Code Built-in Agents

These work alongside custom agents:

| Agent | Purpose |
|-------|---------|
| **Explore** | Fast read-only codebase search |
| **Plan** | Research during plan mode |
| **General-purpose** | Complex multi-step modifications |

Use **Explore** for quick searches, **custom agents** for domain expertise.

---

## Synthesis Protocol

After all agents complete, synthesize:

```markdown
## Orchestration Synthesis

### Task Summary
[What was accomplished]

### Agent Contributions
| Agent | Finding |
|-------|---------|
| security-auditor | Found X |
| backend-specialist | Identified Y |

### Consolidated Recommendations
1. **Critical**: [Issue from Agent A]
2. **Important**: [Issue from Agent B]
3. **Nice-to-have**: [Enhancement from Agent C]

### Action Items
- [ ] Fix critical security issue
- [ ] Refactor API endpoint
- [ ] Add missing tests
```

---

## Best Practices

1. **Available agents** - see the table above and the `intelligent-routing` skill for the full roster
2. **Logical order** - Discovery → Analysis → Implementation → Testing
3. **Share context** - Pass relevant findings to subsequent agents
4. **Single synthesis** - One unified report, not separate outputs
5. **Verify changes** - Include test-engineer for code modifications

---

## Key Benefits

- ✅ **Fresh context per agent** - Each subagent starts clean; pass it the findings it needs
- ✅ **AI-controlled** - Claude orchestrates autonomously
- ✅ **Native integration** - Works with built-in Explore, Plan agents
- ✅ **Resume support** - Can continue previous agent work
- ✅ **Context passing** - Findings flow between agents
Files in this package (2)
  • SKILL.md 5 KB
  • reference/orchestrator-reference.md 4 KB

Versions

RepositoryScoreLicence
This page · jeffersonvalente/cardume100MIT
sentimony/skills100MIT
sentimony/skills100MIT
rootcastleco/rei-skills100MIT
FrancoStino/opencode-skills-collection100MIT
davila7/claude-code-templates100MIT
sickn33/agentic-awesome-skills100MIT
khaledsaeed18/dotclaude100MIT
Viltrumlik/parallel-agents100MIT

Database snapshot: 13.11.2026 · package version 6230e07aa581 (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

  • 100orchestrate
    This skill should be used when the user asks to 'orchestrate a task', 'break down work into parallel agents', 'coordinate subtasks', 'run agents in parallel', or mentions 'multi-agent'. Decomposes complex tasks into tracked subtasks, dispatches parallel subagents, and coordinates until completion.
  • 100workflow-parallel-agents
    Run multiple agents in parallel via git worktrees, cloud agents, or multi-model comparison. Use for "run agents in parallel", "best-of-N", "compare approaches", "multi-model", "parallel worktrees".
  • 100run-parallel
    [Orbit 2.4.4 Implementation] Independent tasks with parallel agents after an independence check. Use when: «параллельно», «одновременно несколько», «разгони задачи», «несколько агентов сразу»; parallel agents, run in parallel.
  • 100fork-join
    Runs multiple specialist subagents in parallel then merges their outputs into a unified result. Use when a task can be split into independent parallel workstreams that need to be recombined.
  • 100parallel-work
    Splits a request into independent tasks, runs them in parallel worker sessions (each edit task in its own git worktree), then collects the reports and, after confirmation, commits, merges, runs the integrated check and cleans up. Use for "run these in parallel", "split these…
  • 100orchestrator
    Use when you are unsure which specialist to invoke, when a task spans multiple roles, when you want the system to plan before acting, or when you need parallel specialist agents dispatched to complete a complex task. The orchestrator breaks work into subtasks, assigns…

Feedback and reports

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