OpenClaw Multi-Agent Team Setup: Build an AI Team for Your Business [2026]

Why Run Multiple Agents?

A single OpenClaw agent can handle a lot. But as your operations grow, a single agent trying to do everything — sales, operations, finance, customer service, personal assistance — starts to suffer from context overload. Its persona becomes bloated, its tool set becomes unwieldy, and its responses become less focused.

The solution is the same one that works in human organizations: specialize. Instead of one generalist, build a team of specialists. Each agent has a clear role, a focused persona, a limited set of tools, and specific permissions. The result is better performance, clearer ownership of tasks, and easier debugging when something goes wrong.

Think of it like hiring staff. You would not hire one person to be your sales rep, accountant, operations manager, and executive assistant simultaneously. The same logic applies to AI agents. Specialization produces better results.

OpenClaw's multi-agent architecture was introduced in version 3.20 and significantly improved in 3.22. It supports inter-agent communication, shared resources, role-based permissions, and independent model assignments per agent. This guide covers everything you need to build a functioning AI team.

Multi-Agent Architecture

OpenClaw's multi-agent system uses a hub-and-spoke model. Here is how it works:

The Hub: A single OpenClaw instance runs on your server. This instance manages all agents, routes messages, handles authentication, and coordinates shared resources. There is one Docker container, one database, and one set of API keys.

The Spokes: Each agent runs as a separate process within the OpenClaw instance. Every agent has its own persona file, memory directory, tool permissions, and model assignment. Agents are isolated from each other by default — they cannot read each other's memories or use each other's tools unless explicitly permitted.

The Router: When a message arrives (from WhatsApp, Telegram, email, etc.), the router decides which agent should handle it. Routing can be based on the messaging channel (WhatsApp messages go to Sales, email goes to CEO), keywords or patterns in the message, explicit user commands (@sales, @finance), or workflow delegation from another agent.

The architecture looks like this conceptually:

┌─────────────────────────────────────┐
│         OpenClaw Instance           │
│                                     │
│  ┌──────────┐    ┌──────────┐       │
│  │ CEO Agent│◄──►│  Router  │◄──── WhatsApp
│  └──────────┘    │          │◄──── Telegram
│  ┌──────────┐    │          │◄──── Email
│  │Sales Agent│◄──►│          │◄──── Discord
│  └──────────┘    │          │       │
│  ┌──────────┐    │          │       │
│  │ Ops Agent│◄──►│          │       │
│  └──────────┘    │          │       │
│  ┌──────────┐    │          │       │
│  │Fin. Agent│◄──►│          │       │
│  └──────────┘    └──────────┘       │
│                                     │
│  ┌────────────────────────────┐     │
│  │    Shared Resources        │     │
│  │  (DB, API keys, tools)     │     │
│  └────────────────────────────┘     │
└─────────────────────────────────────┘

Defining Team Roles

Before configuring anything, define what each agent in your team is responsible for. This is the most important step and the one most operators rush through. A poorly defined role leads to overlapping responsibilities, confused routing, and agents doing work that should belong to another agent.

For most small to medium businesses, we recommend starting with four agents:

You can add more agents later — customer support, marketing, HR, IT — but starting with four gives you a solid foundation and keeps costs manageable.

The CEO / Chief of Staff Agent

The CEO agent is your primary personal agent. It is the one you interact with most and the one with the broadest permissions. Think of it as your AI executive assistant.

Persona configuration (ceo_persona.md):

---
agent_id: ceo
name: Atlas
model: claude-opus-4
temperature: 0.3
max_tokens: 4096
channels: [whatsapp_personal, email_personal]
---

You are Atlas, the AI Chief of Staff for [Business Name].

Your primary responsibilities:
- Manage the executive's daily schedule and priorities
- Draft and review communications
- Coordinate with other agents (Sales, Ops, Finance) by delegating tasks
- Provide strategic analysis and decision support
- Maintain the executive's personal knowledge base

You have authority to:
- Read and send emails on behalf of the executive
- Manage calendar events
- Delegate tasks to Sales, Ops, and Finance agents
- Access all shared memory files
- Make scheduling decisions autonomously

Communication style:
- Direct and concise
- Proactive — surface important information before being asked
- Use bullet points for status updates
- Flag decisions that require human input clearly

The CEO agent typically uses the most capable (and expensive) model because it handles the most complex and varied tasks. It also has the broadest tool access and can delegate to any other agent.

The Sales Agent

The Sales agent focuses exclusively on revenue-generating activities. It qualifies leads, manages follow-ups, updates your CRM, and drafts proposals.

Persona configuration (sales_persona.md):

---
agent_id: sales
name: Hunter
model: claude-sonnet-4
temperature: 0.4
max_tokens: 2048
channels: [whatsapp_business, email_sales]
---

You are Hunter, the AI Sales Agent for [Business Name].

Your primary responsibilities:
- Respond to inbound leads within 5 minutes
- Qualify leads based on the BANT framework (Budget, Authority, Need, Timeline)
- Schedule discovery calls and demos
- Update the CRM with lead status, notes, and next actions
- Draft follow-up emails and proposals
- Track pipeline metrics and report weekly

You DO NOT:
- Close deals or negotiate pricing (escalate to human)
- Access financial records
- Modify operational workflows
- Send communications from the executive's personal accounts

Lead qualification criteria:
- Budget: minimum $500/month or $5,000 one-time
- Authority: must be a decision-maker or direct influencer
- Need: must have a clear problem your product/service solves
- Timeline: looking to start within 90 days

The Sales agent uses a mid-tier model because its tasks — responding to messages, updating CRM fields, drafting emails — do not require the most powerful reasoning. Claude Sonnet or GPT-4o handles these tasks well at a lower cost per message.

The Operations Agent

The Operations agent handles the day-to-day running of your business. It manages tasks, schedules, processes, and internal communications.

Persona configuration (ops_persona.md):

---
agent_id: ops
name: Compass
model: claude-sonnet-4
temperature: 0.2
max_tokens: 2048
channels: [slack, telegram_team]
---

You are Compass, the AI Operations Agent for [Business Name].

Your primary responsibilities:
- Manage project tasks and deadlines in Notion/Asana
- Send daily standup summaries to the team channel
- Track recurring processes and flag overdue items
- Schedule meetings and coordinate team availability
- Maintain operational documentation
- Run automated workflows (daily reports, weekly reviews)

You DO NOT:
- Interact with customers directly
- Access financial systems
- Make strategic decisions
- Send external communications

Escalation rules:
- Overdue tasks (3+ days): notify CEO agent
- Resource conflicts: notify CEO agent
- Process failures: log error, notify CEO agent, suggest fix

The Ops agent can use the cheapest model assignment because its tasks are structured and repetitive. If you want to minimize costs further, you can run the Ops agent on a local model through Ollama for zero API cost, though response quality may vary.

The Finance Agent

The Finance agent tracks money — invoices, expenses, budgets, and financial reporting.

Persona configuration (finance_persona.md):

---
agent_id: finance
name: Ledger
model: claude-sonnet-4
temperature: 0.1
max_tokens: 2048
channels: [email_finance, internal_dashboard]
---

You are Ledger, the AI Finance Agent for [Business Name].

Your primary responsibilities:
- Track incoming invoices and flag overdue payments
- Generate weekly expense reports
- Monitor budget vs. actual spending
- Alert when spending exceeds thresholds
- Prepare monthly financial summaries for the CEO agent
- Categorize transactions and maintain the chart of accounts

You DO NOT:
- Initiate payments or transfers (flag for human approval)
- Access customer-facing channels
- Modify operational workflows
- Share financial data outside the agent team without human approval

Accuracy requirements:
- All financial figures must be precise — never round or estimate
- Always cite the source document for any number you report
- Flag discrepancies immediately with both the number and the expected value

The Finance agent uses a low temperature (0.1) because financial tasks require precision over creativity. Every number must be exact, every categorization must be correct.

Permissions and Access Control

One of the most important aspects of a multi-agent team is ensuring each agent only has access to what it needs. OpenClaw's permission system operates on three levels:

Tool permissions: Each agent has an explicit list of tools it can use. The CEO agent might have access to email, calendar, CRM, and file management tools. The Finance agent only gets accounting tools and read-only email access.

# In agents.yml
agents:
  ceo:
    tools:
      - email_send
      - email_read
      - calendar_manage
      - crm_full_access
      - file_manager
      - agent_delegate    # Can delegate to other agents
    tool_permissions: full

  sales:
    tools:
      - email_send        # Only from sales email
      - email_read        # Only sales inbox
      - crm_full_access
      - calendar_read     # Read-only calendar
    tool_permissions: restricted

  ops:
    tools:
      - notion_manage
      - slack_send
      - calendar_manage
      - file_read         # Read-only file access
    tool_permissions: restricted

  finance:
    tools:
      - accounting_read
      - email_read        # Read-only, finance inbox only
      - spreadsheet_manage
      - report_generate
    tool_permissions: restricted

Channel permissions: Each agent is assigned specific messaging channels. This prevents the Sales agent from accidentally responding in the CEO's personal WhatsApp chat, or the Finance agent from sending messages in the customer-facing Telegram group.

Memory permissions: By default, each agent has its own memory directory and cannot read other agents' memories. You can create shared memory spaces for information that multiple agents need — for example, a shared client list or company policies file.

# Memory configuration
memory:
  ceo:
    private: /memory/ceo/
    shared: [/memory/shared/clients/, /memory/shared/policies/]
  sales:
    private: /memory/sales/
    shared: [/memory/shared/clients/, /memory/shared/products/]
  ops:
    private: /memory/ops/
    shared: [/memory/shared/policies/, /memory/shared/processes/]
  finance:
    private: /memory/finance/
    shared: [/memory/shared/clients/, /memory/shared/budgets/]

Shared Tools and Resources

While agents are isolated by default, some resources need to be shared across the team:

Shared memory files: Information that multiple agents need — client contact lists, company policies, product catalogs, pricing sheets. These live in the /memory/shared/ directory and are readable by agents with explicit permission.

Shared API keys: All agents share the same AI model API keys, messaging platform tokens, and integration credentials. These are configured once in the master .env file.

Shared database: All agents use the same SQLite database for conversation history and session management. Each agent's conversations are tagged with its agent_id, so they remain logically separated even though they share the same database.

The delegation tool: The agent_delegate tool allows one agent to send a task to another agent and receive the result. This is how the CEO agent can ask the Finance agent to pull revenue numbers without the CEO agent needing direct access to the accounting system.

# Example: CEO agent delegating to Finance agent
@delegate finance "What is our total revenue for March 2026? Break down by client."

# The Finance agent receives this as a task, queries the accounting system,
# and returns the result to the CEO agent's conversation.

Workflow Routing Between Agents

Routing determines which agent handles which messages. OpenClaw supports several routing strategies:

Channel-based routing (simplest): Messages from specific channels always go to specific agents. WhatsApp personal goes to CEO, WhatsApp Business goes to Sales, Slack goes to Ops.

# In agents.yml
routing:
  whatsapp_personal: ceo
  whatsapp_business: sales
  email_personal: ceo
  email_sales: sales
  email_finance: finance
  slack: ops
  telegram_team: ops

Keyword-based routing: Messages containing specific keywords are routed to specific agents. A message mentioning "invoice" or "payment" goes to Finance, regardless of the channel.

routing_rules:
  - pattern: "(invoice|payment|expense|budget|revenue)"
    agent: finance
    priority: high
  - pattern: "(lead|prospect|demo|proposal|pricing)"
    agent: sales
    priority: high
  - pattern: "(task|deadline|schedule|meeting|standup)"
    agent: ops
    priority: medium

Mention-based routing: Users explicitly address an agent with @mentions. "@sales what's the pipeline status?" goes directly to the Sales agent.

Delegation-based routing: One agent passes a task to another. The CEO agent receives a complex request that involves financial data, delegates the financial portion to the Finance agent, and synthesizes the results.

In practice, most operators use a combination. Channel-based routing handles the majority of messages, keyword-based routing catches edge cases, and delegation handles complex multi-step workflows.

Cost Per Agent

Understanding the cost breakdown helps you plan your agent team budget:

Example: 4-agent team on a budget

• Hetzner CX21 (4GB RAM, 2 vCPU): $8/month
• CEO agent on Claude Opus: $30/month API
• Sales agent on Claude Sonnet: $15/month API
• Ops agent on Claude Sonnet: $10/month API
• Finance agent on Claude Sonnet: $8/month API
• Total: approximately $71/month

Example: 4-agent team with local models for cost reduction

• Hetzner AX41 (64GB RAM, dedicated): $45/month
• CEO agent on Claude Opus: $30/month API
• Sales agent on Claude Sonnet: $15/month API
• Ops agent on Ollama (local Llama 3): $0/month API
• Finance agent on Ollama (local Llama 3): $0/month API
• Total: approximately $90/month (higher server cost, lower API cost)

Real Workflow Examples

Here are three real multi-agent workflows that demonstrate how agents collaborate:

Workflow 1: New Lead Processing

1. A prospect sends a WhatsApp message to the business number: "Hi, I need help with AI automation for my real estate agency."
2. The Router sends the message to the Sales agent (channel-based routing).
3. The Sales agent qualifies the lead using BANT questions: "Thanks for reaching out! I'd love to learn more. Quick question — what's your monthly budget for AI automation, and when are you looking to get started?"
4. After qualification, the Sales agent updates the CRM with the new lead and schedules a discovery call on the CEO's calendar.
5. The Sales agent delegates to the CEO agent: "@delegate ceo New qualified lead: [Name], real estate agency, $2K/month budget, wants to start in April. Discovery call scheduled for Thursday at 2pm."
6. The CEO agent adds the lead to its briefing notes and prepares talking points for the call.

Workflow 2: Monthly Financial Review

1. On the 1st of each month (scheduled via workflow_auto.md), the CEO agent triggers the monthly review workflow.
2. CEO agent delegates to Finance: "@delegate finance Generate the monthly financial summary for February 2026. Include revenue by client, total expenses by category, and net profit."
3. Finance agent queries the accounting system, generates the report, and returns it to the CEO agent.
4. CEO agent delegates to Ops: "@delegate ops List all overdue tasks and projects that missed their February deadlines."
5. Ops agent checks Notion, compiles the list, and returns it.
6. CEO agent synthesizes both reports and sends a consolidated monthly review to the executive via WhatsApp: "Your February review is ready. Revenue: $42K (+8% MoM). Expenses: $31K. Net: $11K. Three overdue projects need attention: [details]. Shall I schedule time to review?"

Workflow 3: Customer Issue Escalation

1. A customer messages the business WhatsApp: "My invoice from January still hasn't been corrected. This is the third time I'm asking."
2. The Router sends it to Sales (channel-based), but keyword routing detects "invoice" and re-routes to Finance.
3. Finance agent looks up the customer's invoices: "I can see the January invoice for $1,200. The original amount was $1,500 and a credit of $300 was applied on Feb 3. What correction are you expecting?"
4. If the customer is still unhappy, Finance escalates to CEO: "@delegate ceo Repeat customer complaint about January invoice. [Customer Name] has asked three times. Details: [summary]. Recommend immediate resolution."
5. CEO agent reviews the situation and either resolves it directly or flags it for human attention: "This needs your personal touch. [Customer Name] is frustrated about a $300 discrepancy. I've drafted an email with a resolution offer — shall I send it?"

Scaling Your Agent Team

Start small and scale up. Here is the recommended progression:

Phase 1 — Single agent (week 1-2): Deploy one agent (the CEO/Chief of Staff) and get comfortable with the platform. Learn how personas, memory, and tools work with a single agent before adding complexity.

Phase 2 — Two agents (week 3-4): Add the agent that addresses your biggest bottleneck. For most businesses, that is either Sales (if lead follow-up is slow) or Ops (if internal coordination is chaotic).

Phase 3 — Full team (month 2): Add the remaining agents. At this point, you have enough experience with OpenClaw to configure routing, permissions, and delegation effectively.

Phase 4 — Specialized agents (month 3+): Add agents for specific functions as needed: Customer Support, Marketing, HR, IT. Each new agent should have a clear, bounded role that does not overlap with existing agents.

As your team grows, monitor these metrics:

• Response time: How quickly each agent responds to messages. If response times increase, you may need to upgrade your server or optimize the agent's tool set.
• Routing accuracy: What percentage of messages reach the correct agent on the first try. If misroutes are common, refine your routing rules.
• Delegation success rate: How often inter-agent delegations complete successfully. Failed delegations usually indicate unclear instructions or missing permissions.
• API cost per agent: Track costs individually to identify which agents are expensive and whether model downgrades make sense.
• Memory usage: Run docker stats regularly. If you are approaching 80% of your VPS RAM, either upgrade the server or move agents to a second instance.

A well-configured multi-agent team can handle the workload of 2-3 full-time assistants at a fraction of the cost. The key is clear role definition, strict permissions, and thoughtful routing. Start with the four core agents described in this guide, and expand as your confidence and needs grow.