OpenClaw broke multi-agent work down into three modes: standalone agents, subagents, and ACP

OpenClaw presented a multi-agent model not as an abstract idea, but as a set of working modes for real tasks in Telegram. A user can manage one main agent and then distribute roles to permanent executors, temporary subagents, and external development tools via ACP.

Three operating modes

The OpenClaw scheme is based on three different ways to delegate. The first—separate permanent agents with their own working folder, memory, and instructions. The second—subagents that the main agent launches for a specific one-time task and provides only the necessary context. The third—ACP, that is, a mode where engineering work is performed not by OpenClaw itself, but by a connected external tool like Codex, Claude Code, or Gemini CLI. The result is not one universal assistant, but a dispatcher that can select the appropriate execution level for the type of work.

• Permanent agent—for a role that is needed regularly
• Subagent—for one-time research or part of a large task
• ACP—for development tasks in an external environment
• Main agent—for routing, control, and result compilation

"Multi-agent functionality in

OpenClaw is not one button, but several operating modes for agents."

When each is needed

Separate agents in this model are useful where a task repeats and accumulates its own context. The article provides simple examples: an agent for research, an agent for rewriting, an agent for publishing. Each can live in its own working folder, remember previous actions, and receive tasks both directly and through the main agent. This approach reduces chaos: instead of one long conversation with mixed assignments, there emerges a system of roles where each executor has their own area of responsibility and their own accumulated memory.

Subagents solve a different problem—how to quickly extract one-time or parallel work from the main flow. If you need to briefly study a topic, gather several conclusions, or break a large task into independent pieces, the main agent can launch child runs and then consolidate the answers into a single summary. This is especially useful for research and preliminary analysis. In this mode, you don't need to create a new permanent participant in advance: a subagent appears for the task, receives limited context, and disappears after completion, without overloading the general system with unnecessary memory.

For development, OpenClaw offers a separate route via ACP. Here the main agent remains the entry point and orchestrator, but the code itself is written by an external tool. The article describes three scenarios: a one-time ACP session for a single engineering task, a permanent ACP session for a long-term project, and binding ACP context to a separate Telegram topic, where the technical discussion line exists separately from the main chat. This mode is needed when a project requires long context, sequential iterations, and the advantages of specialized CLI tools.

Telegram as a control panel

The author places particular emphasis on Telegram as a natural interface for such an architecture. A permanent agent can be bound to a separate bot or to the current topic, and the technical ACP context—to a dedicated branch in the chat. As a result, roles and work lines don't mix: research happens in one place, development—in another, while the main agent remains the central entry point for task assignment. For the user, this looks not like complex infrastructure, but like an understandable map of dialogues with different types of executors.

From this follows the main OpenClaw scenario: the main agent stops being just an interlocutor and becomes a system coordinator. It can send research to a separate agent, a one-time subtask—to a subagent, the engineering part—to ACP via Codex, and then return one compiled answer. That is, the user manages not every action manually, but the logic of work distribution. This is precisely what the practical value of multi-agent functionality consists of: less micromanagement, more managed specialization and parallel work.

What this means

OpenClaw effectively offers not a "magical AI agent," but an operational model for teams and solo developers who want to distribute roles, context, and tools across different channels. If this approach takes root, Telegram chats with agents will increasingly resemble both a lightweight IDE and a dispatch center simultaneously: one entry point, several executors, and cleaner separation between research, content, and code.