Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

parallel-agents

/parallel-agents

Uruchamia agentów pojedynczo, po kolei lub równolegle i scala ich wyniki, gdy zadanie wymaga różnych kompetencji.

Repozytorium
cardume ↗
Licencja
MIT
Ostatnia zmiana repozytorium
04.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Uruchamia agentów pojedynczo, po kolei lub równolegle i scala ich wyniki, gdy zadanie wymaga różnych kompetencji.

Oryginalny opis (EN)

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.

Jak działa

  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
Sekcje z nagłówków SKILL.md, w oryginale · 169 linii, 701 słów
Podgląd SKILL.md
---
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
Pliki w paczce (2)
  • SKILL.md 5 KB
  • reference/orchestrator-reference.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · 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

Migawka bazy z 13.11.2026 · wersja paczki 6230e07aa581 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100orchestrate
    Rozbija złożone zadanie na śledzone podzadania, uruchamia równoległych subagentów i koordynuje ich pracę do ukończenia.
  • 100workflow-parallel-agents
    Uruchamia wielu agentów równolegle przez git worktree, agentów w chmurze lub porównanie wielu modeli, na przykład best-of-N i porównanie podejść.
  • 100run-parallel
    Uruchamia niezależne zadania równolegle przez agentów po sprawdzeniu niezależności, gdy użytkownik prosi o pracę jednocześnie.
  • 100fork-join
    Uruchamia równolegle wielu wyspecjalizowanych subagentów i łączy ich wyniki w jeden rezultat, gdy zadanie da się podzielić na niezależne równoległe części.
  • 100parallel-work
    Dzieli prośbę na niezależne zadania, wykonuje je równolegle w osobnych sesjach i scala wyniki po potwierdzeniu.
  • 100orchestrator
    Rozbija pracę na podzadania, przydziela specjalistów, uruchamia agentów równolegle i syntetyzuje wyniki, gdy nie wiadomo, którego specjalistę wywołać albo zadanie obejmuje kilka ról.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.