Skip to content
Skills Library
AI & agents · Planning

team-create

/team-create

Create a collaborative agent team with roles, personalities, and skills. Use when: user says "create team", "build a team", "新建团队", "创建团队", "组建团队", "搭建团队". Do NOT use for managing existing teams or assigning tasks to teams.

Repository
clawwork ↗
Licence
Apache-2.0
Last repository change
19.08.2026

Assessment and security

95/ 100Class: good
Format20 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 19.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Create a collaborative agent team with roles, personalities, and skills. Use when: user says "create team", "build a team", "新建团队", "创建团队", "组建团队", "搭建团队". Do NOT use for managing existing teams or assigning tasks to teams.

Triggers from the description

create teambuild a team新建团队创建团队组建团队搭建团队

Arguments

/team-create [team-name]
Original author description

Create a collaborative agent team with roles, personalities, and skills. Use when: user says "create team", "build a team", "新建团队", "创建团队", "组建团队", "搭建团队". Do NOT use for managing existing teams or assigning tasks to teams.

How it works

  1. Team Protocol
  2. Workflow
  3. Installation Flow (for consumers of this team)
  4. Rules
Original SKILL.md headings · 245 lines, 1,135 words
SKILL.md preview
---
name: team-create
description: >
  Create a collaborative agent team with roles, personalities, and skills.
  Use when: user says "create team", "build a team", "新建团队",
  "创建团队", "组建团队", "搭建团队".
  Do NOT use for managing existing teams or assigning tasks to teams.
user-invocable: true
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
  - AskUserQuestion
  - WebSearch
argument-hint: "[team-name]"
---

# Team Create

Interactive workflow for building a collaborative agent team.

A Team is an installable package — it bundles multiple OpenClaw Agents,
each with its own identity (agent.md), personality (soul.md), and skill
dependencies (skills.json), all self-contained and portable.

## Team Protocol

### Folder Structure

```
~/.agents/teams/{team-name}/
├── team.md                          # Team metadata + positioning
└── agents/
    ├── manager/                     # MANDATORY — coordinator, never does work itself
    │   ├── agent.md
    │   ├── soul.md
    │   └── skills.json              # Skill dependencies (empty for coordinator)
    ├── {agent-slug}/
    │   ├── agent.md                 # Agent identity + description
    │   ├── soul.md                  # Personality, tone, working style
    │   └── skills.json              # This agent's skill dependencies with install sources
    └── ...
```

### team.md Format

```yaml
---
name: {team-name}
description: "{one-line team purpose}"
version: "1.0.0"
agents:
  - id: manager
    name: "{Manager Display Name}"
    role: coordinator
  - id: {agent-slug}
    name: "{Display Name}"
    role: worker
---

{Markdown body: team mission, positioning, collaboration model between agents}
```

### agent.md Format

Each agent maps to an OpenClaw Agent. Defines WHO this agent is — identity
and responsibilities only. No skill references here.

```yaml
---
id: {agent-slug}
agentId: ""
name: "{Display Role Name}"
description: "{What this agent is responsible for}"
---

{Markdown body: role positioning, core responsibilities, how this agent
collaborates with other agents in the team}
```

- `id`: internal role slug within the team, defined at creation time, immutable
- `agentId`: real OpenClaw Agent ID assigned by the system, backfilled at install time, left empty at creation

### soul.md Format

Defines HOW this agent communicates and thinks — its personality.

```markdown
# {Role Name} — Soul

## Personality

{Communication style, tone, attitude.}

## Working Style

{How this agent approaches tasks, priorities, decision-making.}

## Principles

{Core beliefs that guide decisions.}
```

### Per-Agent skills.json Format

Each agent has its OWN skills.json declaring its skill dependencies with
install sources. Format mirrors `.skill-lock.json` for compatibility.

```json
{
  "version": 1,
  "skills": {
    "{skill-id}": {
      "source": "{owner/repo}",
      "sourceType": "github",
      "skillPath": "skills/{skill-id}/SKILL.md"
    }
  }
}
```

**sourceType values:**
- `"github"` — install from GitHub repo (requires `source` as `owner/repo`)
- `"cloud-hub"` — install from OpenClaw Cloud Hub (requires `source` as hub skill ID)
- `"local"` — already available locally, no installation needed

### Manager Agent (MANDATORY)

Every team MUST have a `manager` agent with these properties:

- **id**: `manager`
- **role**: `coordinator` in team.md
- **Never does work itself** — only dispatches, coordinates, and synthesizes
- **soul.md**: focuses on orchestration style, delegation principles, quality gates
- **skills.json**: typically empty (`"skills": {}`)
- The manager is the entry point when the team is invoked

## Workflow

- [ ] Step 0: Parse arguments
- [ ] Step 1: Team positioning (team.md)
- [ ] Step 2: Define agents (manager auto-created + user-defined workers)
- [ ] Step 3: Define each agent's soul
- [ ] Step 4: Assign skills (per-agent skills.json)
- [ ] Step 5: Generate and save
- [ ] Step 6: Summary

### Step 0: Parse Arguments

- [ ] If `$ARGUMENTS` contains a team name, use it; otherwise ask
- [ ] Slugify: lowercase, hyphens, no spaces (e.g., "Research Team" → `research-team`)
- [ ] Check `~/.agents/teams/{team-name}/` does not exist
- [ ] If it exists, ask: overwrite or pick a new name?

### Step 1: Team Positioning (team.md)

Ask the user:

> What kind of team do you want to create? Describe its purpose and mission.

- [ ] Draft team.md with frontmatter (name, description, version) and body
- [ ] Body: team mission, positioning, collaboration model
- [ ] The `manager` agent is always first in the agents list with `role: coordinator`
- [ ] Show draft for confirmation

### Step 2: Define Agents

The `manager` agent is auto-created. Ask the user for worker agents:

> What roles does this team need? (e.g., frontend developer, tester, PM)

For each role:

- [ ] Collect: display name + brief description
- [ ] Derive slug (e.g., "Frontend Developer" → `frontend-dev`)
- [ ] Confirm the complete agent list (manager + workers)

### Step 3: Define Each Agent's Soul (soul.md)

For each agent (including manager):

- [ ] Manager soul: orchestration style, delegation principles, how it routes work
- [ ] Worker souls: personality, working style, principles for each role
- [ ] If user says "auto", generate sensible defaults based on role
- [ ] Show drafts and let user adjust

### Step 4: Assign Skills (per-agent skills.json)

For each agent, build its own skills.json:

- [ ] Recommend skills based on role heuristics
- [ ] Let user customize: add/remove per agent
- [ ] Manager typically has empty skills
- [ ] For each skill assigned to an agent, determine its install source:
  1. Check `~/.agents/.skill-lock.json` — if skill exists there, copy source info
  2. Check `~/.agents/skills-lock.json` — same
  3. If not found locally, search for it (GitHub, Cloud Hub) or ask user
- [ ] Write skills.json into each agent's folder

### Step 5: Generate and Save

- [ ] Create `~/.agents/teams/{team-name}/`
- [ ] Create `agents/{slug}/` for each agent (manager + workers)
- [ ] Write `team.md`
- [ ] For each agent write `agent.md` + `soul.md` + `skills.json`
- [ ] Verify with `find` tree listing

### Step 6: Summary

```
Team created successfully!
━━━━━━━━━━━━━━━━━━━━━━━━━

📁 ~/.agents/teams/{team-name}/
├── team.md — {description}
└── agents/
    ├── manager/
    │   ├── agent.md — Coordinator
    │   ├── soul.md
    │   └── skills.json — 0 skills
    ├── {agent-1}/
    │   ├── agent.md — {role}
    │   ├── soul.md
    │   └── skills.json — {N} skills
    └── ...

Total: {N} agents (1 manager + {N-1} workers)

Per-agent skills:
  • manager: (coordinator — no skills)
  • {agent-1}: {skill-1}, {skill-2}, ...
  • {agent-2}: {skill-1}, {skill-3}, ...

Merged skill manifest ({N} unique):
  • {skill-1} — {sourceType}: {source}
  • {skill-2} — {sourceType}: {source}
  ...
```

## Installation Flow (for consumers of this team)

When a team is installed, the installer should:

1. Read all `agents/*/skills.json` to collect every agent's skill dependencies
2. Merge and deduplicate skill IDs across all agents
3. For each unique skill: check if already installed in `~/.agents/skills/`
4. Install missing skills from their declared sources
5. Create OpenClaw agents via Gateway API for each agent in team.md
6. Upload `agent.md` and `soul.md` to each agent's workspace via `agents.files.set`

## Rules

- Every team MUST have a `manager` agent — it is the coordinator entry point
- All generated content in the language the user uses
- Each agent folder is self-contained: agent.md + soul.md + skills.json
- skills.json MUST include source info for every skill — no orphan references
- Do not invent skills — verify existence via lock files or web search
- Agent slugs must be unique within a team
- soul.md should feel human — avoid generic corporate language
- The team folder must be self-contained and portable (installable on any machine)
Files in this package (5)
  • SKILL.md 8 KB
  • templates/agent.md 1 KB
  • templates/skills.json 1 KB
  • templates/soul.md 1 KB
  • templates/team.md 1 KB

Versions

The database has no other skills named team-create.

Database snapshot: 13.11.2026 · package version 0aa26010a454 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100create
    Design and create a team-chat agent team with the person, a fixed team of subagents with roles, models, effort and a brief per member, saved to .claude/teams/ and opened in the team pane. Use when the person asks to create, set up, design or build a team.
  • 100agent-teams
    Create agent teams for parallel collaboration. Use when user mentions team, parallel, multi-agent, coordinate, collaborate, review team, multiple perspectives, or says "agent-teams".
  • 100team-stack
    Analyze a task, propose an agent team composition with roles and responsibilities, and create the team after user confirmation. Use when the user says "team stack", "create a team", "set up agents for this", or describes a complex task that would benefit from multiple agents working together.
  • 80agents:agent-team
    Orchestrating Claude Code agent teams. Use when creating teams, spawning teammates, assigning tasks, configuring teammate modes, or setting up team quality gate hooks.
  • 100claude-code-agent-teams
    This skill should be used when the user asks to "create an agent team", "run a multi-agent team", "coordinate multiple Claude sessions", "use agent teams", or wants to parallelize work across multiple Claude Code instances.
  • 100agent-teams
    创建和管理 Agent Teams 并行任务团队。当用户说"建个团队"、"拉个队伍"、"并行跑"、"create team"、"spawn agents"、"组队"时触发。

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.