# Skill: Assemble and run a parallel team of specialized AI agents for a single task

> Use this skill when a task has clearly separable dimensions (security + design + copy, or frontend + backend + QA) that benefit from simultaneous deep focus -- instead of one agent switching roles and going shallow on each.

Source: sodigi-learn -- vibecoding/komanda-agentov - https://sodigi.io/learn/vibecoding/komanda-agentov

## When to use
- A pre-launch review needs independent coverage of security, SEO, and UX simultaneously.
- One agent asked to "check everything" keeps producing shallow, generalist output.
- The task is large enough that sequential single-agent work would take too long or miss domain-specific issues.
- You want multiple perspectives and especially want to see where agents disagree.

## Core rules
- An agent team is division of labor, not "more AI = smarter." Each agent gets one narrow role.
- Maximum 5 agents per team. More agents = more cost, more noise, less signal.
- Agents run in parallel and do NOT communicate with each other during execution.
- Each agent's role is a plain-text persona file: who they are, what they check, what they must deliver.
- Build the team around the task -- pick only roles the current task actually needs.
- Each agent must own a distinct, non-overlapping scope. Two agents editing the same file will overwrite each other.
- The final step is always a synthesis: who agreed, where they conflicted, and what to do next. Without synthesis there is work but no result.
- The most valuable part of the summary is disagreements -- that is where real decisions live.

## Procedure
1. Identify 2-5 distinct dimensions of the task that benefit from independent expertise.
2. Define one short persona per agent: role name, what they focus on, what they deliver.
3. Give all agents the same task description plus their individual role constraint.
4. Launch them in parallel (in the same prompt or as parallel sub-agent invocations).
5. Collect individual reports.
6. Synthesize: list agreements (high confidence items), list conflicts (items requiring a decision), list next steps.

## Ready-to-use prompt
```
Assemble a team of [2-3] agents for this task: [describe the task].

Roles:
- [Agent 1 name]: focus on [narrow area], deliver [specific output format].
- [Agent 2 name]: focus on [narrow area], deliver [specific output format].

Rules:
1. Run both agents in parallel, each working independently in its own role.
2. [Agent 1] checks [specific things] and returns [ranked list / report].
3. [Agent 2] checks [specific things] and returns [ranked list / report].
4. After both finish, write a single synthesis:
   - Where the conclusions overlap (high confidence)
   - Where they disagree (decision needed)
   - What to do first
5. Do not add more agents -- only these roles are needed.
```

## Pitfalls
- Building a larger team thinking more agents means better results -- 10 agents produce noise, not insight.
- Giving every agent the vague role "do everything" -- that is just five identical interns duplicating each other.
- Calling in roles the task does not need -- a designer on a security audit burns tokens for nothing.
- Letting two agents work on the same file -- they will overwrite each other's edits.
- Skipping the synthesis step -- three separate reports with no merge is three problems instead of one solution.
- Expecting agents to coordinate with each other -- they run in parallel and are unaware of each other; you merge the result.