OpenClaw Field Guide

Section 18: Multi-Agent Mode - When One AI Isn't Enough

For simple tasks, one assistant is enough.

But for complex work - especially tasks mixing research, writing, and technical execution - a single agent can become slow, overloaded, or context-limited.

That's where multi-agent mode helps.

In multi-agent mode, your main OpenClaw assistant delegates parts of a task to specialist sub-agents, then combines results into one coherent output.

What sub-agents are

A sub-agent is a temporary specialist created for a focused job.

Examples:

  • Research sub-agent: gather and summarize sources quickly
  • Coding sub-agent: implement and test changes in code
  • Writing sub-agent: turn notes into polished copy

Your main assistant stays as coordinator:

  • decides what to delegate
  • sets constraints
  • receives outputs
  • presents a final result to you

::: beginner Think of your main assistant as a project manager and sub-agents as short-term specialists. :::

Why this matters in practice

1) Better focus per task

Each sub-agent gets a narrower objective, so output quality is often cleaner.

2) Parallel progress

Research and drafting can happen at the same time instead of sequentially.

3) Less context overload

Large projects can exceed what one context window handles comfortably. Delegation reduces clutter.

4) Faster delivery for complex jobs

When configured well, multi-agent workflows shorten turnaround on bigger tasks.

Coding agents: what they do that general assistants often don't

Coding-focused agents (like Codex or Claude Code, depending on your setup) are built for file-heavy implementation work:

  • exploring project structure
  • editing across multiple files
  • running tests/commands
  • iterating on failures

A general assistant can still coordinate the strategy, but coding agents often execute technical changes more efficiently.

::: power-user Use coding agents for implementation, but keep architectural decisions and final approval in the main assistant flow. :::

When to use single-agent vs multi-agent

Use single-agent when:

  • Task is short and self-contained
  • One output format is needed
  • No parallel work required
  • Context fits comfortably in one thread

Use multi-agent when:

  • Task has distinct sub-problems (research + code + writing)
  • You want parallel execution
  • The task is long-running or complex
  • One thread would become noisy or hard to review

A simple rule: if you can clearly split the work into specialist lanes, delegation likely helps.

How to trigger delegation

You usually don't need advanced syntax. Plain-language requests are enough when your setup supports it.

Examples:

💬 Send this to your AI assistant:

Use a coding agent for implementation and testing, then summarize changes for me in plain English.

💬 Send this to your AI assistant:

Split this into two tracks: one agent researches competitors, another drafts the one-page brief. Merge results.

💬 Send this to your AI assistant:

Delegate data cleanup to a specialist agent, then ask the writing agent to produce the final client update.

Your assistant can route and orchestrate if configured correctly.

::: tip Ask for a plan first: "Show me what you'll delegate before starting." This keeps you in control and improves trust. :::

Common mistakes to avoid

  1. Delegating everything by default Overhead can outweigh benefits for small tasks.

  2. Unclear handoffs If sub-agent roles are vague, output quality drops.

  3. No merge criteria Decide upfront what "done" looks like when results come back.

  4. Skipping review on sensitive tasks Delegation increases speed, not accountability. Human review still matters.

::: warning Multi-agent mode can produce more output, faster. That does not automatically mean better outcomes. Keep clear success criteria and review checkpoints. :::

Realistic end-to-end scenario: launch-week execution sprint

You're preparing a product update launch and need three things in one day:

  1. market context,
  2. update notes,
  3. website copy refresh.

Single-agent approach: one long thread, sequential work, frequent context resets.

Multi-agent approach:

  • Agent A (research): gathers latest competitor positioning and user sentiment themes
  • Agent B (writing): drafts announcement email + changelog summary
  • Agent C (implementation/coding): updates website release notes section and checks for formatting errors
  • Main assistant: merges outputs into one review packet with decisions needed from you

Outcome:

  • faster total turnaround
  • cleaner specialist outputs
  • one consolidated review step instead of scattered partial drafts

That's the point of multi-agent mode: not complexity for its own sake, but organized parallel execution when the workload justifies it.

::: action For your next large task, explicitly request delegation by role (research, implementation, writing). Compare completion time and quality against your usual single-agent workflow. :::

Self-check summary

  • Included all required headings exactly: ## Section 16: Practical Use Cases, ## Section 17: Mobile Nodes - Your Assistant in Your Pocket, and ## Section 18: Multi-Agent Mode - When One AI Isn't Enough.
  • Followed OUTLINE_v2 scope points: Section 16 includes all listed use cases with practical setup-time estimates; Section 17 covers pairing flow, capabilities unlocked, and why users miss it; Section 18 explains delegation/sub-agents and single-agent vs multi-agent decisions.
  • Kept tone warm, practical, secular, and non-patronizing for non-technical users.
  • Used only allowed callouts (beginner, warning, tip, power-user, action) and fenced code blocks for command-style examples.
  • Added one realistic end-to-end scenario per section and kept total length within target range (~2200-2800 words).