研究提案

Terminal-Bench 数据合成方案

基于 ClawHub Skills 种子的终端 Agent 训练数据合成（CPT/SFT/RL）

Terminal-Bench 数据合成 Skills

基于 ClawHub Skills 种子的 Terminal-Bench 数据合成方案

目标：以 ClawHub 上的 Agent Skills 为种子，合成高质量终端 Agent 训练数据，用于 LLM 的中训练（CPT）、监督微调（SFT）和强化学习（RL）阶段。

一、背景调研

1.1 Terminal-Bench 概览

Terminal-Bench 是由 Stanford x Laude Institute 联合开发的 终端 Agent 基准测试，评估 AI 在真实终端环境中自主完成复杂任务的能力。

维度Terminal-Bench 1.0Terminal-Bench 2.0 (2026.01)
任务数量~10089（经严格筛选）
验证方式基础验证人工 + AI 双重验证
最高通过率~50%<65%（Codex CLI/GPT-5: 49.6%）
论文-arXiv:2601.11868

任务结构（每个任务包含三部分）：

task_name/
├── instruction.md       # 英文任务描述
├── tests/test.sh        # 验证测试脚本
├── Dockerfile           # 隔离环境
└── solution/            # 参考解决方案（Oracle）

1.2 TermiGen — 终端 Agent 训练框架（核心参考）

TermiGen 是 UCSB 推出的框架，专门用于合成终端 Agent 训练轨迹，与我们的目标高度匹配。

指标数据
环境数量3,500+ 个 Docker 环境
任务类别11 类 / 3 层
CLI 工具覆盖420+ 种
平均轨迹长度25.5 轮对话 / 8,722 tokens
模型效果TermiGen-32B 在 TB 2.0 上 18.0% pass@1

TermiGen 11 类任务体系：

层级类别覆盖工具示例
Tier I: 基础设施1. 软件构建与编译gcc, cmake, rustc, makefile
2. 系统管理与 DevOpsDocker, K8s, systemd, nginx
3. 安全与逆向工程Ghidra, Wireshark, gdb
Tier II: 数据与算法4. 数据处理与 ETLSpark, Kafka, Parquet, SQL
5. 机器学习与 MLOpsPyTorch, CUDA, HuggingFace
6. 算法与逻辑图算法, DP, 搜索
Tier III: 专业领域7. 软件开发React, Django, REST API, CI/CD
8. 科学计算RDKit, GROMACS, NumPy
9. 交互式环境WebSocket, SSH, Jupyter
10. 分布式计算MPI, OpenMP, Ray, SLURM
11. 形式化验证Coq, Z3, OpenGL

1.3 ClawHub / OpenClaw Skills 生态

ClawHub 是 OpenClaw 的公共技能注册表，3000+ Skills，涵盖极为广泛的 Agent 能力域。

OpenClaw 25 个 Tools（Agent 动作空间）：

层级工具描述
核心层read, write, edit, apply_patch文件操作
execShell 命令执行
process后台进程管理
web_search, web_fetch网络搜索与抓取
进阶层browser浏览器操作
memory_search/get跨会话记忆
sessions_spawn子 Agent 启动
cron定时任务调度
message跨平台消息
nodes硬件控制
…共 17 个

53 个官方 Skills 分类：

类别代表 Skills数量
笔记管理obsidian, notion, apple-notes, bear-notes4
任务管理things-mac, apple-reminders, trello3
邮件日历gog (Google Workspace), himalaya2
聊天社交slack, discord, wacli, imsg, bird6
开发工具github, coding-agent, tmux4
K8s/DevOpskubernetes, k8s, kube-medic, ansible, terraform9
数据库mysql, pg, redis-store, database-operations4
监控monitoring, prometheus, logging-observability3
音乐/智能家居spotify-player, openhue6
创意/图像openai-image-gen, video-frames4
语音openai-whisper, sherpa-onnx-tts4
系统/其他weather, summarize, clawhub, nano-pdf8+

ClawHub 运维高频 Skills（Top 20）： kubernetes, k8s, kube-medic, k8s-backup, k8-autoscaling, ansible, terraform, terraform-engineer, devops, monitoring, prometheus, logging-observability, database-operations, mysql, pg, redis-store, storage, cloud-storage, cloud-devops, openclaw-backup

1.4 现有数据合成 & Agent RL 训练方法论

(a) SWiRL — 分步强化学习（Google, 2025）

  • 方法：将多步轨迹分解为子轨迹，对每个子轨迹独立做 RL 优化
  • 效果：跨任务泛化，HotPotQA 训练可提升 GSM8K +16.9%
  • 参考：arXiv:2504.04736

(b) DeepSWE — 纯 RL 训练 Coding Agent（Berkeley, 2025）

  • 框架：基于 rLLM + R2E-Gym 环境
  • 动作空间：Bash 执行 / 搜索 / 文件编辑器 / 完成提交
  • 奖励：稀疏 ORM（成功/失败二值）
  • 效果：SWE-bench 59%，纯 RL 无需 SFT
  • 关键发现：模型自发学会边缘案例思考和回归测试

(c) GRPO — 无需奖励模型的策略优化

  • 优势：无需训练单独的 Reward Model，直接用标量奖励优化
  • 生态：ms-swift / verl-agent / OpenRLHF 等框架均已支持
  • 适用：特别适合 Agent 多步交互 + 工具调用场景

(d) ProductResearch — 多 Agent 合成轨迹蒸馏

  • 方法：User Agent + Supervisor Agent + Research Agent 协作生成轨迹
  • 蒸馏：反思内化（Reflective Internalization），多角色 → 单角色
  • 效果：MoE 模型微调后接近 Frontier 闭源系统

(e) Agent RL 训练关键技术总结

技术要点方案选项
冷启动结构化模板 Prompt / SFT 预热 / 课程学习
奖励设计稀疏 ORM / 分层奖励 / 分阶段课程奖励
优化算法GRPO / PPO / DPO
初始化基座模型 + Prompt / SFT 蒸馏
Token 掩码环境返回内容 masking，只学决策部分

二、方案设计：基于 ClawHub Skills 的数据合成 Pipeline

2.1 整体架构

┌─────────────────────────────────────────────────────────────┐
│                    数据合成 Pipeline                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────┐    ┌──────────────┐    ┌──────────────────┐   │
│  │ Phase 1  │───→│   Phase 2    │───→│     Phase 3      │   │
│  │ 种子采集  │    │  任务生成     │    │   轨迹合成       │   │
│  │ & 分析   │    │  & 环境构建   │    │   & 质量过滤     │   │
│  └──────────┘    └──────────────┘    └──────────────────┘   │
│       │                │                      │              │
│       ▼                ▼                      ▼              │
│  ┌──────────┐    ┌──────────────┐    ┌──────────────────┐   │
│  │ Phase 4  │    │   Phase 5    │    │     Phase 6      │   │
│  │ CPT 语料 │    │  SFT 数据    │    │   RL 训练数据    │   │
│  │ 构建     │    │  构造        │    │   构造           │   │
│  └──────────┘    └──────────────┘    └──────────────────┘   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

2.2 Phase 1：种子采集与能力域映射

目标

从 ClawHub Skills 中提取结构化的”能力种子”，映射到 Terminal-Bench 任务分类体系。

具体步骤

Step 1：批量抓取 ClawHub Skills 元数据

# 通过 ClawHub CLI / API 获取所有 skills
clawhub search "*" --limit 3000
# 解析每个 skill 的 SKILL.md 获取：
# - 功能描述、使用场景、前置依赖
# - 涉及的 CLI 工具链
# - 交互模式（单步/多步/多工具联动）

Step 2：能力域映射矩阵

将 ClawHub Skills 映射到扩展的任务分类体系：

ClawHub Skill 类别映射到任务域可衍生任务类型
kubernetes, k8s, kube-medic系统管理与 DevOpsPod 调试、Service 配置、故障排查
ansible, terraform基础设施即代码Playbook 编写、资源编排、多云部署
github, coding-agent软件开发PR 审查、Issue 处理、CI/CD 配置
mysql, pg, redis-store数据管理SQL 优化、数据迁移、备份恢复
prometheus, monitoring可观测性告警配置、Dashboard 构建、指标分析
slack, discord, gog工作流自动化消息联动、日程管理、多平台协调
nano-pdf, summarize文档处理PDF 处理、内容提取、格式转换
weather, web_search信息检索API 调用、数据聚合、结果解析
docker (内置)容器化镜像构建、编排调试、网络配置
nginx, systemd (内置)服务管理反向代理、服务编排、日志分析

Step 3：能力难度分级

Level 1 (简单)：单工具单步操作
  → "用 kubectl 查看 pod 状态"
  → "用 git 创建一个新分支"

Level 2 (中等)：单工具多步操作
  → "排查一个 CrashLoopBackOff 的 Pod 并修复"
  → "用 Terraform 部署一个 3 节点 Redis 集群"

Level 3 (困难)：多工具联动
  → "监控报警触发后，自动排查 K8s 服务异常并回滚"
  → "从 GitHub Issue 出发，定位 Bug、修复并提 PR"

Level 4 (专家)：跨系统长链路
  → "设计并部署一个带监控告警的微服务架构"
  → "数据库性能劣化排查：从慢查询到索引优化到缓存策略"

2.3 Phase 2：任务生成与环境构建

方案 A：基于 SKILL.md 的模板化任务生成

利用 LLM 读取 SKILL.md，自动生成多难度任务变体：

TASK_GEN_PROMPT = """
你是一个终端任务设计师。根据以下 Agent Skill 描述，生成 {n} 个不同难度的终端任务。

## Skill 信息
{skill_md_content}

## 任务格式
每个任务需要包含：
1. instruction: 清晰的英文任务描述（模拟真实用户需求）
2. difficulty: L1/L2/L3/L4
3. tools_required: 需要用到的命令行工具列表
4. setup_description: 环境初始状态描述
5. success_criteria: 可验证的成功条件列表
6. reference_solution: 参考解决步骤
7. common_pitfalls: 常见陷阱和错误路径

## 变体维度
- 正常路径 vs 异常/故障场景
- 单步完成 vs 需要调试迭代
- 标准配置 vs 边缘条件
"""

方案 B：基于 TermiGen 的环境自动合成

复用 TermiGen 框架，基于 ClawHub Skills 扩展环境：

# task.yaml 模板
task_id: "k8s-pod-crashloop-debug-001"
category: "system_administration"
source_skill: "kube-medic"
difficulty: "L3"
instruction: |
  A Kubernetes deployment 'web-api' in namespace 'production' has pods
  stuck in CrashLoopBackOff. Investigate the root cause, fix the issue,
  and verify the deployment is healthy with all replicas running.
environment:
  base_image: "ubuntu:22.04"
  setup_scripts:
    - install_kubectl.sh
    - setup_minikube.sh
    - deploy_broken_app.sh
tools_available:
  - kubectl
  - docker
  - curl
  - jq
success_tests:
  - "kubectl get pods -n production | grep 'Running' | wc -l == 3"
  - "curl -s http://localhost:8080/health | jq '.status' == 'ok'"

方案 C：人机协作 + 进化式生成（Evol-Instruct 变体）

Round 1: 从 SKILL.md 生成基础任务集
Round 2: LLM 对任务做"复杂化演进"
  - 添加约束条件（限时、限资源、限权限）
  - 注入故障（依赖缺失、配置错误、权限不足）
  - 合并多个 Skills 形成组合任务
Round 3: 人工审核 + 质量打分
Round 4: 高分任务继续演进，低分任务淘汰或修订

2.4 Phase 3：轨迹合成与质量过滤

3.1 轨迹生成方法

方法 1：Expert Model 直接生成

# 使用强 LLM (GPT-4/Claude) 在 Docker 环境中执行任务
trajectory = []
for task in tasks:
    env = DockerEnvironment(task.dockerfile)
    agent = ExpertAgent(model="gpt-4o", tools=TOOL_SET)
    result = agent.solve(task.instruction, env, max_turns=50)
    if result.passed_tests:
        trajectory.append({
            "task": task,
            "trajectory": result.conversation,
            "success": True,
            "turns": result.num_turns,
            "tokens": result.total_tokens
        })

方法 2：多 Agent 协作生成（参考 ProductResearch）

┌──────────────┐     ┌────────────────┐     ┌──────────────┐
│  Task Agent  │────→│ Executor Agent │────→│ Verifier     │
│ (理解任务)    │     │ (执行方案)      │     │ (验证结果)    │
└──────────────┘     └────────────────┘     └──────────────┘
       │                     │                      │
       │              ┌──────────────┐              │
       └─────────────→│ Critic Agent │←─────────────┘
                      │ (反思改进)    │
                      └──────────────┘
  • Task Agent：解析任务需求，制定分步计划
  • Executor Agent：在终端环境中执行命令
  • Verifier Agent：运行测试脚本验证结果
  • Critic Agent：分析失败原因，建议改进策略

方法 3：纠错轨迹合成（参考 TermiGen 核心创新）

# 生成"失败→纠错→成功"轨迹
def generate_error_correction_trajectory(task, env):
    # Step 1: 用较弱模型生成初始尝试（大概率失败）
    weak_agent = Agent(model="qwen2.5-7b")
    initial_attempt = weak_agent.solve(task, env)

    if initial_attempt.failed:
        # Step 2: 用强模型分析错误并纠正
        strong_agent = Agent(model="gpt-4o")
        correction = strong_agent.analyze_and_fix(
            task, initial_attempt.trajectory, env
        )
        # Step 3: 合并为完整的纠错轨迹
        return merge_trajectories(initial_attempt, correction)

3.2 质量过滤 Pipeline

Raw Trajectories
       │
       ▼
┌──────────────────┐
│ 1. 功能正确性过滤  │ ← 运行 test.sh，必须全部通过
│    (Hard Filter)  │
└──────────────────┘
       │
       ▼
┌──────────────────┐
│ 2. 效率过滤       │ ← 剔除步骤数 > 2x Oracle 的轨迹
│    (Soft Filter)  │
└──────────────────┘
       │
       ▼
┌──────────────────┐
│ 3. 多样性去重     │ ← 基于命令序列做相似度聚类去重
│    (Dedup)        │
└──────────────────┘
       │
       ▼
┌──────────────────┐
│ 4. LLM 质量打分   │ ← 从推理质量、工具使用合理性、
│    (Quality Score)│    解释清晰度等维度打分
└──────────────────┘
       │
       ▼
  High-Quality Trajectories

2.5 Phase 4：CPT（Continual Pre-Training）语料构建

目标

增强模型对终端操作、工具文档、系统管理知识的理解。

语料构成

语料类型来源预估规模处理方式
工具文档man pages, —help 输出, 官方 docs100M+ tokens结构化清洗
SKILL.md 语料ClawHub 3000+ Skills10M+ tokens保留原始结构
终端交互日志GitHub Issues/Answers, StackOverflow500M+ tokens质量过滤
配置文件语料Dockerfile, YAML, TOML, nginx.conf200M+ tokens语法标注
错误处理语料Error patterns + Fix patterns50M+ tokens错误-修复对

数据格式

{
  "text": "<|tool_doc|>\n## kubectl get pods\n\nDisplay one or many pods...\n<|/tool_doc|>",
  "metadata": {"source": "man_page", "tool": "kubectl", "category": "k8s"}
}
{
  "text": "<|skill|>\n# Kubernetes Skill\n\nManage K8s clusters...\n<|/skill|>",
  "metadata": {"source": "clawhub", "skill_slug": "kubernetes", "downloads": 15000}
}
{
  "text": "<|terminal_session|>\n$ docker build -t myapp .\nERROR: failed to solve...\n$ # Fix: add --platform linux/amd64\n$ docker build --platform linux/amd64 -t myapp .\nSuccessfully built abc123\n<|/terminal_session|>",
  "metadata": {"source": "synthetic", "category": "docker", "has_error_fix": true}
}

2.6 Phase 5：SFT 数据构造

5.1 数据格式

{
  "messages": [
    {
      "role": "system",
      "content": "You are a terminal agent. You can execute bash commands and use tools to solve tasks. Think step by step."
    },
    {
      "role": "user",
      "content": "A Kubernetes pod 'web-api-xxx' is in CrashLoopBackOff. Find the root cause and fix it."
    },
    {
      "role": "assistant",
      "content": "<think>\nI need to investigate why the pod is crash-looping. Let me start by checking the pod status and recent events.\n</think>\n<action type=\"bash\">\nkubectl describe pod web-api-xxx -n production\n</action>"
    },
    {
      "role": "tool",
      "content": "Name: web-api-xxx\nStatus: CrashLoopBackOff\n...\nEvents:\n  Warning  BackOff  Container web-api failed: OOMKilled"
    },
    {
      "role": "assistant",
      "content": "<think>\nThe pod is being OOMKilled. I need to check the current memory limits and the actual memory usage, then increase the resource limits.\n</think>\n<action type=\"bash\">\nkubectl get pod web-api-xxx -o jsonpath='{.spec.containers[0].resources}'\n</action>"
    },
    // ... 更多轮次 ...
    {
      "role": "assistant",
      "content": "<think>\nThe deployment is now healthy with all pods running. Let me verify the fix is stable.\n</think>\n<action type=\"bash\">\nkubectl get pods -n production | grep web-api\n</action>"
    },
    {
      "role": "tool",
      "content": "web-api-xxx   1/1   Running   0   30s\nweb-api-yyy   1/1   Running   0   30s\nweb-api-zzz   1/1   Running   0   30s"
    },
    {
      "role": "assistant",
      "content": "The issue has been resolved. The root cause was an OOMKilled error..."
    }
  ],
  "metadata": {
    "task_id": "k8s-oom-debug-001",
    "source_skill": "kube-medic",
    "difficulty": "L2",
    "tools_used": ["kubectl"],
    "turns": 8,
    "tokens": 4500,
    "verified": true
  }
}

5.2 SFT 数据矩阵（目标规模）

能力维度基于的 ClawHub Skills目标任务数目标轨迹数
K8s/容器管理kubernetes, k8s, kube-medic 等5002,500
IaC/配置管理ansible, terraform 等3001,500
数据库运维mysql, pg, redis-store 等4002,000
监控告警prometheus, monitoring 等2001,000
软件开发github, coding-agent 等5002,500
系统管理devops, cloud-devops 等3001,500
文件/文档处理nano-pdf, summarize 等2001,000
网络/APIweb_search, web_fetch 等2001,000
编译/构建(内置工具链)3001,500
安全/调试(内置工具链)2001,000
合计50+ Skills~3,100~15,500

5.3 轨迹蒸馏策略（多 Agent → 单 Agent）

参考 ProductResearch 的 Reflective Internalization：

def distill_trajectory(multi_agent_traj):
    """
    将多 Agent 协作轨迹蒸馏为单角色 SFT 训练样本
    """
    # 1. 提取 Executor Agent 的行动序列
    actions = extract_actions(multi_agent_traj, role="executor")
    # 2. 提取 Critic Agent 的推理过程
    reasoning = extract_reasoning(multi_agent_traj, role="critic")
    # 3. 合并为单角色 <think> + <action> 格式
    distilled = []
    for action, reason in zip(actions, reasoning):
        distilled.append({
            "role": "assistant",
            "content": f"<think>\n{reason}\n</think>\n<action>\n{action}\n</action>"
        })
    return distilled

2.7 Phase 6：RL 训练数据构造

6.1 推荐方案：分阶段 GRPO

参考 R1-Searcher++ 的课程学习 + DeepSWE 的纯 RL 路径：

┌────────────────────────────────────────────────────────┐
│              RL 训练三阶段                               │
├────────────────────────────────────────────────────────┤
│                                                         │
│  Stage 1: 行为塑形（Behavior Shaping）                   │
│  ┌─────────────────────────────────────┐               │
│  │ 奖励：格式正确 → +0.1                │               │
│  │       使用了合适的工具 → +0.2        │               │
│  │       答案正确 → 不关注              │               │
│  │ 目标：学会终端交互的基本模式          │               │
│  └─────────────────────────────────────┘               │
│                    │                                     │
│                    ▼                                     │
│  Stage 2: 任务完成（Task Completion）                    │
│  ┌─────────────────────────────────────┐               │
│  │ 奖励：测试通过 → +1.0               │               │
│  │       部分通过 → +0.5               │               │
│  │       失败 → 0                      │               │
│  │ 目标：学会解决实际任务               │               │
│  └─────────────────────────────────────┘               │
│                    │                                     │
│                    ▼                                     │
│  Stage 3: 效率优化（Efficiency Optimization）            │
│  ┌─────────────────────────────────────┐               │
│  │ 奖励：通过 + 步骤少 → 高分           │               │
│  │       通过 + 步骤多 → 中分           │               │
│  │       失败 → 负分                    │               │
│  │ 目标：学会高效解决问题               │               │
│  └─────────────────────────────────────┘               │
│                                                         │
└────────────────────────────────────────────────────────┘

6.2 奖励函数设计

def compute_reward(trajectory, task, test_results):
    """
    多维度奖励函数
    """
    reward = 0.0

    # 1. 结果奖励（主要信号）
    pass_rate = test_results.passed / test_results.total
    reward += pass_rate * 1.0

    # 2. 效率奖励（辅助信号）
    oracle_steps = task.reference_solution.num_steps
    actual_steps = len(trajectory.actions)
    efficiency = max(0, 1 - (actual_steps - oracle_steps) / (oracle_steps * 3))
    reward += efficiency * 0.2

    # 3. 格式奖励（冷启动信号）
    if trajectory.follows_format:
        reward += 0.1

    # 4. 惩罚（安全信号）
    if trajectory.has_destructive_commands:  # rm -rf /, DROP DATABASE 等
        reward -= 1.0

    return reward

6.3 环境交互接口

class TerminalRLEnvironment:
    """
    基于 Docker 的 RL 训练环境
    """
    def __init__(self, task_config):
        self.container = docker.create(task_config.dockerfile)
        self.task = task_config
        self.history = []

    def reset(self):
        self.container.restart()
        self.history = []
        return self.task.instruction

    def step(self, action: str):
        """执行动作，返回 (observation, reward, done, info)"""
        # 执行命令
        stdout, stderr, exit_code = self.container.exec(action)
        observation = f"stdout: {stdout}\nstderr: {stderr}\nexit_code: {exit_code}"

        # 检查是否完成
        done = self._check_done(action)

        # 计算奖励（仅在 done 时）
        reward = 0.0
        if done:
            test_results = self.container.exec(self.task.test_script)
            reward = compute_reward(self.history, self.task, test_results)

        self.history.append({"action": action, "observation": observation})
        return observation, reward, done, {"test_results": test_results if done else None}

6.4 Token Masking 策略

参考 Search-R1 的 Retrieved Token Masking：

┌──────────────────────────────────────────────────┐
│  计算 Loss 的 Token 范围                          │
├──────────────────────────────────────────────────┤
│                                                   │
│  <think>                                          │
│    I need to check the pod logs...  ✅ 计算 Loss  │
│  </think>                                         │
│  <action>                                         │
│    kubectl logs web-api-xxx          ✅ 计算 Loss  │
│  </action>                                        │
│  <observation>                                    │
│    Error: Connection refused...      ❌ 不计算 Loss│
│    at line 42 of server.js           ❌ 不计算 Loss│
│  </observation>                                   │
│  <think>                                          │
│    The error indicates...            ✅ 计算 Loss  │
│  </think>                                         │
│                                                   │
└──────────────────────────────────────────────────┘

三、技术实施路线图

3.1 阶段规划

Phase 1（第 1-2 周）：种子采集与分析
├── 批量抓取 ClawHub 3000+ Skills 元数据
├── 构建能力域映射矩阵
├── 定义扩展任务分类体系（15+ 类别）
└── 设计难度分级标准

Phase 2（第 3-5 周）：任务生成与环境构建
├── 基于 SKILL.md 生成 3,000+ 任务描述
├── 用 Evol-Instruct 做任务复杂化演进
├── 构建 Docker 环境（复用 TermiGen 框架）
├── 编写测试脚本
└── 人工审核 + 质量把关

Phase 3（第 6-8 周）：轨迹合成
├── Expert Model 生成成功轨迹
├── 多 Agent 协作生成高质量轨迹
├── 纠错轨迹合成（弱模型失败 + 强模型纠正）
├── 质量过滤 Pipeline
└── 轨迹蒸馏（多角色 → 单角色）

Phase 4（第 9-10 周）：CPT 语料整理
├── 工具文档语料清洗
├── SKILL.md 语料处理
├── 终端日志语料过滤
└── 统一格式化

Phase 5（第 11-13 周）：SFT 数据集构建
├── 格式化为 messages 格式
├── 多样性去重
├── 质量打分排序
└── 数据集划分（train/val/test）

Phase 6（第 14-16 周）：RL 环境与数据
├── Docker 环境标准化
├── 奖励函数实现与调优
├── 训练框架集成（verl-agent / ms-swift）
└── 基线实验验证

3.2 预估数据规模

数据类型规模Token 数用途
CPT 语料-~1B tokens中训练
SFT 任务3,100 个任务-微调
SFT 轨迹15,500 条~135M tokens微调
RL 环境3,500+ Docker-强化学习
RL 轨迹（在线生成）按需按需强化学习

3.3 推荐训练 Pipeline

Base Model (e.g., Qwen2.5-Coder-32B)
        │
        ▼
   ┌─────────┐
   │  CPT    │ ← 终端文档 + SKILL.md + 配置文件语料
   │ (1B tok)│
   └─────────┘
        │
        ▼
   ┌─────────┐
   │  SFT    │ ← 高质量终端 Agent 轨迹 (15K 条)
   │         │
   └─────────┘
        │
        ▼
   ┌─────────┐
   │  RL     │ ← GRPO + Docker 环境交互 (3,500+ 环境)
   │ (GRPO)  │    分阶段课程学习
   └─────────┘
        │
        ▼
  Terminal Agent Model

四、关键风险与对策

风险影响对策
ClawHub Skills 质量参差种子质量影响下游按下载量/星级筛选 Top Skills，人工审核
Docker 环境不稳定RL 训练中断参考 TermiGen 验证流程，预跑所有环境
轨迹数据分布偏斜模型偏向简单任务按难度分层采样，保证各 Level 均衡
RL 奖励信号稀疏训练不收敛分阶段课程 + 格式奖励热启动
数据泄露到评测集评估不可信严格去重 + Canary GUID 检测
安全风险模型学会危险命令沙箱隔离 + 危险命令惩罚 + 输出过滤

五、与现有工作的差异化价值

维度TermiGenDeepSWE/R2E-Gym本方案
种子来源人工设计GitHub PRsClawHub 3000+ Skills（生态驱动）
任务覆盖11 类代码修复15+ 类（含 DevOps/运维/文档处理）
工具覆盖420+4 个500+（融合 OpenClaw 25 Tools）
训练阶段SFTRLCPT + SFT + RL 全链路
纠错轨迹✅❌✅ + 多 Agent 蒸馏
可扩展性中低高（ClawHub 持续增长）

六、参考文献

  1. Terminal-Bench 2.0 — Merrill et al., 2026. arXiv:2601.11868
  2. TermiGen — UCSB, 2026. GitHub
  3. SWiRL — Goldie et al., 2025. arXiv:2504.04736
  4. DeepSWE — Agentica/Berkeley, 2025. GitHub
  5. ProductResearch — Wang et al., 2026. arXiv:2602.23716
  6. ClawHub / OpenClaw — docs.openclaw.ai
  7. GRPO for Agent — ms-swift / verl-agent 框架文档
  8. Agentic Tool Use RL — 综述文章, 2025. CSDN