OpenClaw Subagent 深度实践

七夜zippoe2026-05-04 8:57

目录

    • 摘要
    • [1. 引言 - Subagent 的应用场景](#1. 引言 - Subagent 的应用场景)
      • [1.1 为什么需要子智能体？](#1.1 为什么需要子智能体？)
      • [1.2 典型应用场景](#1.2 典型应用场景)
      • [1.3 OpenClaw Subagent 核心特性](#1.3 OpenClaw Subagent 核心特性)
    • [2. Subagent 架构详解](#2. Subagent 架构详解)
      • [2.1 整体架构](#2.1 整体架构)
      • [2.2 会话隔离机制](#2.2 会话隔离机制)
      • [2.3 运行时环境](#2.3 运行时环境)
      • [2.4 上下文注入规则](#2.4 上下文注入规则)
    • [3. sessions_spawn 详解](#3. sessions_spawn 详解)
      • [3.1 核心参数](#3.1 核心参数)
      • [3.2 启动模式详解](#3.2 启动模式详解)
        • [3.2.1 基本启动](#3.2.1 基本启动)
        • [3.2.2 指定模型](#3.2.2 指定模型)
        • [3.2.3 超时控制](#3.2.3 超时控制)
      • [3.3 返回值解析](#3.3 返回值解析)
      • [3.4 超时处理机制](#3.4 超时处理机制)
    • [4. Subagent 编排](#4. Subagent 编排)
      • [4.1 并行执行模式](#4.1 并行执行模式)
      • [4.2 串行执行模式](#4.2 串行执行模式)
      • [4.3 条件执行模式](#4.3 条件执行模式)
      • [4.4 编排模式对比](#4.4 编排模式对比)
    • [5. 通信机制](#5. 通信机制)
      • [5.1 通告机制详解](#5.1 通告机制详解)
      • [5.2 sessions_send 发送消息](#5.2 sessions_send 发送消息)
      • [5.3 steer 引导运行](#5.3 steer 引导运行)
      • [5.4 kill 终止运行](#5.4 kill 终止运行)
      • [5.5 通信机制对比表](#5.5 通信机制对比表)
    • [6. 实战案例 - 多任务并行处理](#6. 实战案例 - 多任务并行处理)
      • [6.1 场景描述](#6.1 场景描述)
      • [6.2 完整实现代码](#6.2 完整实现代码)
      • [6.3 执行流程图](#6.3 执行流程图)
    • [7. 性能优化与资源管理](#7. 性能优化与资源管理)
      • [7.1 并发控制](#7.1 并发控制)
      • [7.2 模型选择策略](#7.2 模型选择策略)
      • [7.3 超时设置最佳实践](#7.3 超时设置最佳实践)
      • [7.4 自动归档配置](#7.4 自动归档配置)
      • [7.5 资源监控](#7.5 资源监控)
    • [8. 工具策略与安全配置](#8. 工具策略与安全配置)
      • [8.1 子智能体工具限制](#8.1 子智能体工具限制)
      • [8.2 安全配置示例](#8.2 安全配置示例)
      • [8.3 工具策略优先级](#8.3 工具策略优先级)
    • [9. 总结](#9. 总结)
    • [10. 参考资料](#10. 参考资料)

摘要

在现代 AI 智能体架构中，子智能体（Subagent）是实现并行处理、任务隔离和资源优化的重要机制。OpenClaw 提供了一套完整的子智能体系统，支持从主智能体会话中生成独立的后台运行实例，并通过通告机制将结果异步返回给请求者。本文深入探讨 OpenClaw Subagent 的核心架构、运行时机制、通信模式以及实战应用场景。通过详细的参数解析、架构图示和代码示例，读者将掌握如何高效地编排多个子智能体，实现复杂任务的并行处理，以及如何通过合理的超时设置和资源管理来保障系统稳定性。🚀

1. 引言 - Subagent 的应用场景

1.1 为什么需要子智能体？

在传统的单智能体架构中，所有任务都在同一个会话中顺序执行。这种模式在面对以下场景时会遇到瓶颈：

  • 长时间运行的任务：如大规模数据分析、文件处理、网络爬取等，会阻塞主会话
  • 并行处理需求：同时处理多个独立任务，提高整体效率
  • 任务隔离：某些任务需要独立的上下文或安全边界
  • 资源优化：为不同任务分配不同模型，平衡成本与质量

子智能体正是为解决这些问题而设计的。它允许主智能体将任务"委托"给独立的后台运行实例，自己则继续处理其他工作。

1.2 典型应用场景

场景 描述 优势
🔍 后台研究 主智能体继续对话，子智能体搜索资料 不阻塞用户体验
📊 批量处理 并行处理多个文件或数据集 提高吞吐量
🔐 安全隔离 敏感操作在沙箱中运行 降低风险
💰 成本优化 简单任务使用便宜模型 降低运营成本
⏰ 定时任务 周期性检查和通知 自动化运维

1.3 OpenClaw Subagent 核心特性

OpenClaw Subagent
核心特性
异步执行
会话隔离
结果通告
工具策略控制
运行模式
并行执行
串行编排
条件触发
通信机制
sessions_spawn
sessions_send
steer
kill
资源管理
超时控制
并发限制
自动归档

2. Subagent 架构详解

2.1 整体架构

OpenClaw Subagent 的架构设计遵循"隔离优先、通信可控"的原则。每个子智能体都在独立的会话中运行，拥有自己的上下文和工具集。
subagent 队列
子智能体池
Gateway 网关
主智能体 (Main Agent)
用户请求
任务分解
结果聚合
会话管理
工具策略
队列调度
子智能体 A
子智能体 B
子智能体 C
任务队列
并发控制

2.2 会话隔离机制

每个子智能体都有唯一的会话标识符，格式为：

复制代码 
agent:<agentId>:subagent:<uuid>

例如：agent:main:subagent:06d744ad-38d7-4cb3-89c0-c4e3fe69415d

这种命名方式确保了：

  1. 会话独立性：每个子智能体拥有独立的对话历史和上下文
  2. 追溯能力：可以通过会话键追踪子智能体的完整生命周期
  3. 权限隔离：认证配置按智能体 ID 加载，而非会话类型

2.3 运行时环境

子智能体的运行时环境由以下组件构成：

组件 说明 配置位置
上下文注入 仅加载 AGENTS.md + TOOLS.md 系统默认
工具策略 默认排除会话工具 tools.subagents.tools
模型配置 继承或独立配置 agents.defaults.subagents.model
沙箱隔离 可选的 Docker 容器隔离 agents.list[].sandbox

2.4 上下文注入规则

与主智能体不同，子智能体的上下文注入有特殊限制：
注入
注入
子智能体上下文
AGENTS.md
TOOLS.md
主智能体上下文
AGENTS.md
SOUL.md
IDENTITY.md
USER.md
HEARTBEAT.md
TOOLS.md
主智能体
子智能体

这种设计确保子智能体保持轻量级，同时具备基本的工作空间认知。

3. sessions_spawn 详解

sessions_spawn 是启动子智能体的核心工具。理解其参数和配置选项是高效使用子智能体的关键。

3.1 核心参数

参数 类型 必需 默认值 说明
task string ✅ - 子智能体要执行的任务描述
label string ❌ - 可读标签，用于日志和调试
agentId string ❌ 请求者ID 目标智能体 ID
model string ❌ 继承 覆盖子智能体使用的模型
thinking string ❌ 继承 覆盖思考级别
runTimeoutSeconds number ❌ 0 运行超时（秒），0 表示不限制
cleanup string ❌ keep 完成后的清理策略

3.2 启动模式详解

3.2.1 基本启动

最简单的启动方式，子智能体继承主智能体的所有默认配置：

json 复制代码 
{
  "task": "分析 /data/logs 目录下的所有日志文件，统计错误类型和频率"
}
3.2.2 指定模型

为子智能体指定不同的模型，实现成本优化：

json 复制代码 
{
  "task": "翻译 /docs/manual.pdf 的内容为中文",
  "model": "gpt-4o-mini",
  "label": "文档翻译任务"
}
3.2.3 超时控制

设置运行超时，防止任务无限期运行：

json 复制代码 
{
  "task": "从 API 获取实时数据并生成报告",
  "runTimeoutSeconds": 300,
  "label": "API 数据获取"
}

3.3 返回值解析

sessions_spawn 立即返回一个状态对象：

json 复制代码 
{
  "status": "accepted",
  "runId": "run_abc123",
  "childSessionKey": "agent:main:subagent:06d744ad-38d7-4cb3-89c0-c4e3fe69415d"
}
字段 说明
status 始终为 "accepted"，表示任务已入队
runId 运行标识符，用于后续管理操作
childSessionKey 子智能体的会话键

3.4 超时处理机制

超时计时器 子智能体 Gateway 主智能体 超时计时器 子智能体 Gateway 主智能体 alt [正常完成] [超时触发] sessions_spawn (runTimeoutSeconds=60) 启动子智能体 设置超时计时器 任务完成 通告结果 超时信号 中止运行 通告超时状态

重要说明：

  • runTimeoutSeconds 仅停止运行，不会自动归档会话
  • 会话保留直到自动归档时间到达（默认 60 分钟）
  • 使用 cleanup: "delete" 可在完成后立即归档

4. Subagent 编排

4.1 并行执行模式

并行执行是子智能体最常见的使用模式，适用于多个独立任务同时处理的场景。
结果通告
并行执行
并行启动
输入任务
任务 A
任务 B
任务 C
sessions_spawn A
sessions_spawn B
sessions_spawn C
子智能体 A
子智能体 B
子智能体 C
结果 A
结果 B
结果 C

并行执行示例代码：

python 复制代码 
# 并行启动多个子智能体处理不同数据源
import json

# 定义并行任务
parallel_tasks = [
    {
        "task": "分析 MySQL 数据库中的用户行为数据，生成用户画像报告",
        "label": "MySQL 分析",
        "model": "gpt-4o-mini"
    },
    {
        "task": "处理 Redis 缓存中的热点数据，识别访问模式",
        "label": "Redis 分析",
        "model": "gpt-4o-mini"
    },
    {
        "task": "解析 Elasticsearch 日志，统计 API 调用频率",
        "label": "ES 日志分析",
        "model": "gpt-4o-mini"
    }
]

# 并行启动所有任务
results = []
for task_config in parallel_tasks:
    result = sessions_spawn(**task_config)
    results.append(result)
    print(f"已启动任务: {task_config['label']}, runId: {result['runId']}")

# 结果将通过通告机制异步返回

上述代码展示了如何并行启动三个子智能体，分别处理 MySQL、Redis 和 Elasticsearch 数据。每个任务使用较便宜的 gpt-4o-mini 模型，降低成本。主智能体无需等待，结果会通过通告机制异步返回。

4.2 串行执行模式

当任务之间存在依赖关系时，需要采用串行执行模式。
成功
失败
任务 1: 数据采集
检查结果
任务 2: 数据清洗
错误处理
任务 3: 数据分析
任务 4: 报告生成

串行执行示例代码：

python 复制代码 
# 串行执行：数据采集 -> 清洗 -> 分析 -> 报告
import time

def run_pipeline():
    """执行数据处理管道"""
    
    # 阶段 1: 数据采集
    spawn_result = sessions_spawn(
        task="从 API 端点采集最近 24 小时的交易数据",
        label="数据采集",
        runTimeoutSeconds=600
    )
    
    # 等待结果通告（实际实现中通过回调处理）
    # 这里展示概念性代码
    collection_result = wait_for_announcement(spawn_result['runId'])
    
    if collection_result['status'] != 'success':
        return handle_error(collection_result)
    
    # 阶段 2: 数据清洗
    spawn_result = sessions_spawn(
        task=f"清洗采集的数据，移除重复项和无效记录。数据路径: {collection_result['data_path']}",
        label="数据清洗",
        runTimeoutSeconds=300
    )
    
    # 继续后续阶段...

这段代码展示了串行管道的概念。实际实现中，主智能体通过通告机制接收每个阶段的结果，然后决定是否启动下一阶段。

4.3 条件执行模式

条件执行允许根据运行时状态动态决定任务流程。
小于 1GB
1GB-10GB
大于 10GB
开始
数据量检查
轻量处理模式
标准处理模式
分布式处理模式
结果合并
结束

4.4 编排模式对比

模式 适用场景 优势 劣势
并行 独立任务、批量处理 高吞吐量、响应快 资源消耗大
串行 有依赖的任务链 逻辑清晰、易调试 总耗时长
条件 动态决策场景 灵活适应、资源优化 实现复杂

5. 通信机制

5.1 通告机制详解

子智能体通过"通告步骤"将结果返回给请求者。这是 OpenClaw Subagent 的核心通信机制。
请求者渠道 子智能体 subagent 队列 主智能体 请求者渠道 子智能体 subagent 队列 主智能体 执行任务... alt [正常完成] [跳过通告] sessions_spawn(task) 启动子智能体 通告步骤 发布通告消息 接收结果 返回 ANNOUNCE_SKIP

通告消息格式：

复制代码 
Status: success | error | timeout | unknown
Result: [任务结果摘要]
Notes: [错误详情或其他上下文]

---
runtime: 5m12s
tokens: 15000/8000/23000
cost: $0.12
sessionKey: agent:main:subagent:xxx
sessionId: session_yyy
transcript: /path/to/transcript.json

5.2 sessions_send 发送消息

使用 sessions_send 可以向正在运行的子智能体发送消息：

python 复制代码 
# 向子智能体发送指导消息
sessions_send(
    sessionKey="agent:main:subagent:06d744ad-38d7-4cb3-89c0-c4e3fe69415d",
    message="请优先处理错误日志，忽略调试级别的日志"
)

5.3 steer 引导运行

steer 操作允许主智能体动态调整子智能体的行为方向：

python 复制代码 
# 引导子智能体调整方向
subagents_steer(
    target="run_abc123",
    message="发现数据源 A 不可用，请切换到数据源 B 继续处理"
)

5.4 kill 终止运行

当需要立即停止子智能体时，使用 kill 操作：

python 复制代码 
# 终止特定子智能体
subagents_kill(target="run_abc123")

# 终止所有子智能体
subagents_kill(target="all")

5.5 通信机制对比表

操作 工具 用途 典型场景
启动 sessions_spawn 创建新子智能体 任务委托
发送 sessions_send 发送消息 补充指令
引导 subagents steer 调整方向 动态调整
终止 subagents kill 停止运行 取消任务
查询 subagents list 查看状态 监控管理

6. 实战案例 - 多任务并行处理

6.1 场景描述

假设我们需要为一个技术博客平台生成每周内容报告，需要：

  1. 分析过去一周的文章阅读数据
  2. 统计用户评论情感倾向
  3. 生成热门话题排行榜
  4. 创建作者贡献度报告

这四个任务相互独立，非常适合并行处理。

6.2 完整实现代码

python 复制代码 
"""
OpenClaw Subagent 多任务并行处理示例
场景：生成每周内容报告
"""

import json
from datetime import datetime, timedelta

class WeeklyReportOrchestrator:
    """周报编排器 - 协调多个子智能体并行处理"""
    
    def __init__(self):
        self.active_subagents = []
        self.results = {}
    
    def spawn_analysis_tasks(self, week_start: str, week_end: str):
        """并行启动所有分析任务"""
        
        # 定义四个并行任务
        tasks = [
            {
                "task": f"""分析 {week_start} 至 {week_end} 期间的文章阅读数据：
                    1. 统计总阅读量、独立访客数
                    2. 识别阅读量 Top 10 文章
                    3. 分析阅读时段分布
                    4. 计算平均阅读时长
                    
                    数据源：/data/articles/
                    输出格式：JSON 报告""",
                "label": "阅读数据分析",
                "model": "gpt-4o-mini",
                "runTimeoutSeconds": 600
            },
            {
                "task": f"""分析 {week_start} 至 {week_end} 期间的用户评论：
                    1. 统计评论总数和活跃用户数
                    2. 进行情感分析（正面/负面/中性）
                    3. 识别高频关键词
                    4. 标记需要关注的负面评论
                    
                    数据源：/data/comments/
                    输出格式：JSON 报告""",
                "label": "评论情感分析",
                "model": "gpt-4o-mini",
                "runTimeoutSeconds": 600
            },
            {
                "task": f"""生成 {week_start} 至 {week_end} 的热门话题排行榜：
                    1. 从文章标题和标签提取话题
                    2. 按热度评分排序（阅读量×0.4 + 评论数×0.3 + 分享数×0.3）
                    3. 识别新兴话题（增长率 > 50%）
                    4. 生成话题趋势图数据
                    
                    数据源：/data/articles/, /data/tags/
                    输出格式：JSON 报告""",
                "label": "热门话题排行",
                "model": "gpt-4o-mini",
                "runTimeoutSeconds": 600
            },
            {
                "task": f"""创建 {week_start} 至 {week_end} 的作者贡献度报告：
                    1. 统计每位作者的发文数量
                    2. 计算作者文章的平均阅读量
                    3. 识别新晋作者（首次发文）
                    4. 生成作者活跃度排名
                    
                    数据源：/data/authors/, /data/articles/
                    输出格式：JSON 报告""",
                "label": "作者贡献报告",
                "model": "gpt-4o-mini",
                "runTimeoutSeconds": 600
            }
        ]
        
        # 并行启动所有任务
        for task in tasks:
            result = sessions_spawn(
                task=task["task"],
                label=task["label"],
                model=task.get("model"),
                runTimeoutSeconds=task.get("runTimeoutSeconds", 0)
            )
            self.active_subagents.append({
                "runId": result["runId"],
                "label": task["label"],
                "sessionKey": result["childSessionKey"],
                "startTime": datetime.now()
            })
            print(f"✅ 已启动: {task['label']} (runId: {result['runId']})")
        
        return self.active_subagents
    
    def handle_announcement(self, runId: str, result: dict):
        """处理子智能体的结果通告"""
        # 查找对应的任务
        subagent = next(
            (s for s in self.active_subagents if s["runId"] == runId),
            None
        )
        
        if subagent:
            self.results[subagent["label"]] = {
                "status": result.get("status"),
                "data": result.get("result"),
                "runtime": result.get("runtime"),
                "tokens": result.get("tokens")
            }
            print(f"📥 收到结果: {subagent['label']} - {result.get('status')}")
        
        # 检查是否所有任务都已完成
        if len(self.results) == len(self.active_subagents):
            self.generate_final_report()
    
    def generate_final_report(self):
        """聚合所有结果，生成最终报告"""
        report = {
            "generated_at": datetime.now().isoformat(),
            "sections": self.results
        }
        
        # 保存报告
        report_path = f"/reports/weekly_{datetime.now().strftime('%Y%m%d')}.json"
        write(report_path, json.dumps(report, indent=2, ensure_ascii=False))
        print(f"📊 最终报告已生成: {report_path}")


# 使用示例
if __name__ == "__main__":
    orchestrator = WeeklyReportOrchestrator()
    
    # 计算上周日期范围
    today = datetime.now()
    week_start = (today - timedelta(days=7)).strftime("%Y-%m-%d")
    week_end = today.strftime("%Y-%m-%d")
    
    # 启动并行分析
    orchestrator.spawn_analysis_tasks(week_start, week_end)

上述代码实现了一个完整的周报生成系统。WeeklyReportOrchestrator 类封装了任务编排逻辑，通过 spawn_analysis_tasks 方法并行启动四个子智能体，每个负责不同的分析任务。handle_announcement 方法处理异步返回的结果，当所有任务完成时自动生成最终报告。

6.3 执行流程图

报告生成阶段
结果收集阶段
并行执行阶段
并行启动阶段
初始化阶段
创建编排器实例
计算日期范围
定义任务配置
启动阅读分析
启动评论分析
启动话题排行
启动作者报告
子智能体 A
子智能体 B
子智能体 C
子智能体 D
接收通告 A
接收通告 B
接收通告 C
接收通告 D
聚合结果
生成最终报告
保存报告文件

7. 性能优化与资源管理

7.1 并发控制

OpenClaw 通过专用队列通道控制子智能体的并发数：

json 复制代码 
{
  "agents": {
    "defaults": {
      "subagents": {
        "maxConcurrent": 8
      }
    }
  }
}

并发配置建议：

场景 建议并发数 说明
轻量任务（文本处理） 8-16 快速完成，资源消耗低
中等任务（数据分析） 4-8 平衡资源与效率
重量任务（模型训练） 1-2 资源密集型，避免竞争

7.2 模型选择策略

合理选择模型可以显著降低成本：

json 复制代码 
{
  "agents": {
    "defaults": {
      "subagents": {
        "model": "gpt-4o-mini"
      }
    }
  }
}

模型选择矩阵：

任务类型 推荐模型 原因
简单分类/提取 gpt-4o-mini 成本低，速度快
复杂推理 claude-sonnet-4 推理能力强
代码生成 claude-sonnet-4 代码质量高
创意写作 gpt-4o 创意性好

7.3 超时设置最佳实践

python 复制代码 
# 根据任务复杂度设置合理的超时
TIMEOUT_PRESETS = {
    "quick": 60,        # 快速任务：1 分钟
    "standard": 300,    # 标准任务：5 分钟
    "extended": 900,    # 扩展任务：15 分钟
    "long_running": 3600  # 长任务：1 小时
}

def spawn_with_preset(task: str, preset: str = "standard"):
    """使用预设超时启动子智能体"""
    return sessions_spawn(
        task=task,
        runTimeoutSeconds=TIMEOUT_PRESETS.get(preset, 300)
    )

7.4 自动归档配置

子智能体会话会自动归档以释放资源：

json 复制代码 
{
  "agents": {
    "defaults": {
      "subagents": {
        "archiveAfterMinutes": 60
      }
    }
  }
}

归档策略：

  • 默认 60 分钟后自动归档
  • 使用 cleanup: "delete" 可立即归档
  • 归档保留转录文件（重命名为 *.deleted.<timestamp>）

7.5 资源监控

优化动作
监控指标
过高
积压
过长
超预算
活跃子智能体数
队列长度
平均运行时间
Token 消耗
调整并发数
优化任务分解
切换模型
设置超时

8. 工具策略与安全配置

8.1 子智能体工具限制

默认情况下，子智能体获得除会话工具外的所有工具。可以通过配置覆盖：

json 复制代码 
{
  "tools": {
    "subagents": {
      "tools": {
        "deny": ["gateway", "cron", "browser"],
        "allow": ["read", "write", "exec", "process"]
      }
    }
  }
}

8.2 安全配置示例

json 复制代码 
{
  "agents": {
    "list": [
      {
        "id": "main",
        "default": true,
        "workspace": "~/.openclaw/workspace",
        "sandbox": { "mode": "off" }
      },
      {
        "id": "worker",
        "workspace": "~/.openclaw/workspace-worker",
        "sandbox": {
          "mode": "all",
          "scope": "agent"
        },
        "tools": {
          "allow": ["read", "exec"],
          "deny": ["write", "edit", "browser", "gateway"]
        }
      }
    ]
  }
}

8.3 工具策略优先级

工具过滤按以下顺序执行，每个级别只能进一步限制：

  1. 工具配置文件（tools.profile）
  2. 提供商工具配置文件
  3. 全局工具策略（tools.allow/deny）
  4. 智能体特定工具策略
  5. 沙箱工具策略
  6. 子智能体工具策略

9. 总结

OpenClaw Subagent 为现代 AI 智能体系统提供了强大的并行处理和任务隔离能力。通过本文的深入探讨，我们了解到子智能体系统的核心设计理念和实际应用方法。

核心要点回顾：

🎯 架构设计：子智能体采用会话隔离机制，每个实例拥有独立的上下文和工具集，通过通告机制实现异步通信。这种设计既保证了隔离性，又维持了高效的通信能力。

⚙️ 参数配置 ：sessions_spawn 提供了丰富的参数选项，包括模型选择、超时控制、清理策略等。合理配置这些参数可以优化资源使用和成本效益。

🔄 编排模式：并行、串行、条件执行三种模式各有适用场景。并行模式适合独立任务批量处理，串行模式适合有依赖关系的任务链，条件模式适合动态决策场景。

📡 通信机制 ：通告机制是子智能体与主智能体之间的桥梁，支持正常结果返回、错误处理和超时通知。sessions_send、steer、kill 等操作提供了灵活的运行时控制能力。

🛡️ 安全与资源管理：通过工具策略、沙箱隔离、并发控制等多层机制，确保子智能体在安全边界内高效运行。合理的超时设置和自动归档策略有助于资源回收。

最佳实践建议：

  1. 根据任务复杂度选择合适的模型，平衡成本与质量
  2. 设置合理的超时时间，避免资源浪费
  3. 利用并发控制防止资源竞争
  4. 为敏感操作配置沙箱隔离
  5. 监控运行指标，持续优化配置

OpenClaw Subagent 的设计体现了"隔离优先、通信可控"的核心理念，为构建复杂的智能体系统提供了坚实的基础设施。随着 AI 应用场景的不断扩展，子智能体架构将在多任务处理、资源优化、安全隔离等方面发挥越来越重要的作用。🌟

10. 参考资料

  1. OpenClaw 官方文档 - 子智能体
    https://docs.openclaw.ai/app/docs/zh-CN/tools/subagents.md

  2. OpenClaw 官方文档 - 多智能体沙箱与工具
    https://cryptoclawdocs.termix.ai/app/docs/zh-CN/tools/multi-agent-sandbox-tools.md

  3. OpenClaw 沙箱配置指南
    https://docs.openclaw.ai/app/docs/zh-CN/gateway/sandboxing.md

  4. OpenClaw 会话管理
    https://docs.openclaw.ai/app/docs/zh-CN/concepts/session.md

相关推荐
MikelSun2 小时前
Sun01 - STM32智能编译烧录助手
人工智能·stm32·单片机·物联网·iot
ting94520002 小时前
动手学深度学习（PyTorch版）深度详解（10）： 优化算法 全解
人工智能·pytorch·深度学习·算法
EnCi Zheng2 小时前
03-注意力机制基础 [特殊字符]
人工智能
katheta2 小时前
时间序列模型总体分类
人工智能·分类·数据挖掘·时间序列·时序模型
LaughingZhu2 小时前
Product Hunt 每日热榜 | 2026-05-01
人工智能·经验分享·深度学习·产品运营
缝艺智研社2 小时前
誉财 YC - 21 平板下摆机：服装下摆与袖口加工的卓越之选
大数据·人工智能·自动化·电脑·新人首发·线上模板机
JianZhen✓2 小时前
浅谈AI代码编辑器使用
人工智能
AI进化营-智能译站2 小时前
ROS2 C++开发系列19-枚举定义机器人状态机｜随机数生成仿真测试数据流
java·c++·ai·机器人
byte轻骑兵2 小时前
蓝牙CAP规范解析：构建多设备协同的通用音频新生态
人工智能·音视频·le audio·低功耗音频·蓝牙通话
热门推荐
01要裂开了！ChatGPT要手机号验证了？注册Codex要求验证电话号码怎么办？2026年登陆Codex要手机号验证的解决办法02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结04Codex 接入 DeepSeek API 完整配置文档05裂开！ChatGPT 居然开始要手机号验证，附详细解决方法06零基础教你claude code 接入 deepseek V4072026年AI前瞻：量子AI、具身智能与科学发现的新纪元08在Windows 11上安装Docker的踩坑记录09实测可用｜小米 MiMo 百万亿 Token 免费领，开发者速冲10CVE-2026-31431 (Copy Fail) 漏洞复现与验证记录