agent-team-builder
Guide users through building a custom multi-agent team on OpenClaw — from role design to workspace files, routing bindings, channel configuration, and collaboration rules.
Install / Use
npx skills add LeoYeAI/openclaw-master-skills --skill agent-team-builderInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of agent-team-builder
agent-team-builder scores 90/100 on our quality scale, 1363rd of 4,700 Development & Engineering skills we index (top 29%).
Its SKILL.md is 22 KB long, well organised into 65 sections with 22 code examples: a thorough specification that gives an agent plenty to work with.
With 2,149 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-30 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
agent-team-builder compared with similar skills
All 4 of these similar skills score higher than agent-team-builder; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| agent-team-builder (this skill)by LeoYeAI | 90 | 2.1k | 4mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install agent-team-builder?
- Run
npx skills add LeoYeAI/openclaw-master-skills --skill agent-team-builder. The install tabs above show the steps for each supported agent. - Which AI agents does agent-team-builder work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is agent-team-builder safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is agent-team-builder still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: agent-team-builder description: > Guide users through building a custom multi-agent team on OpenClaw — from role design to workspace files, routing bindings, channel configuration, and collaboration rules. Use this skill whenever the user mentions building an AI team, multi-agent setup, multi-agent collaboration, agent roles, OpenClaw team configuration, or wants to create multiple agents that work together. Also trigger when the user says things like "set up my agents", "create an agent team", "configure multi-agent", "I want multiple AI assistants working together", or references team coordination, agent routing, agent-to-agent communication, or workspace isolation in OpenClaw.
Agent Team Builder for OpenClaw
Build a custom multi-agent collaboration team on OpenClaw — step by step, with correct architecture, workspace files, routing config, and collaboration rules.
Important: This skill is based on verified OpenClaw documentation (docs.openclaw.ai) and the official GitHub repo (github.com/openclaw/openclaw). All configuration patterns, file names, and architecture decisions reflect the actual OpenClaw system as of early 2026.
How This Skill Works
This is an interactive, guided workflow. You walk the user through 8 phases:
- Team Design — Define roles, responsibilities, and collaboration model
- Architecture Planning — Single Gateway + multi-agent + channel strategy
- Agent & Workspace Setup — Create agents, workspace files, identity
- Routing & Bindings — Wire messages to the right agent
- Collaboration Rules — Group chat strategy, mention gates, ping-pong limits
- Agent-to-Agent Communication — sessions_send, sessions_spawn, allowlists
- Team Shared Memory — Cross-agent knowledge sharing mechanism
- Memory, Operations & Delivery — Per-agent memory, heartbeat, cost control, final config
At each phase, ask the user questions, validate their choices, then generate the corresponding configuration and workspace files.
Phase 1: Team Design
Goal
Help the user define their agent team composition.
Questions to Ask
-
What is your primary use case?
- Personal productivity (schedule, research, writing)
- Software development (code, review, deploy)
- Content creation (writing, editing, publishing)
- Business operations (strategy, analysis, execution)
- Custom / mixed
-
How many agents do you want? (recommend 2–5 to start; more adds complexity)
-
For each agent, define:
id: short lowercase identifier (e.g.,planner,coder,writer)name: display name (e.g., "🧠 Planner")role: one-sentence description of what this agent doesmode: Does it lead (orchestrator) or follow (specialist)?
-
Do you want an orchestrator agent?
- An orchestrator monitors all group messages and dispatches to specialists
- Specialists only respond when explicitly @-mentioned
- This is the recommended pattern for 3+ agents
Guidance
Recommended team templates (user can customize):
Dev Team (4 agents):
planner— Task decomposition, prioritization, project trackingcoder— Code implementation, debugging, technical executionreviewer— Code review, quality assurance, testingwriter— Documentation, commit messages, technical writing
Content Team (3 agents):
strategist— Content strategy, audience analysis, topic planningcreator— Writing, editing, creative outputcritic— Quality review, fact-checking, style consistency
Business Team (4 agents):
chief— Overall coordination, decision synthesisanalyst— Data analysis, market research, risk assessmentbuilder— Technical implementation, automationcommunicator— External communication, reports, presentations
Solo+ (2 agents):
main— General-purpose assistant (default agent)research— Deep research, analysis, background tasks
Phase 2: Architecture Planning
Key Architecture Facts (from official docs)
Explain these to the user clearly:
-
Single Gateway, Multiple Agents
- One
openclaw gatewayprocess hosts ALL agents - Each agent has its own workspace, session store, and memory index
- Agents are defined in
agents.list[]in~/.openclaw/openclaw.json - No need to run multiple Gateway processes
- One
-
Isolation is real
- Each agent gets: workspace directory,
agentDirfor auth/state, session transcripts under~/.openclaw/agents/<agentId>/sessions/, memory index database - Never reuse
agentDiracross agents — causes auth/session collisions
- Each agent gets: workspace directory,
-
Channel Strategy Ask the user which channels they want to use:
- Discord: Best for visible multi-agent group collaboration. Each agent needs its own bot account (Discord Developer Portal → one bot per agent). Enable Message Content Intent for each bot.
- Telegram: Each agent needs its own bot via BotFather. Good for controlled/private channels.
- WhatsApp: Each agent maps to a phone number/account. Good for personal use.
- Slack, Signal, iMessage, etc.: All supported. See channel guides in docs.
-
Discord is recommended for group collaboration because:
- Each bot has a visible identity in the server
- @mention mechanics work naturally
- Conversation threading is visible
- Multiple bots can coexist in one guild/server
Questions to Ask
- Which channel(s) will you use? (can be multiple)
- For group collaboration, which channel will be the "main stage"?
- Do you want the same agents on multiple channels, or different agents per channel?
Phase 3: Agent & Workspace Setup
Creating Agents
For each agent, the user should run:
openclaw agents add <agent-id>
Or define them in ~/.openclaw/openclaw.json:
{
agents: {
list: [
{ id: "planner", workspace: "~/.openclaw/workspace-planner" },
{ id: "coder", workspace: "~/.openclaw/workspace-coder" },
{ id: "reviewer", workspace: "~/.openclaw/workspace-reviewer" },
],
},
}
Workspace Files
Each agent's workspace follows this standard structure (per official docs):
| File | Purpose | Loaded When |
|------|---------|-------------|
| AGENTS.md | Operating instructions, memory rules, behavior priorities | Every session |
| SOUL.md | Persona, tone, boundaries | Every session |
| USER.md | Who the user is, how to address them | Every session |
| IDENTITY.md | Agent name, vibe, emoji (created during bootstrap) | Every session |
| TOOLS.md | Notes about local tools/conventions (guidance only, does NOT control tool access) | Every session |
| HEARTBEAT.md | Optional tiny checklist for heartbeat runs | Heartbeat only |
| BOOT.md | Optional startup checklist on gateway restart | Gateway start |
| BOOTSTRAP.md | One-time first-run ritual, deleted after completion | First run only |
| memory/YYYY-MM-DD*.md | Daily memory logs (append-only) | On demand |
| MEMORY.md | Curated long-term memory | Private sessions only |
Critical correction: The official workspace does NOT include files named
ROLE-COLLAB-RULES.md,TEAM-RULEBOOK.md,TEAM-DIRECTORY.md, orGROUP_MEMORY.mdas standard OpenClaw files. These are custom additions. If the user wants collaboration rules, they should be embedded inAGENTS.mdandSOUL.md, which are the files OpenClaw actually loads every session.
Generate Workspace Files
For each agent, generate these files based on the user's team design.
SOUL.md template — Customize per agent:
# Soul of [Agent Name]
## Identity
- Name: [Display Name]
- Role: [One-line role description]
- Emoji: [Emoji identifier]
## Personality
[2-3 sentences describing tone, communication style]
## Responsibilities
[Bullet list of what this agent owns]
## Boundaries
- [What this agent should NOT do]
- [When to defer to other agents]
## Private Chat Mode
[How to behave in 1:1 conversations — act as full-service expert]
## Group Chat Mode
[How to behave in group — follow team protocol, incremental contributions only]
AGENTS.md template — Customize per agent:
# Operating Manual for [Agent Name]
## Core Behavior
- Always read IDENTITY.md and USER.md at session start
- In group chats, only respond when @-mentioned (unless you are the orchestrator)
- Write important decisions to memory/YYYY-MM-DD.md
## Memory Protocol
- Read today's and yesterday's daily log at session start
- Use memory_search for semantic recall before answering complex questions
- Write durable facts to MEMORY.md only in private sessions
- Never load MEMORY.md in group contexts
## Collaboration Protocol
- When your task is done, summarize your output clearly
- If a task is outside your role, say so and suggest which agent to @
- Never engage in back-and-forth with other agents without user involvement
## Quality Standards
[Role-specific quality requirements]
IDENTITY.md template:
# [Agent Name]
- id: [agent-id]
- name: [Display Name]
- emoji: [Emoji]
- role: [Role description]
- capabilities: [What this agent can do]
Phase 4: Routing & Bindings
How Bindings Work
Bindings route inbound messages to agents. They are evaluated in order — first match wins. More specific bindings should come before general ones.
Each binding matches on: channel, accountId, chatType, peer, guild/team IDs.
Discord Configuration
Each Discord bot = one accountId. Bind each to an agent:
{
bindings: [
{ agentId: "planner", match: { channel: "discord", accountId: "planner-bot" } },
{ agentId: "coder", match: { channel: "discord", accountId: "coder-bot" } },
{ agentId: "reviewer", match: { channel: "discord", accountId: "reviewer-bot" } },
],
channels: {
discord: {
accounts: {
"planner-bot": {
token: "${DISCORD_TOKEN_PLANNER}",
guilds: {
"<guild-id>": {
channels: {
"<collab-channel-id>": { allow: true },
},
},
},
},
"coder-bot": {
token: "${DISCORD_TOKEN_CODER}",
// ... similar guild/channel config
},
// ... other bots
},
},
},
}
Telegram Configuration
Each Telegram bot = one accountId:
{
bindings: [
{ agentId: "planner", match: { channel: "telegram", accountId: "default" } },
{ agentId: "coder", match: { channel: "telegram", accountId: "coder" } },
],
channels: {
telegram: {
accounts: {
default: { botToken: "${TELEGRAM_TOKEN_PLANNER}" },
coder: { botToken: "${TELEGRAM_TOKEN_CODER}" },
},
},
},
}
Questions to Ask
- For Discord: Have you created bot accounts in the Discord Developer Portal?
- Do you want all agents in the same guild channel, or separate channels?
- For each agent, what's their account identifier?
Phase 5: Collaboration Rules
Group Chat Strategy
The recommended pattern for multi-agent group collaboration:
Orchestrator agent: requireMention: false (sees all messages)
- Monitors all group messages
- Decides when to dispatch tasks
- Does NOT respond to everything — stays silent by default, intervenes when needed
Specialist agents: requireMention: true (only responds when @-mentioned)
- Each specialist has
mentionPatternsfor reliable triggering - Only acts when explicitly called upon
// In the orchestrator's account config:
guilds: {
"<guild-id>": {
channels: {
"<channel-id>": { allow: true, requireMention: false },
},
},
},
// In specialist accounts:
guilds: {
"<guild-id>": {
channels: {
"<channel-id>": { allow: true, requireMention: true },
},
},
},
Mention Patterns
Configure per-agent mention patterns so users can reliably summon agents:
// Per age
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
