Parallel Agents Engine

Orchestrate multiple specialized AI agents through Claude Code's native agent system for comprehensive, multi-perspective analysis and implementation tasks.

When to Use

Use agent orchestration when:

• Complex tasks span multiple expertise domains (security + performance + testing)
• You need comprehensive reviews from different perspectives
• Feature implementation touches backend, frontend, and database layers
• Large codebases need systematic exploration before changes

Skip orchestration when:

• The task is simple and single-domain
• A quick fix or small change is needed
• One agent or direct work suffices

Quick Start

Single Agent Invocation

Use the security-auditor agent to review authentication flows

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.

Parallel Invocation

In parallel:
- Use security-auditor to check authentication
- Use performance-optimizer to profile API endpoints
- Use test-engineer to assess coverage

Context Passing

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

Core Concepts

Orchestration Patterns

Comprehensive Analysis:

explorer-agent → [domain agents in parallel] → synthesis

1. explorer-agent: Map codebase structure
2. In parallel: security-auditor, backend-specialist, frontend-specialist
3. test-engineer: Verify findings
4. Synthesize all results into prioritized recommendations

Feature Review:

1. Identify affected domains
2. Invoke relevant domain agents (only those needed)
3. test-engineer validates changes
4. Consolidated report

Security Audit:

security-auditor → penetration-tester → synthesis

1. security-auditor: Config and code review
2. penetration-tester: Active vulnerability testing
3. Prioritized remediation plan

Available Specialized Agents

Agent	Domain	Use For
orchestrator	Coordination	Multi-perspective analysis
security-auditor	Security	Auth, vulnerabilities, config
penetration-tester	Security testing	Active exploit testing
backend-specialist	Backend	APIs, Node.js, Express
frontend-specialist	Frontend	React, UI, components
test-engineer	Testing	Coverage, TDD, test generation
devops-engineer	DevOps	CI/CD, deployment, infrastructure
database-architect	Database	Schema, migrations, Prisma
api-designer	API design	REST, GraphQL, OpenAPI
debugger	Debugging	Error investigation, root cause
explorer-agent	Discovery	Project structure mapping
documentation-writer	Docs	README, API docs, guides
performance-optimizer	Performance	Profiling, optimization

Built-in Claude Code Agents

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

Synthesis Protocol

After all agents complete, produce a unified report:

Copy
## Orchestration Synthesis

### Task Summary
[What was accomplished across all agents]

### Agent Contributions
| Agent | Key Finding |
|-------|-------------|
| security-auditor | Found SQL injection in /api/users |
| backend-specialist | N+1 query in orders endpoint |
| test-engineer | 23% test coverage, missing auth tests |

### Prioritized Recommendations
1. **Critical**: Fix SQL injection vulnerability
2. **Important**: Add database query optimization
3. **Nice-to-have**: Increase test coverage to 80%

### Action Items
- [ ] Parameterize SQL queries in user controller
- [ ] Add eager loading for order relations
- [ ] Write auth middleware integration tests

Best Practices

1. Start with exploration — use explorer-agent first to map the codebase before invoking domain specialists
2. Parallelize independent agents — security and performance reviews can run simultaneously
3. Share context between agents — pass findings from earlier agents to inform later ones
4. Always include test-engineer for code modifications to verify changes
5. Produce a single synthesis — one unified report beats separate outputs
6. Use the right scope — don't orchestrate 5 agents for a single-file bug fix

Common Issues

Agent overlap in findings: Deduplicate during synthesis. If security-auditor and backend-specialist both flag the same issue, consolidate under the higher-severity classification.

Context loss between agents: Explicitly pass key findings from one agent to the next. Use "Based on the security audit findings, the test-engineer should focus on..." style prompts.

Over-orchestration: Not every task needs multiple agents. If the task is clear and scoped to one domain, use a single agent directly.