Skip to content
Agentmart
Submit a tool

agent-teams

Design and run Claude Code agent teams: parallel teammates with a shared task list who message and challenge each other.

Skill by nq-rdl

IndexedCC-BY-4.0
Write a review

Install

Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.

npx agentmarket install skill/nq-rdl-agent-teams

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Design and run Claude Code agent teams: parallel teammates with a shared task list who message and challenge each other. Use when the user asks for a team or teammates, wants parallel reviewers or investigators who debate findings, asks whether to use a team or subagents, or mentions teammate mode, team lead, or CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS.

Use cases: design, sales, productivity, agent-building

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this skill can do and what it asks for, from its SKILL.md. Checked Oct 25, 2026.

Tools
No tools found
Secrets
None asked for
Install scripts
None found
Runs as
Shell scripts

Network hosts it talks to 1

  • codeload.github.com · found in install command

Files it touches

  • ~/.claude/skills/agent-teams

What's inside

Skill name
agent-teams
Description
Design and run Claude Code agent teams: parallel teammates with a shared task list who message and challenge each other. Use when the user asks for a team or teammates, wants parallel reviewers or investigators who debate findings, asks whether to use a team or subagents, or mentions teammate mode, team lead, or CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS.
License
CC-BY-4.0
Compatibility
Requires Claude Code v2.1.178+ (implicit per-session team; TeamCreate and TeamDelete removed; teams first shipped in v2.1.32) with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and an interactive session. Split-pane mode requires tmux or iTerm2 with the it2 CLI. Checked against the agent-teams docs with Claude Code 2.1.284 on 2026-09-29.
Metadata
repo: https://github.com/nq-rdl/agent-extensions
Instructions
350 lines in SKILL.md · view on GitHub

Before installing

  • Ships executable scripts

Files (4)

  • SKILL.md
  • examples.rst · references/
  • subagent-vs-team.rst · references/
  • check-config.sh · scripts/

SKILL.md (first lines)

## Codex execution

This skill describes another host. Claude Code/OpenCode commands, configuration, and hook examples below are artifacts for that host, not tools available in Codex. Use Codex tools to inspect or author them; launch the target host only when the user requests execution and it is installed. Do not configure Codex as Claude Code.

Before shell examples, set PLUGIN_ROOT to the absolute installed plugin directory: two parent directories above this SKILL.md’s containing skill directory. Derive it from the loaded file path, never the working directory. This variable is not automatically supplied to ordinary shell tools. Quote it in commands.

Here $ARGUMENTS means the user’s supplied skill arguments. Codex does not populate a shell variable for them. Pass arguments with shell quoting that preserves literal text; never evaluate user text as shell code.

## User Input

```text
$ARGUMENTS
```

When the user invokes `/agent-teams`, design an agent team for their request.
If `$ARGUMENTS` is empty, ask the user what work they want to parallelize.

Follow the **Team Design Workflow** below to produce a ready-to-execute team
plan, then offer to create the team.

---

## Team Design Workflow

When designing a team, follow these steps:

1. **Understand the work** — what is the user trying to accomplish?
2. **Identify parallel lanes** — which parts can run independently?
3. **Choose team vs subagents** — see [references/subagent-vs-team.rst](references/subagent-vs-team.rst) for the decision flowchart. Only recommend a team when teammates genuinely need to communicate with each other or coordinate via shared tasks.
4. **Size the team** — start with 3-5 teammates. More than 6 is rarely justified.
5. **Define roles and ownership** — each teammate needs a clear name, responsibility, and file ownership boundaries to prevent overwrites.
6. **Set dependency order** — which teammates must share interfaces before others can proceed?
7. **Choose display mode** — `in-process` (default, one terminal) or a split-pane mode (`auto`, `tmux`, `iterm2`); see *Display modes*.
8. **Consider quality gates** — recommend `TeammateIdle`, `TaskCreated`, or `TaskCompleted` hooks where appropriate.

### Output Format

Present the team design as:

```
## Team plan: <short title>

**Goal**: <one-sentence description>

### Teammates

| # | Name | Role | Owns | Model |
|---|------|------|------|-------|
| 1 | ... | ... | ... | ... |

### Dependency Order
<which teammate feeds into which>

### Prompt
<the natural-language prompt the user should give Claude to create this team>

### Configuration
<any settings needed — env vars, display mode, permissions>
```

See [references/examples.rst](references/examples.rst) for complete team
configurations across common workflows.

---

# Agent Teams — Parallel Claude Code Coordination

## Overview

Agent teams coordinate multiple independent Claude Code instances working in
parallel. One session acts as the **team lead**, coordinating work, assigning
tasks, and synthesizing results. **Teammates** work independently, each in its
own context window, and communicate directly with each other.

This is fundamentally different from subagents. Read
[references/subagent-vs-team.rst](references/subagent-vs-team.rst) for the full
comparison — it matters because choosing the wrong one wastes tokens or limits
capability.

## Prerequisites

Agent teams are **experimental and disabled by default**. Before using them:

1. Enable the feature flag
2. Verify the configuration is correct

### Enable agent teams

Add to your project or user `settings.json`:

```json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}
```

**Settings file locations** (highest precedence first, below managed settings
and CLI flags):
- Project local: `<project>/.claude/settings.local.json`
- Project: `<project>/.claude/settings.json`
- User: `~/.claude/settings.json`

### Verify or toggle configuration

Run the bundled script from the project root (it needs `jq`). It reads the
settings files in precedence order and reports the effective value; a value
in any settings file overrides a shell export:

```bash
# Check current status
bash "${CLAUDE_SKILL_DIR}/scripts/check-config.sh"

# Enable agent teams (sets the flag to "1" in user settings; add --project for .claude/settings.json)
bash "${CLAUDE_SKILL_DIR}/scripts/check-config.sh" --enable

# Disable agent teams (sets the flag to "0")
bash "${CLAUDE_SKILL_DIR}/scripts/check-config.sh" --disable

From nq-rdl/agent-extensions, CC-BY-4.0.

More from nq-rdl/agent-extensions

Signals

Stars
0
Forks
1
Open issues
15
Last commit (this folder)
Sep 29, 2026 (29 days ago)
Last release
Oct 16, 2026 (12 days ago)

From GitHub (fetched Oct 24, 2026).

Details

License
CC-BY-4.0
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

More from nq-rdl

Cite this page

agent-teams skill. Agent Mart. https://agentmart.dev/skills/nq-rdl-agent-teams (last updated 2026-10-24)