agentleFS
clawwork-aiclawwork-ai/ClawWork/.claude/skills/team-creator/SKILL.md

team-create

Skill533 starsChanged 5 months agoApache-2.0View on GitHub

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.

The file

We split this skill into the rules it gives an agent

9 rules. About 0 are common, 5 are distinctive, and 4 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Every team MUST have a manager agent with these properties:

    line 132
  2. Very specific:

    Check ~/.agents/.skill-lock.json — if skill exists there, copy source info

    line 198
  3. Distinctive:

    If not found locally, search for it (GitHub, Cloud Hub) or ask user

    line 200
  4. Distinctive:

    When a team is installed, the installer should:

    line 245
  5. Very specific:

    Read all agents/*/skills.json to collect every agent's skill dependencies

    line 247
  6. Distinctive:

    Create OpenClaw agents via Gateway API for each agent in team.md

    line 251
  7. Very specific:

    Every team MUST have a manager agent — it is the coordinator entry point

    line 256
  8. Distinctive:

    All generated content in the language the user uses

    line 257
  9. Distinctive:

    Do not invent skills — verify existence via lock files or web search

    line 260

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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

---
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.

---
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.

# {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.

{
  "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)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.