---
name: run-an-agent-team
description: "Design a small team of AI agents to tackle a complex task in parallel — who does what, how they hand off, and how to keep them coordinated — instead of one overloaded agent doing everything serially. Use when asked how do I use multiple AI agents, set up an agent team, orchestrate agents for, or run agents in parallel. Produces a decomposition of the task into agent roles, a coordination pattern (parallel vs sequential, how outputs combine), the context each agent needs (and what to keep isolated), a review/quality step, and the guardrails to keep it from going off the rails — practical multi-agent design for real tasks."
homepage: https://mohitagw15856.github.io/pm-claude-skills/skill/run-an-agent-team.html
metadata:
  {
    "openclaw": { "emoji": "🧠" }
  }
---

# Run an Agent Team

Complex tasks overwhelm a single AI agent — the context gets muddy, quality drops, and it does everything serially. A small team of specialized agents, each with a focused role and clean context, can tackle it in parallel and check each other's work. This designs that team for your task: the roles, how they coordinate and hand off, what context each needs (and what to isolate), and the guardrails — turning "one agent doing everything" into a coordinated effort.

## What This Skill Produces

- **The task decomposition** — the task broken into distinct agent roles, each with a focused responsibility (researcher, drafter, critic, integrator, etc.)
- **A coordination pattern** — whether agents run in parallel or sequence, how their outputs combine, and where the hand-offs are
- **Context design** — what each agent needs to know, and (crucially) what to keep *isolated* so one agent's context doesn't muddy another's (the key to why teams beat one agent)
- **A review/quality step** — a separate agent or pass to critique and integrate, so quality is checked, not assumed
- **Guardrails** — how to keep the team on track (clear objectives, defined outputs, a human checkpoint) and avoid runaway loops or drift
- **A right-sized recommendation** — including when a single agent is genuinely better (not everything needs a team)

## Required Inputs

Ask for these if not provided:
- **The task** — the complex thing you want a team to tackle
- **Your setup** — the AI tool/framework you're using (Claude Code sub-agents, an agent framework, or manual multi-chat)
- **The subtasks** — the natural pieces, if you can see them
- **Quality bar & stakes** — how much the output matters (drives the review rigor)
- **Constraints** — cost, time, and how much human oversight you want

## Framework: Decompose, Isolate, Coordinate, Review

1. **Check it needs a team.** Not every task does — if it's simple or highly sequential with shared context, one agent is better. Use a team when parts are genuinely parallel or benefit from distinct, isolated perspectives.
2. **Decompose into roles.** Break the task into focused responsibilities, each an agent — a researcher, a builder, a critic, an integrator — so each has one clear job.
3. **Isolate context deliberately.** The power of a team is clean, separate context per agent — decide what each needs and what to keep apart, so perspectives stay distinct and context stays sharp.
4. **Choose the coordination pattern.** Parallel (independent then combine), sequential (hand-offs), or a mix — and define exactly how outputs pass between agents and merge.
5. **Add a review pass.** A separate critic/integrator step catches errors and combines the work — don't trust unreviewed parallel output.
6. **Guardrail it.** Clear objectives, defined output formats, iteration limits, and a human checkpoint keep the team from drifting or looping.

## Output Format

### Agent team: task [x] · setup [y]

**Needs a team?** [yes — parts are parallel/benefit from isolation / no — one agent is better because Z].
**Roles**
| Agent | Responsibility | Context it needs / isolate |
|---|---|---|
| [researcher] | | |
| [builder] | | |
| [critic] | | |
| [integrator] | | |

**Coordination:** [parallel / sequential / mix] — outputs combine by [how].
**Review pass:** [critic/integrator checks & merges].
**Guardrails:** clear objectives · defined outputs · iteration limit · human checkpoint.

## Quality Checks
- [ ] Checks whether a team is actually warranted (vs one agent)
- [ ] Decomposes into focused agent roles
- [ ] Deliberately designs isolated vs shared context (the key advantage)
- [ ] Defines the coordination pattern and how outputs combine
- [ ] Includes a review/integration pass
- [ ] Adds guardrails against drift and runaway loops

## Anti-Patterns
- **Using a team** for a task one agent handles better.
- **Agents with muddy, shared context** (loses the whole advantage).
- **No review pass** — trusting unchecked parallel output.
- **Vague roles** that overlap and conflict.
- **Missing guardrails** — runaway loops or drift with no human checkpoint.

## Example Trigger Phrases
- "How do I use multiple AI agents to build this?"
- "Set up an agent team to research and write this report."
- "Orchestrate several agents for this complex task."
- "Should this be one agent or a team, and how do I structure it?"
- "Design a parallel agent workflow for this."