专栏定位：OpenClaw 从入门到精通（第 11 章）
适读人群：开发者、技术爱好者、AI应用创业者

摘要

当面对一个需要数小时才能完成的复杂任务时，单线程处理会让整个系统阻塞。OpenClaw 的 Subagent（子 Agent）机制允许你将复杂任务分解为多个并行的子任务，让多个 Agent 同时工作，大幅提升处理效率。本章将深入探讨 sessions_spawn（启动子任务）、sessions_send（跨会话通信）、sessions_list / sessions_history（会话追踪）的用法，以及如何设计任务分解策略（map-reduce、流水线）。学完本章，你将能够构建多线程并行内容创作、分布式数据处理等高级工作流。

SEO 摘要

OpenClaw Subagent 子 Agent 机制、sessions_spawn 会话管理、sessions_send 跨会话通信、sessions_list 会话追踪、map-reduce 任务分解策略。

目录

• 为什么需要 Subagent
• 会话管理核心 API
• sessions_spawn：启动子任务
• sessions_send：跨会话通信
• 任务分解策略
• 实战：多线程内容创作
• 常见错误与避坑指南
• 术语注释
• 面试高频问答
• 深度扩展
• 附录
• 系列总结（第 01-11 章）
• 版权声明

开篇

想象这样一个场景：你需要为一家公司生成一年的内容营销计划，包括 52 篇博客文章、100 条社交媒体帖子、12 个月度通讯。

如果用传统方式，一个一个生成，需要几十个小时。但如果你这样思考：

主 Agent（规划）
    ↓
┌─────────────────────────────────────────┐
│  子 Agent 1: 博客文章生成               │
│  子 Agent 2: 社交媒体帖子生成           │
│  子 Agent 3: 月度通讯生成               │
└─────────────────────────────────────────┘
    ↓
主 Agent（整合与审查）

三个子 Agent 同时工作，处理时间从几十小时缩短到几十分钟。这就是 Subagent 的威力。

核心知识点

1. 为什么需要 Subagent

1.1 单 Agent 的局限性

用户请求
    ↓
Agent 正在处理复杂任务（30 分钟）
    ↓
用户发送第二条消息
    ↓
??? 阻塞 or 排队 or 忽略 ???

单 Agent 的问题：

• 阻塞：当前任务没完成，无法响应新请求
• 上下文膨胀：多任务混合导致上下文污染
• 效率低下：一个任务等待 I/O 时，CPU 闲置

1.2 Subagent 的价值

主会话
    ↓ 用户请求
    ↓ 拆解任务
┌────────────────────────────────────────┐
│  子 Agent A：处理任务 1                 │
│  子 Agent B：处理任务 2                 │
│  子 Agent C：处理任务 3                 │
│  （并行执行，互不干扰）                  │
└────────────────────────────────────────┘
    ↓ 完成
主会话（整合结果，返回用户）

Subagent 的优势：

• 并行处理：多个任务同时执行
• 隔离性：每个子任务有独立上下文
• 可扩展：根据任务复杂度动态增减子 Agent

1.3 适用场景

场景	不用 Subagent	用 Subagent
生成 10 篇文章	串行，1 小时	并行，10 分钟
处理 100 个文件	逐个处理	分批并行
多语言翻译	逐语言等待	同时翻译
代码审查多个 PR	逐个审查	同时审查

2. 会话管理核心 API

OpenClaw 提供以下会话管理工具：

API	功能	返回值
sessions_spawn	启动新的子会话	session_id
sessions_send	向指定会话发送消息	response
sessions_list	列出所有会话	会话列表
sessions_history	获取会话历史	历史消息
sessions_yield	让出控制权	-
sessions_kill	终止会话	-

3. sessions_spawn：启动子任务

3.1 基本语法

sessions_spawn(
    prompt="任务描述",
    name="agent-name",           # 可选，会话名称
    model="anthropic/claude-3-5-sonnet",  # 可选，指定模型
    runtime="standard"           # 可选，standard 或 acp
)

返回：

{
  "session_id": "sess_abc123def456",
  "name": "blog-writer-1",
  "status": "running"
}

3.2 完整示例

# 启动一个子 Agent 生成博客文章
sessions_spawn(
    prompt="为一家 AI 创业公司写一篇关于 LLM 应用前景的博客文章。

要求：
- 字数：2000-3000 字
- 风格：专业但易懂，面向技术决策者
- 结构：引言、3-4 个核心观点、结论
- 包含具体案例和数据

输出格式：
# 文章标题

## 引言
...

## [核心观点 1]
...

## [核心观点 2]
...

...（以此类推）

## 结论
...
",
    name="blog-writer",
    model="qwen/qwen-plus",
    timeout=300000  # 5 分钟超时
)

3.3 spawn 参数详解

参数	类型	必填	说明
prompt	string	是	子 Agent 的任务描述
name	string	否	会话名称，便于追踪
model	string	否	指定使用的模型
timeout	number	否	超时时间（毫秒）
runtime	string	否	standard（默认）或 acp（ACP 协议）
context	object	否	传递给子 Agent 的额外上下文

3.4 等待子 Agent 完成

# 启动子 Agent
sessions_spawn(
    prompt="帮我写一篇博客文章",
    name="blog-writer",
    runtime="standard"
)
# 返回 session_id: "sess_abc123"

# 轮询等待完成
process(action="poll", sessionId="sess_abc123", timeout=300000)

# 获取结果
sessions_history(sessionId="sess_abc123")

4. sessions_send：跨会话通信

4.1 向子会话发送消息

# 向已存在的会话发送消息
sessions_send(
    sessionId="sess_abc123",
    message="请修改文章，语气更正式一些"
)

4.2 获取会话历史

# 获取指定会话的完整历史
sessions_history(sessionId="sess_abc123")

# 只获取最近的消息
sessions_history(sessionId="sess_abc123", limit=10)

4.3 列出所有会话

# 列出所有会话
sessions_list()

# 返回示例：
# [
#   {"session_id": "sess_main", "name": "main", "status": "active", "created": "..."},
#   {"session_id": "sess_abc123", "name": "blog-writer", "status": "running"},
#   {"session_id": "sess_def456", "name": "social-post", "status": "completed"}
# ]

4.4 终止会话

# 终止一个正在运行的会话
sessions_kill(sessionId="sess_abc123")

5. 任务分解策略

5.1 Map-Reduce 模式

Map 阶段：将大任务分解为多个小任务，并行处理：

# 主 Agent
"""
用户要求：为我们的产品生成多语言描述（中文、英文、日文、韩文）

将任务分解为三个子任务：
1. 中文描述生成
2. 英文描述生成
3. 日韩文描述生成

并行启动三个子 Agent。
"""

# 启动三个子 Agent
session_zh = sessions_spawn(
    prompt="生成产品的中文描述...",
    name="desc-zh"
)

session_en = sessions_spawn(
    prompt="Generate product description in English...",
    name="desc-en"
)

session_jp = sessions_spawn(
    prompt="产品的日本語説明文を生成...",
    name="desc-jp"
)

# 等待所有完成
# ... (polling)

# Reduce 阶段：整合结果
"""
整合三个子 Agent 的输出，生成最终的多语言产品描述文档。
"""

完整示例：

# 主 Agent 执行
sessions_spawn(
    prompt="
你是一个内容创作团队的主编。

任务：为一篇关于「远程办公效率提升」的文章生成 5 个社交媒体帖子。

请按以下步骤执行：

1. 首先理解文章的核心观点（主要讨论异步沟通、工具选择、工作节奏）

2. 然后启动 5 个并行的子 Agent，每个生成一个帖子：
   - 子 Agent 1：Twitter/X 帖子（140-280字）
   - 子 Agent 2：LinkedIn 帖子（专业风格）
   - 子 Agent 3：微博帖子（轻松风格）
   - 子 Agent 4：微信公众号摘要（简短有力）
   - 子 Agent 5：知乎回答风格的帖子（深度分析）

3. 每个子 Agent 使用 sessions_spawn 启动

4. 等待所有子 Agent 完成后，整合结果

输出格式：
## 帖子 1：Twitter/X
[内容]

---

## 帖子 2：LinkedIn
[内容]

...（以此类推）
"
)

5.2 流水线模式

流水线模式：每个子 Agent 的输出是下一个子 Agent 的输入：

任务 A → 子 Agent 1 → 输出 A
                      ↓
任务 B → 子 Agent 2 → 输出 B
                      ↓
任务 C → 子 Agent 3 → 输出 C

# Step 1: 子 Agent 1 - 研究阶段
session1 = sessions_spawn(
    prompt="研究 AI 在教育行业的最新应用趋势，输出 5 个关键发现...",
    name="research"
)
# 等待完成，获取结果

# Step 2: 子 Agent 2 - 写作阶段
session2 = sessions_spawn(
    prompt="基于以下研究结果，写一篇博客文章...\n\n[研究结果：{session1_result}]",
    name="writer"
)
# 等待完成，获取结果

# Step 3: 子 Agent 3 - 审查阶段
session3 = sessions_spawn(
    prompt="审查以下文章，给出修改建议...\n\n[文章内容：{session2_result}]",
    name="reviewer"
)

5.3 树形分解模式

树形模式：一个任务分解为多个子任务，子任务再分解：

           主 Agent
              ↓
    ┌─────────┴─────────┐
    ↓                   ↓
子 Agent A              子 Agent B
    ↓                   ↓
┌───┴───┐           ┌───┴───┐
↓       ↓           ↓       ↓
A1     A2          B1      B2

# 主 Agent
"""
用户要求：为一个软件开发项目创建完整的技术文档。

分解任务：
1. 架构文档（子 Agent A）
   - 系统概览（A1）
   - 模块设计（A2）
2. API 文档（子 Agent B）
   - 认证 API（B1）
   - 数据 API（B2）

先生成架构文档和 API 文档的子任务，
完成后进行整合和格式化。
"""

# 启动第一层
session_arch = sessions_spawn(prompt="生成架构文档...", name="arch")
session_api = sessions_spawn(prompt="生成 API 文档...", name="api")

# 等待完成...

# 整合
"""
整合架构文档和 API 文档，生成完整的技术文档包。
"""

6. 实战：多线程内容创作

6.1 需求

为一个科技博客生成以下内容（并行）：

• 1 篇深度长文（3000 字）
• 3 篇短文（各 800 字）
• 5 条社交媒体帖子

6.2 完整代码

# 主 Agent 发起任务
sessions_spawn(
    prompt="
你是内容创作团队的负责人。用户的任务是：为一篇关于「AI Agent 如何改变工作方式」的文章生成内容矩阵。

请执行以下步骤：

## Step 1: 规划内容结构

基于主题，规划：
- 1 篇深度长文的核心观点和结构
- 3 篇短文的切入角度
- 5 条社交媒体帖子的核心信息点

## Step 2: 并行生成内容

启动 9 个子 Agent 同时工作：

【长文生成】× 1
- 子 Agent L1：生成 3000 字的深度长文

【短文生成】× 3
- 子 Agent S1：短文 1 - AI Agent 概念解释
- 子 Agent S2：短文 2 - 具体应用案例
- 子 Agent S3：短文 3 - 未来趋势展望

【社交帖子生成】× 5
- 子 Agent P1：Twitter 帖子
- 子 Agent P2：LinkedIn 帖子
- 子 Agent P3：微博帖子
- 子 Agent P4：微信公众号摘要
- 子 Agent P5：知乎回答

## Step 3: 整合输出

所有子 Agent 完成后，按照以下格式整合：

# 【长文】
[内容]

# 【短文 1】
[标题]
[内容]

# 【短文 2】
...

# 【社交媒体矩阵】
## Twitter
[帖子内容]

## LinkedIn
[帖子内容]

...（以此类推）

---

提示：使用 sessions_spawn 启动每个子 Agent，
每个子 Agent 使用 runtime='standard'。
",
    name="content-creator",
    timeout=600000
)

6.3 进阶：监控进度

# 主 Agent 启动多个子 Agent

# 定期检查子 Agent 状态
sessions_list()
# 返回：
# [
#   {session_id: "sess_L1", name: "long-form", status: "completed"},
#   {session_id: "sess_S1", name: "short-1", status: "completed"},
#   {session_id: "sess_S2", name: "short-2", status: "running"},
#   ...
# ]

# 查看已完成的内容
sessions_history(sessionId="sess_L1")
sessions_history(sessionId="sess_S1")

# 向正在运行的子 Agent 发送消息
sessions_send(
    sessionId="sess_S2",
    message="请注意，字数控制在 800 字以内"
)

6.4 结果整合

# 整合所有子 Agent 的输出

# 获取所有已完成会话的结果
long_form = sessions_history(sessionId="sess_L1")
short_1 = sessions_history(sessionId="sess_S1")
short_2 = sessions_history(sessionId="sess_S2")
short_3 = sessions_history(sessionId="sess_S3")
posts = [
    sessions_history(sessionId="sess_P1"),
    sessions_history(sessionId="sess_P2"),
    sessions_history(sessionId="sess_P3"),
    sessions_history(sessionId="sess_P4"),
    sessions_history(sessionId="sess_P5")
]

# 主 Agent 生成最终整合输出
整合提示 = f"""
请将以下内容整合成一份完整的内容创作输出：

【长文】{long_form}
【短文 1】{short_1}
【短文 2】{short_2}
【短文 3】{short_3}
【社交帖子】{posts}

格式要求：
- 清晰的层次结构
- 每个内容块有标题标注
- 检查内容一致性
- 如有重复或矛盾，进行调和
"""

7. 常见错误与避坑指南

错误 1：子 Agent 启动后没有获取结果

症状： sessions_spawn 返回了 session_id，但之后无法获取结果

原因： 会话可能在后台运行，需要用 process 或 polling 获取

解决：

# 启动时指定等待模式
sessions_spawn(
    prompt="...",
    yieldMs=30000  # 30 秒后自动返回 session_id
)

# 或使用 process 轮询
process(action="poll", sessionId="sess_xxx", timeout=300000)

错误 2：子 Agent 之间的上下文不共享

症状： 子 Agent 1 的输出无法直接传给子 Agent 2

原因： 默认情况下，每个子 Agent 有独立的上下文

解决：

# 方式一：主 Agent 获取结果后传给下一个子 Agent
result1 = sessions_history(sessionId="sess_1")
sessions_spawn(
    prompt=f"基于以下内容继续工作：\n{result1}",
    name="continuation"
)

# 方式二：使用 context 参数传递
sessions_spawn(
    prompt="继续上一步的工作",
    context={"previous_result": "..."}
)

错误 3：太多子 Agent 导致资源耗尽

症状： 启动大量子 Agent 后，系统变慢或崩溃

原因： 每个子 Agent 都会消耗内存和 API 调用配额

解决：

# 限制并发数量
MAX_CONCURRENT = 5

# 分批启动
for i in range(10):
    if current_running >= MAX_CONCURRENT:
        wait_for_completion()
    spawn_agent(task[i])

错误 4：子 Agent 超时没有处理

症状： 子 Agent 超时中断，内容丢失

解决：

# 设置合理的超时时间
sessions_spawn(
    prompt="...",
    timeout=600000  # 10 分钟超时
)

# 实现重试机制
def spawn_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            result = sessions_spawn(prompt=prompt, timeout=300000)
            return result
        except TimeoutError:
            if attempt == max_retries - 1:
                raise
            continue

错误 5：忘记终止已完成但仍在运行的会话

症状： 会话列表越来越长，资源浪费

解决：

# 完成后主动终止
sessions_kill(sessionId="sess_xxx")

# 或者定期清理
sessions_list()  # 查看所有会话
for session in sessions_list():
    if session.status == "completed":
        sessions_kill(session.session_id)

术语注释

术语	英文	解释
Subagent	子 Agent	从主 Agent 派生的独立工作单元
Session	会话	一次完整的对话上下文
sessions_spawn	启动子会话	创建新的子 Agent 会话
sessions_send	发送消息	向指定会话发送消息
Map-Reduce	映射归约	分解-并行-整合的任务处理模式
Pipeline	流水线	串联多个处理阶段的任务模式
Yield	让出控制	交出执行权，等待结果返回

面试高频问答

Q1：Subagent 和普通的函数调用有什么区别？

回答：本质区别在于自主性和上下文隔离。普通函数调用是同步的，你调用它，它执行，返回结果，整个过程在同一个上下文中。Subagent 是一个独立的 Agent，有自己完整的上下文、可以多轮交互、可以使用工具、超时机制等。你可以把它想象成雇佣了一个独立的小助手，而不是调用了一个函数。另一个关键区别是并行性：多个 Subagent 可以同时运行，互不干扰，而普通函数调用通常是串行的。

Q2：如何设计一个好的任务分解策略？

回答：好的任务分解要考虑三个因素。第一，独立性：分解出来的子任务尽可能互相独立，这样才真正能并行执行。第二，粒度适中：子任务太大（比如 10 小时的工作）无法有效并行；太小（比如 1 分钟的工作）则管理开销太大。第三，错误隔离：一个子任务失败不应该导致整体失败。实际建议：从「能不能同时做」的角度思考分解，如果两个任务需要同一个资源或依赖同一个输出，就不适合分解。

Q3：Subagent 适合什么场景，不适合什么场景？

回答：适合的场景包括：多语言内容并行生成（翻译、帖子）；多个独立数据源的并行采集；代码库中多个模块的并行分析；需要不同专家视角同时处理的任务。不适合的场景包括：任务之间有强依赖（必须先 A 才能 B）；简单的一次性任务（直接做比启动 Subagent 更高效）；资源受限的环境（每个 Agent 都有内存和 API 成本）。

深度扩展

深度 1：Subagent 与 Cron 的结合

Subagent 可以与 Cron 结合，实现定时并行任务：

# Cron 触发后启动多个 Subagent
openclaw cron add "0 9 * * *" \
    --name "每日市场报告" \
    --prompt "
今天是周一，请生成本周市场报告。

启动 4 个 Subagent 并行采集数据：
1. Subagent A：采集宏观经济数据
2. Subagent B：采集行业动态
3. Subagent C：采集竞争对手信息
4. Subagent D：采集客户反馈

所有数据采集完成后，
整合成一份完整的市场报告，
发送到飞书群。
"

深度 2：多 Agent 协作框架

更复杂的多 Agent 场景，可以使用主从架构：

┌─────────────────────────────────────────────────────┐
│                    Orchestrator                       │
│                  (主编 Agent)                         │
│  - 理解用户需求                                       │
│  - 分解任务                                           │
│  - 分配给 Specialized Agents                          │
│  - 整合结果                                           │
└─────────────────────────────────────────────────────┘
                          │
        ┌─────────────────┼─────────────────┐
        ↓                 ↓                 ↓
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ Specialized   │ │ Specialized   │ │ Specialized   │
│ Agent A      │ │ Agent B       │ │ Agent C       │
│ (技术专家)    │ │ (市场专家)    │ │ (运营专家)    │
└───────────────┘ └───────────────┘ └───────────────┘

深度 3：Agent 间的通信协议

Subagent 之间可以直接通信（不通过主 Agent）：

# Agent A 发现需要 Agent B 的数据，直接请求
sessions_send(
    sessionId="sess_agent_B",
    message="我需要 X 数据，请提供"
)

# Agent B 处理请求
# ...

# Agent B 返回结果给 Agent A
sessions_send(
    sessionId="sess_agent_A",
    message="X 数据如下：..."
)

附录

A.1 sessions API 速查

API	用途	示例
sessions_spawn	启动新会话	sessions_spawn(prompt="...")
sessions_send	发送消息	sessions_send(sessionId="...", message="...")
sessions_list	列出所有会话	sessions_list()
sessions_history	获取历史	sessions_history(sessionId="...")
sessions_kill	终止会话	sessions_kill(sessionId="...")

A.2 会话状态

状态	说明
active	正在运行
completed	已完成
failed	执行失败
timeout	超时
cancelled	被取消

A.3 任务分解模板

## 任务分解模板

### 输入
[原始任务描述]

### 分解方案
1. 子任务 1：[描述] → [子 Agent 名称]
2. 子任务 2：[描述] → [子 Agent 名称]
3. 子任务 3：[描述] → [子 Agent 名称]

### 依赖关系
- 子任务 1 和 2 可并行
- 子任务 3 依赖 1 和 2 的结果

### 整合逻辑
[如何将子任务结果合并]

系列总结（第 01-11 章）

通过前十章（加上本章）的学习，我们已经全面掌握了 OpenClaw 的核心能力：

第 01-10 章： 基础认知、配置体系、人格设计、记忆系统、Skills 架构、核心工具集、编程 Agent、多模型路由、飞书集成、定时任务
第 11 章： Subagent 与会话管理，复杂任务分解执行

现在你已经能够构建复杂的多 Agent 工作流。接下来两章我们将学习安全与权限（生产环境部署指南）以及自定义 Skill 开发。读完这两章，你将能够在生产环境中安全地部署 OpenClaw，并开发自己的 Skills。

版权声明

本文为原创技术实践文章，禁止未经授权的全文转载；引用请注明出处与本文链接。