How to Set Up a Multi-Agent Team with OpenClaw

One OpenClaw agent is useful. A team of agents is a force multiplier. Instead of one generalist doing everything, you can run specialized agents — a builder who codes, a strategist who plans, a creator who writes — each with their own memory, personality, and tools.

This isn’t theoretical. Users are running 6-8 agent teams that operate autonomously overnight, delivering finished work by morning. Here’s how to set it up.

Why Multi-Agent?

A single agent hits limits fast:

• Context window fills up with mixed tasks (coding + writing + research)
• Personality conflicts — you want your coder to be precise, your writer to be creative
• No parallelism — one agent can only do one thing at a time

Multiple agents solve all three. Each gets a focused role, dedicated memory, and can work simultaneously.

Architecture Overview

┌─────────────┐
│  You (Kai)  │
└──────┬──────┘
       │ Slack / Telegram / Discord
       ▼
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Strategist │     │   Builder    │     │   Creator    │
│   (Ethan)    │     │   (Marcus)   │     │   (Leo)      │
│              │     │              │     │              │
│ • Planning   │     │ • Code       │     │ • Content    │
│ • Research   │     │ • Debug      │     │ • Social     │
│ • Analysis   │     │ • Deploy     │     │ • Marketing  │
└──────────────┘     └──────────────┘     └──────────────┘
       │                    │                    │
       └────────────────────┼────────────────────┘
                            ▼
                   Shared Workspace
                   (files, memory)

Step 1: Define Your Agents

In your clawdbot.json (or openclaw.json), add an agents array. Each agent gets:

• id — unique identifier
• name — display name
• soul — personality and role definition (SOUL.md path)
• channels — which chat channels this agent monitors
• skills — which tools this agent can use

{
  "agents": [
    {
      "id": "strategist",
      "name": "Ethan",
      "soul": "agents/strategist/SOUL.md",
      "channels": ["#strategy", "#ceo-coach"],
      "skills": ["web_search", "reddit", "hn"]
    },
    {
      "id": "builder",
      "name": "Marcus",
      "soul": "agents/builder/SOUL.md",
      "channels": ["#coding", "#devops"],
      "skills": ["github", "coding-agent", "cloudflare"]
    },
    {
      "id": "creator",
      "name": "Leo",
      "soul": "agents/creator/SOUL.md",
      "channels": ["#content", "#social"],
      "skills": ["bird", "social-content", "copywriting"]
    }
  ]
}

Step 2: Write SOUL.md for Each Agent

This is where personality lives. A builder’s SOUL.md might say:

# SOUL.md — Marcus (Builder)

You are Marcus, the engineering lead. You write clean, tested code.

## Personality
- Precise, methodical, slightly dry humor
- Always check existing code before writing new code
- Prefer simple solutions over clever ones

## Rules
- Never push to main without tests
- Always create feature branches
- Document non-obvious decisions

The key insight: specificity matters. Don’t say “you’re a coder.” Say “you prefer TypeScript, use pnpm, and write Astro components with minimal client-side JS.”

Step 3: Set Up Channels

Each agent needs a home. On Slack or Discord:

1. Create dedicated channels: #p-work-coding, #p-content-studio, #p-strategy
2. Map agents to channels in your config
3. Use a shared channel (like #general) for cross-agent coordination

Agents only see messages in their channels, keeping context focused and token costs low.

Step 4: Add a Daemon (Orchestrator)

The secret weapon: a daemon agent that supervises the others.

{
  "id": "daemon",
  "name": "Daemon",
  "soul": "agents/daemon/SOUL.md",
  "channels": ["#ops"],
  "capabilities": ["spawn_agents", "monitor_health"]
}

The daemon can:

• Night shift supervision — wake agents with tasks at 2am
• Health monitoring — check if agents are stuck or idle
• Workspace backup — commit and push work automatically
• Morning delivery — compile overnight results into a summary

Step 5: Cron Jobs for Overnight Work

The real power: agents that work while you sleep.

{
  "cron": [
    {
      "name": "Night Supervisor",
      "schedule": { "kind": "cron", "expr": "0 2 * * *", "tz": "Asia/Shanghai" },
      "payload": {
        "kind": "agentTurn",
        "message": "Night shift. Check active projects, assign work to agents, deliver results by morning."
      },
      "sessionTarget": "isolated"
    }
  ]
}

Real-World Example: A 6-Agent Team

Here’s a production setup running right now:

Agent	Role	Overnight Output
Alex (Chief of Staff)	Morning briefs, task coordination	Daily brief with weather, calendar, todos
Marcus (Builder)	Code, deploy, debug	Bug fixes, new features, type checks
Leo (Creator)	Content, social media	Tweet drafts, competitor analysis, trends
Ethan (Strategist)	Research, planning	Market analysis, growth strategy, bounty scanning
Noah (Guardian)	Health, security	Wellness checks, security audits, health data
Victor (CFO)	Finance, spending	Expense tracking, invoice processing

Every morning, the owner wakes up to finished work in their Slack channels. Blog posts written, code shipped, research compiled.

Cost Management

Multiple agents mean multiple API calls. Keep costs down:

1. Model routing — Use cheap models (DeepSeek, Haiku) for routine tasks, premium (Sonnet, Opus) for complex ones
2. Focused channels — Agents only process messages in their channels
3. Heartbeat batching — Check multiple things per heartbeat instead of separate cron jobs
4. Memory limits — Set contextTokens per agent to prevent runaway costs

A well-tuned 6-agent team can run for $5-15/day depending on activity.

Common Pitfalls

Don’t overlap responsibilities. If two agents both think they should answer coding questions, you’ll get duplicate responses and wasted tokens.

Don’t skip SOUL.md. Generic agents give generic results. The more specific the personality and rules, the better the output.

Don’t forget memory. Each agent needs its own memory/ directory. Without it, they forget everything between sessions.

Start small. Begin with 2 agents. Add more when you understand the workflow. A poorly configured 8-agent team is worse than a well-tuned 2-agent team.

What’s Next

Once your team is running:

• Set up sub-agent spawning so agents can delegate to each other
• Create shared knowledge bases that all agents can read
• Build approval workflows where agents propose and you approve
• Add specialized tools per agent (GitHub for builder, Bird for creator)

The multi-agent pattern is the closest thing to having a real team that works 24/7. The setup takes an afternoon. The compounding returns last forever.

---

Track your multi-agent work with a Kanban board and monitor agent health with Mission Control. To keep costs manageable across multiple agents, read our API cost reduction guide.