home / skills / vudovn / antigravity-kit / parallel-agents

parallel-agents skill

needs review

This skill coordinates multiple specialized agents to perform comprehensive, multi-domain analysis and implementation tasks within Antigravity.

npx playbooks add skill vudovn/antigravity-kit --skill parallel-agents

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

5.2 KB

---
name: parallel-agents
description: Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise or when comprehensive analysis requires multiple perspectives.
allowed-tools: Read, Glob, Grep
---

# Native Parallel Agents

> Orchestration through Antigravity's built-in Agent Tool

## Overview

This skill enables coordinating multiple specialized agents through Antigravity's native agent system. Unlike external scripts, this approach keeps all orchestration within Antigravity's control.

## 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" |
| `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" |
| `api-designer` | API Design | "REST", "GraphQL", "OpenAPI" |
| `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", "roadmap", "milestones" |
| `seo-specialist` | SEO | "SEO", "meta tags", "search ranking" |
| `game-developer` | Game Development | "game", "Unity", "Godot", "Phaser" |

---

## Antigravity Built-in Agents

These work alongside custom agents:

| Agent | Model | Purpose |
|-------|-------|---------|
| **Explore** | Haiku | Fast read-only codebase search |
| **Plan** | Sonnet | Research during plan mode |
| **General-purpose** | Sonnet | 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** - 17 specialized agents can be orchestrated
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** - Always include test-engineer for code modifications

---

## Key Benefits

- ✅ **Single session** - All agents share context
- ✅ **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

Overview

This skill coordinates multiple specialized agents to run in parallel or sequence for multi-domain tasks. It keeps orchestration native to the system so agents share context in a single session. Use it to combine discovery, domain analysis, testing, and synthesis into one cohesive workflow.

How this skill works

You invoke built-in or custom agents by trigger phrases or explicit agent IDs, then define an orchestration pattern (parallel, sequential, or context-passing). The explorer agent can map the codebase, domain agents perform focused analyses, and a final synthesis step consolidates findings into prioritized recommendations and action items. Sessions can be resumed and context passed from one agent to the next to maintain continuity.

When to use it

When a task needs expertise from multiple domains (security, backend, frontend, testing).
For comprehensive reviews: architecture, security, performance, and test coverage.
When implementing features that touch several layers (API, UI, database).
When you need a unified, prioritized remediation plan from multiple perspectives.
For coordinated penetration testing followed by remediation planning.

Best practices

Start with an explorer or discovery agent to map scope before invoking specialists.
Follow a logical order: discovery → analysis → implementation → testing → synthesis.
Pass relevant findings as context to downstream agents to avoid duplication and drift.
Use a single synthesis step to produce a unified report with prioritized action items.
Include a test-engineer whenever code changes are proposed to verify fixes and add coverage.

Example use cases

Comprehensive codebase audit: explorer-agent → security-auditor → performance-optimizer → synthesis.
Feature rollout review: identify affected domains, run backend-specialist and frontend-specialist in parallel, then have test-engineer validate.
Security program: security-auditor → penetration-tester → synthesis with prioritized fixes and remediation steps.
Database migration: explorer-agent maps schema, database-architect plans migrations, devops-engineer prepares CI/CD deployment, synthesis documents steps.
Bug triage: debugger analyzes failing areas while backend and frontend specialists propose fixes; test-engineer confirms resolution.

FAQ

Can agents run truly in parallel?

Agents can be orchestrated to run independently and share context within the same session; actual concurrency depends on the platform, but results are combined in synthesis.

How do I get a single consolidated report?

Use the synthesis protocol: collect agent outputs, consolidate findings into categories (critical/important/nice-to-have), and list action items with ownership and priority.