Agent Team Workflows

Universal multi-agent workflow orchestration using Claude Code Agent Teams. Use when user asks to run a team workflow, create an agent team, or coordinate parallel work across multiple teammates — for any domain (software, content, data, strategy, research, etc.).

Security Scan

The skill's workflow templates and role-based orchestration are coherent with its stated purpose, but the runtime instructions ask you to modify a user config file and to forward whole artifacts between agents (which could expose sensitive data) — these behaviors are not declared in the metadata and merit caution.

Purpose & Capability

The name/description (multi-agent workflow orchestration) matches the SKILL.md, domain presets, patterns, and prompt templates. The templates, role cards, and pipeline patterns are internally consistent and appropriate for the claimed functionality.

Instruction Scope

The SKILL.md instructs the user/agent to edit ~/.claude/settings.json to enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS and to spawn and forward complete artifacts between teammate agents (lead forwards 'full plan', paste inputs, etc.). Those instructions expand the agent's operational scope beyond just producing messages (they require modifying a user config file and relaying potentially large/sensitive inputs across agents). The skill also gives broad discretion to include full context in handoffs without explicit guidance to redact secrets or PII.

Install Mechanism

No install spec and no code files — instruction-only skill. This minimizes install-time risk (nothing is downloaded or written by an installer), but runtime instructions still ask the user/agent to change a local settings file.

Credentials

Declared requirements list no env vars or credentials, which is consistent with the skill's metadata. However, SKILL.md asks to set an experimental flag in ~/.claude/settings.json (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) — this is a configuration change not declared in the 'required config paths' metadata and should be considered a minor mismatch. No external service credentials are requested.

Persistence & Privilege

The skill does not request permanent presence (always:false) and uses platform-default autonomous invocation. The only persistence-like action is the instruction to edit the user's ~/.claude/settings.json to enable an experimental feature; that file-write is outside the skill package and requires user action, but it does increase the skill's runtime capabilities if performed.

What to consider before installing

This skill appears to implement a well-structured multi-agent workflow, but exercise caution before installing or following its instructions: 1) The runtime docs tell you to modify ~/.claude/settings.json to enable an experimental 'agent teams' flag — that change is not declared in the skill metadata. Back up your settings file before editing and only set the flag if you trust the source. 2) The templates repeatedly instruct forwarding 'full' artifacts and pasting complete inputs between agents. That can leak secrets or sensitive files (credentials, private docs, PII). Review and redact any sensitive content before handing it to the workflow. 3) There's no install/download risk, but the skill's source is unknown and the package has no homepage — prefer skills from trusted authors or inspect provenance. 4) If you intend to let the agent run autonomously, monitor its actions and limit the data you provide; consider running initial tests with benign example inputs. If you want a lower-risk option, ask for a version that explicitly warns about PII handling and does not require changing local config files.

Universal orchestration framework for 5-agent teams (1 Lead + 4 Teammates) across any domain.

Prerequisites

Agent Teams must be enabled. Add to ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Generic Roles

Teammate IDs are fixed. Their function is remapped per domain via Role Cards.

Slot	ID	Generic Function	Core Responsibility
Lead	(session)	Orchestrator	Assign tasks, relay context, quality gate, synthesize final output
Slot A	architect	Planner	Frame problem, decompose tasks, produce plan/spec/blueprint
Slot B	developer	Builder	Produce primary artifact (code, draft, dataset, model, proposal)
Slot C	tester	Validator	Check against acceptance criteria, test, evaluate correctness
Slot D	reviewer	Critic	Assess quality, risk, consistency, compliance, suggest improvements

Role Cards (Domain Remapping)

Each domain preset provides Role Cards that specialize the generic functions:

Domain	Planner	Builder	Validator	Critic
Software Dev	Architect	Developer	Tester	Code Reviewer
Content Creation	Producer	Writer	Fact-Checker	Editor
Data Analysis	Analyst Lead	Data Engineer	Statistician	Peer Reviewer
Business Strategy	Strategist	Business Analyst	Financial Modeler	Risk Advisor
Research	Research Lead	Researcher	Methodology Auditor	Peer Reviewer

Full role cards with artifact contracts → reference/domain-presets.md

Pipeline Patterns

4 canonical control-flow patterns. Domain meaning comes from Role Cards, not the pattern itself.

1. sequential — Step-by-Step Pipeline

Planner → Builder → Validator → Critic → Lead Synthesis

Use when: Work is linear and each step depends on the previous output. Examples: Feature dev, content creation, report writing.

2. parallel-merge — Parallel Exploration + Merge

Planner → (Builder ∥ Validator ∥ Critic) → Lead Merge → Validator Gate → Lead Synthesis

Use when: Multiple perspectives can work independently, then combine. Examples: Research, strategy analysis, multi-angle evaluation.

3. iterative-review — Build-Critique Loop

Planner → Builder ↔ Critic (max N rounds) → Validator → Lead Synthesis

Use when: Quality requires iteration between creator and reviewer. Examples: Content editing, design refinement, proposal drafting. Guard: Default max 2 rounds. More requires user approval.

4. fan-out-fan-in — Map-Reduce

Planner → fan-out tasks to all 4 teammates → Lead fan-in merge → Critic Gate → Lead Synthesis

Use when: Large work can be split into independent chunks processed in parallel. Examples: Multi-module features, large dataset processing, codebase audit.

Pattern deep dives with sample task graphs → reference/patterns.md

Coordination Protocol

Strict 6-step protocol, domain-agnostic.

Step 1: Confirm Scope

Before spawning any team, confirm with user:

1. Objective — specific deliverable
2. Domain — select preset or define custom Role Cards
3. Pattern — which pipeline pattern fits
4. Constraints — tools, tech stack, tone, compliance, budget
5. Inputs — source material, existing assets, context files
6. Definition of Done — checkbox acceptance criteria the user agrees to

Step 2: Build Workflow Instance Spec

Fill in the universal template:

WORKFLOW INSTANCE SPEC
─────────────────────
Objective:      [deliverable]
Pattern:        [sequential | parallel-merge | iterative-review | fan-out-fan-in]
Domain:         [preset name or "custom"]

ROLE CARDS
  Planner (architect):  [domain title] — [specific responsibility]
  Builder (developer):  [domain title] — [specific responsibility]
  Validator (tester):   [domain title] — [specific responsibility]
  Critic (reviewer):    [domain title] — [specific responsibility]

ARTIFACTS (per step)
  Step 1 → [artifact name]: [format/content description]
  Step 2 → [artifact name]: [format/content description]
  Step 3 → [artifact name]: [format/content description]
  Step 4 → [artifact name]: [format/content description]

CONSTRAINTS:    [tools, rules, limits]
INPUTS:         [files, data, references]
DEFINITION OF DONE:
  □ [criterion 1]
  □ [criterion 2]
  □ [criterion 3]

Step 3: Create Team

Create a team of 4 teammates:
- architect: [Planner role card — context and responsibility]
- developer: [Builder role card — context and responsibility]
- tester:    [Validator role card — context and responsibility]
- reviewer:  [Critic role card — context and responsibility]

Step 4: Create Tasks with Dependencies

Create tasks following the selected pattern's pipeline order. Each task MUST have:

• Clear description referencing role card
• Required input artifact (from previous step or original inputs)
• Required output artifact (format + content)
• Acceptance criteria
• Dependency on predecessor task

Step 5: Spawn Teammates with Rich Context

Each teammate MUST receive in their spawn prompt:

1. Role Card — their domain title + specific responsibilities
2. Assigned task — what to produce
3. Input artifact — output from previous step (Lead must relay this)
4. Output artifact contract — exact format and content expected
5. Constraints — domain rules, style guides, compliance
6. Handoff instruction — "Message the lead with [artifact] when done"

Universal spawn template:

Spawn a [ID] teammate with the prompt:
"You are the [Domain Title] ([Generic Function]).

YOUR TASK: [task description]

INPUT: [paste or reference previous step's output]

PRODUCE: [artifact name]
Format: [expected format]
Must include: [required sections/elements]

CONSTRAINTS:
- [rule 1]
- [rule 2]

When done, message the lead with your complete [artifact name].
If you encounter blockers, message the lead immediately."

Step 6: Coordinate Handoffs

When a teammate completes their step:

1. Lead receives output via message
2. Lead validates output against acceptance criteria
3. Lead passes artifact + relevant context to next teammate via message
4. If output is insufficient → send specific feedback, ask to revise

Step 7: Synthesize & Deliver

After all steps complete:

1. Collect all artifacts
2. Verify all Definition of Done criteria are met
3. Summarize what was done (traceability: each criterion → which step satisfied it)
4. List remaining TODOs or known issues
5. Present final deliverable to user

Lead Discipline Rules

1. Delegate only — Lead does NOT produce primary artifacts. Use delegate mode (Shift+Tab).
2. Relay all context — Teammates have no shared history. Lead MUST forward relevant artifacts between steps.
3. Direct messages — Use direct messages, not broadcast (saves 4× tokens). Broadcast only for parallel-merge sync points.
4. Right-size tasks — 5-6 tasks per teammate max. Split large work.
5. Gate high-risk actions — Require user approval for: irreversible changes, external publication, legal/compliance, high-cost operations, production deployments.
6. Wait for teammates — Never proceed or implement yourself. Wait for teammate completion before next step.

Handling Failures

Situation	Action
Teammate stuck	Message with additional context, hints, or simplified sub-task
Bad output	Send specific feedback citing acceptance criteria, ask to revise
Teammate stops	Spawn replacement with same context + summary of work already done
Conflict between teammates	Lead mediates, makes final decision, messages both with resolution
Task too large	Lead splits into subtasks, reassigns across teammates
Iterative loop exceeds max	Ask user whether to approve more rounds or finalize current state

Cost Guidelines

Pattern	Est. Cost	Worth It When
sequential	~4-5× single	Work spans 3+ artifacts/files with clear pipeline
parallel-merge	~4× single	3+ independent perspectives needed
iterative-review	~3-4× single	Quality requires creator-critic dialogue
fan-out-fan-in	~5× single	Large work divisible into independent chunks

Rule of thumb: If one agent can finish in one session, don't use a team. Teams shine when work is parallelizable or benefits from multiple specialized perspectives.

Domain Presets (Quick Reference)

Preset	Recommended Pattern	Key Artifacts
software-dev	sequential / fan-out-fan-in	Design doc, source code, test suite, review report
content-creation	iterative-review	Content brief, draft, fact-check report, final edit
data-analysis	fan-out-fan-in	Analysis plan, datasets/transforms, statistical evaluation, findings report
business-strategy	parallel-merge	Strategy framework, market analysis, financial model, risk assessment
research	parallel-merge	Research plan, literature review, methodology audit, synthesis paper

Full presets with role cards, artifacts, and worked examples → reference/domain-presets.md Ready-to-use prompt templates → reference/prompt-templates.md Pattern deep dives → reference/patterns.md