- OpenClaw multi-agent systems use an orchestrator-worker pattern where specialized agents handle distinct tasks in parallel
- Each agent has its own model, tools, memory, and system prompt — mix providers freely across a single pipeline
- Agents communicate through the gateway message bus using channel IDs, not direct API calls
- Shared memory allows agents to pass state without bloating message payloads
- A standard 4-core VPS handles 10–15 concurrent active agents before hardware becomes a bottleneck
Teams who run multi-agent setups complete tasks in a quarter of the time. The ones that struggle built their system without a clear coordination model. Here's what separates working multi-agent pipelines from expensive messes — and how to build the right way from day one.
Why Single Agents Hit a Wall
A single agent processing a complex task runs into three hard limits. Context overflows when the task requires more information than fits in one conversation window. Speed suffers because every subtask runs sequentially. Quality degrades when one agent tries to be simultaneously an expert researcher, a data analyst, and a content writer.
Here's where most people stop. They optimize the single agent — bigger context window, better prompts, more tools. Those optimizations buy marginal gains. The real gain comes from decomposition.
Multi-agent systems solve all three problems simultaneously. Specialized agents keep context focused. Parallel execution collapses processing time. Division of responsibility lets each agent operate in its area of competence.
Every agent in your system should do one thing well. An agent that researches, summarizes, and writes is an agent that does all three poorly. Keep roles tight and handoffs clean.
What Multi-Agent Actually Means in OpenClaw
In OpenClaw, a multi-agent system is two or more independent agent processes running under a shared gateway, coordinating via the message bus. Each agent is a separate OpenClaw instance with its own configuration file, system prompt, tool set, and optionally its own LLM model.
This matters because coordination happens at the messaging layer, not at the code layer. An orchestrator agent doesn't call a worker agent's function directly — it sends it a message through the gateway, just as a human user would. The worker processes the message, executes its task, and responds. The orchestrator receives that response as a message and acts on it.
This design choice gives you two huge advantages. First, each agent is independently testable — you can simulate any agent's behavior by sending it messages manually. Second, you can replace any agent in the pipeline without touching the others, as long as the message contract stays the same.
The Three Agent Roles
| Role | Responsibility | Typical Model |
|---|---|---|
| Orchestrator | Breaks tasks into subtasks, delegates, aggregates results | GPT-4o / Claude Sonnet |
| Worker | Executes a specific subtask using domain tools | Claude Haiku / Ollama |
| Monitor | Watches pipeline health, escalates failures, logs decisions | Any fast model |
Setting Up Your First Multi-Agent System
The simplest useful multi-agent system is an orchestrator and two specialized workers. This setup handles the vast majority of automation use cases while being simple enough to debug when things go wrong.
# agents.md — define your agent team
agents:
- id: orchestrator
model: gpt-4o
system_prompt: "You are a research coordinator. Break complex queries into subtasks and delegate to your worker agents: researcher (channel: researcher-001) and writer (channel: writer-001). Aggregate their outputs into a final response."
tools: [send-message, read-memory, write-memory]
- id: researcher
channel: researcher-001
model: claude-haiku-4-5
system_prompt: "You are a research specialist. When given a topic, search the web, find relevant data, and return a structured summary with sources. Focus on accuracy over brevity."
tools: [web-search, read-url, write-memory]
- id: writer
channel: writer-001
model: claude-haiku-4-5
system_prompt: "You are a content writer. When given research data from memory, transform it into clear, engaging prose. Match the tone specified in the task brief."
tools: [read-memory, write-memory]Channel IDs are how agents address each other. Use descriptive IDs like researcher-001 rather than generic names. This makes your orchestrator's system prompt readable and debugging trivial — you can see exactly which agent failed from the logs.
Start the orchestrator first, then the workers. The orchestrator's gateway registers its channel. Workers register theirs. When the orchestrator calls send-message with a target channel ID, OpenClaw routes the message to the correct agent process automatically.
Coordination Patterns That Work
Most multi-agent failures happen at the coordination layer, not the task layer. The agents themselves perform fine — the orchestrator just doesn't know when to wait, when to parallelize, and when a result is good enough to proceed.
Sequential Pipeline
The simplest pattern. The orchestrator sends task A to worker 1, waits for a response, then sends the result as context to worker 2. No parallelism, but maximum predictability. Use this when step 2 truly depends on step 1's full output — for example, when a writer needs a complete research brief before starting.
Parallel Dispatch
The orchestrator sends tasks to multiple workers simultaneously without waiting for each. It then collects all responses when they arrive and aggregates. Use this when subtasks are independent — for example, researching five different topics at once. As of early 2025, OpenClaw handles parallel dispatch through asynchronous message handling in the gateway.
Fan-Out with Validation
Send the same task to two workers and compare results. A monitor agent checks for consistency. If workers disagree, escalate to the orchestrator for resolution. This adds latency but dramatically improves reliability for high-stakes tasks.
State and Memory Across Agents
The most common mistake in multi-agent design is passing all state through messages. A message containing 4,000 words of research context is slow to process, expensive to tokenize, and hard to debug.
Use shared memory instead. The researcher writes its findings to a named memory key. The writer reads that key when it starts. The orchestrator coordinates which key to use by including it in the task message — a single short string like task-context-42.
This pattern keeps messages small, processing fast, and the system debuggable. You can inspect any memory key at any time using the OpenClaw dashboard or the openclaw memory get [key] CLI command.
Common Mistakes That Kill Multi-Agent Systems
- No error handling in the orchestrator — if a worker times out and you haven't told the orchestrator what to do, it waits forever. Always set a timeout and a fallback instruction in the orchestrator's prompt.
- Too many agents too soon — start with two workers maximum. Add a third only when you've proven the two-worker system works reliably. Complexity compounds fast in multi-agent systems.
- Mixing model sizes poorly — using a slow, expensive model as a worker for simple classification tasks is a cost multiplier. Match model capability to task complexity.
- Shared memory key collisions — if two parallel tasks write to the same memory key, one overwrites the other. Namespace your keys:
task-{task-id}-researchinstead ofresearch. - No logging on inter-agent messages — enable message logging in the gateway config. You cannot debug multi-agent failures without a record of which agent sent what to whom and when.
Frequently Asked Questions
What is a multi-agent system in OpenClaw?
A multi-agent system in OpenClaw is a setup where two or more independent agent processes collaborate on a task. Each agent has its own model, tools, memory, and system prompt. They communicate via the gateway message bus. One agent typically acts as an orchestrator that delegates subtasks to specialized worker agents.
How many agents can OpenClaw run simultaneously?
OpenClaw can run dozens of agents simultaneously on a single server. The practical limit depends on your hardware and LLM API rate limits, not the framework itself. A standard 4-core VPS with 8GB RAM comfortably handles 10–15 concurrent active agents without performance degradation.
Do all agents need to use the same model?
No — each agent can use a different LLM. Run GPT-4o as the orchestrator for complex reasoning, Claude Haiku for fast classification, and a local Ollama model for sensitive data. Mix and match based on cost and capability needs per task.
How does one agent send a message to another?
Agents communicate through the gateway message bus. An orchestrator agent uses the send-message tool with a target channel ID. The receiving agent processes it as a normal user message and responds. OpenClaw handles routing, queuing, and delivery automatically.
Can multi-agent systems run tasks in parallel?
Yes. The orchestrator can dispatch tasks to multiple worker agents simultaneously without waiting for each to finish sequentially. OpenClaw's task dispatcher handles parallel execution. Results from parallel workers are collected and merged by the orchestrator before producing a final output.
What happens if a worker agent fails?
A failed worker returns an error to the orchestrator. Configure error handling in the orchestrator's system prompt — instruct it to retry, reassign to another agent, or degrade gracefully. OpenClaw also supports timeout settings per agent so hung workers don't block the whole pipeline.
How is state shared between agents?
Agents share state through OpenClaw's shared memory store. Any agent can read and write to named memory keys. The orchestrator typically writes task context to shared memory before delegating, so workers have full context without needing it passed in every message.
A. Larsen has built multi-agent pipelines for research automation, customer support, and data processing across three production deployments. Specializes in orchestrator design and inter-agent communication patterns in OpenClaw environments.