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

1. **Team Design** — Define roles, responsibilities, and collaboration model
2. **Architecture Planning** — Single Gateway + multi-agent + channel strategy
3. **Agent & Workspace Setup** — Create agents, workspace files, identity
4. **Routing & Bindings** — Wire messages to the right agent
5. **Collaboration Rules** — Group chat strategy, mention gates, ping-pong limits
6. **Agent-to-Agent Communication** — sessions_send, sessions_spawn, allowlists
7. **Team Shared Memory** — Cross-agent knowledge sharing mechanism
8. **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

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

2. **How many agents do you want?** (recommend 2–5 to start; more adds complexity)

3. **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 does
   - `mode`: Does it lead (orchestrator) or follow (specialist)?

4. **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 tracking
- `coder` — Code implementation, debugging, technical execution
- `reviewer` — Code review, quality assurance, testing
- `writer` — Documentation, commit messages, technical writing

**Content Team (3 agents)**:
- `strategist` — Content strategy, audience analysis, topic planning
- `creator` — Writing, editing, creative output
- `critic` — Quality review, fact-checking, style consistency

**Business Team (4 agents)**:
- `chief` — Overall coordination, decision synthesis
- `analyst` — Data analysis, market research, risk assessment
- `builder` — Technical implementation, automation
- `communicator` — 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:

1. **Single Gateway, Multiple Agents**
   - One `openclaw gateway` process 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

2. **Isolation is real**
   - Each agent gets: workspace directory, `agentDir` for auth/state, session transcripts under `~/.openclaw/agents/<agentId>/sessions/`, memory index database
   - **Never reuse `agentDir` across agents** — causes auth/session collisions

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

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

1. Which channel(s) will you use? (can be multiple)
2. For group collaboration, which channel will be the "main stage"?
3. 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:

```bash
openclaw agents add <agent-id>
```

Or define them in `~/.openclaw/openclaw.json`:

```json5
{
  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`, or
> `GROUP_MEMORY.md` as standard OpenClaw files. These are custom additions.
> If the user wants collaboration rules, they should be embedded in `AGENTS.md`
> and `SOUL.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:

```markdown
# 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:

```markdown
# 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 co