Parallel Agents

Iron Law

USE THIS WORKSPACE'S ACTUAL AGENTS — never reference placeholder agents (security-auditor, backend-specialist) that don't exist here; always dispatch from the 42 agents in .claude/agents/

Explanation: Dispatching a non-existent agent silently fails. Every agent name in this skill maps to a real .md file in .claude/agents/.

Parallel Agents Orchestration

Orchestration guide for coordinating multiple specialized agents through Claude Code's native Agent tool. Keeps all orchestration within Claude's control using the built-in Agent tool and TeamCreate.

When to Use Orchestration

Good for:

• Complex tasks requiring multiple expertise domains (security + code quality + tests)
• Comprehensive reviews (architecture + security + accessibility)
• Feature implementation needing backend + frontend + database work
• Full pre-deploy audits across all stack layers

Not for:

• Simple, single-domain tasks (use the relevant specialist agent directly)
• Quick fixes or small changes within one file
• Tasks where one agent suffices

Decision rule: If dispatching more than 1 agent, use this skill for orchestration patterns and synthesis protocol.

Workspace Agent Catalog

Load references/workspace-agent-catalog.md for full descriptions. Quick reference:

Orchestration Patterns

Load references/orchestration-patterns.md for full pattern details.

Pattern 1: Comprehensive Feature Review

For any feature touching security-sensitive code, database, or multiple services:

Step 1: code-reviewer          → overall quality gate
Step 2: [stack-specific reviewer] → framework-specific patterns
Step 3: security-reviewer      → OWASP + auth + input validation
Step 4: silent-failure-hunter  → error handling completeness
Step 5: pr-test-analyzer       → behavioral test coverage
Step 6: Synthesize all findings

Pattern 2: Pre-Deploy Audit

Before merging any significant feature branch:

Parallel:
  security-reviewer     → security findings
  [stack reviewer]      → framework correctness
  pr-test-analyzer      → test coverage gaps
Sequential:
  output-evaluator      → APPROVE / NEEDS_REVIEW / REJECT verdict

Pattern 3: Full Flutter Feature

riverpod-reviewer         → state management
flutter-security-expert   → secure storage, GDPR
accessibility-auditor     → WCAG 2.1
ui-standards-expert       → design tokens, touch targets
silent-failure-hunter     → error handling in async code

Pattern 4: Agentic AI System Review

agentic-ai-reviewer       → graph correctness, guardrails
security-reviewer         → prompt injection, input validation
rag-pipeline-reviewer     → chunking, model pinning (if RAG used)
silent-failure-hunter     → tool error handling

Synthesis Protocol

Load references/synthesis-protocol.md for the full template.

After all agents complete:

## Orchestration Synthesis

### Task Summary
[What was accomplished]

### Agent Contributions
| Agent | Key Finding |
|-------|------------|
| [agent] | [finding] |

### Consolidated Recommendations (severity-ordered)
1. **CRITICAL** — [issue] — must fix before merge
2. **HIGH** — [issue] — should fix before merge
3. **MEDIUM** — [issue] — fix in follow-up PR
4. **LOW** — [issue] — note for tech debt backlog

### Verdict
[APPROVE | NEEDS_REVIEW | BLOCK] — based on finding severity

Constraints

MUST DO

• Only dispatch agents that exist in .claude/agents/ (42 agents listed in catalog above)
• Pass explicit context to every agent — agents do NOT inherit CLAUDE.md or conversation history
• Produce a single synthesized report, not separate outputs per agent
• Include test coverage review (pr-test-analyzer) for any code-modifying orchestration

MUST NOT DO

• Dispatch agents with only "review this code" — always pass specific context and scope
• Run more agents than needed — match agent count to actual coverage gaps
• Skip synthesis — raw agent outputs are not a deliverable

Knowledge Reference

Agent orchestration, multi-agent coordination, parallel dispatch, reviewer agents, synthesis protocol, pre-deploy gate, Claude Code Agent tool, TeamCreate, context passing