Terminal Bench 2.1 深度拆解：当「用命令行执行真实任务」成为衡量 AI Agent 能力的黄金标准——2026 评测体系全解析

2026 年，AI Agent 从「能说会道」进化到「能做会干」。但谁来定义什么叫「能干」？当各家厂商都在宣传「Agent 能力大幅提升」时，我们究竟在比较什么？Terminal Bench 2.1 给出了一套让整个行业信服的答案——用真实终端任务，测出模型真正的 Agent 上限。本文从架构设计、评测集构建、数学原理到行业影响，系统拆解这套评测体系如何成为 2026 年 AI Agent 领域最受认可的黄金标准。

一、背景：为什么 AI Agent 需要专属基准

1.1 传统基准的失效

2023-2024 年，业界评估 LLM 能力主要靠 MMLU、HumanEval、GSM8K 这套组合拳。但这些基准存在三个根本性问题：

第一个问题：静态题库导致饱和。 MMLU 从 2021 年用到现在，GPT-4 能考 86 分，Claude 3.5 能考 92 分——分数已经接近天花板，再往上卷已经没有意义。更严重的是，主流模型在训练数据中「见过」这些题目，导致分数虚高。

第二个问题：只考「说」，不考「做」。 HumanEval 是给你一个函数签名让你补全代码，GSM8K 是解数学题，它们都在测试「模型能说出正确答案」，而不是「模型能通过执行真实操作来完成任务」。一个 Agent 需要的是：在没有标准答案的场景下，自主规划、调用工具、处理错误、迭代改进——这些能力在传统基准里完全测不出来。

第三个问题：多轮交互能力无法衡量。 真实的 Agent 任务不是一次问答，而是多轮交互。比如「帮我把服务器上的日志压缩归档，然后发送到 S3 备份」，需要 cd、tar、aws s3 cp 多个命令的组合，中途可能遇到权限问题、路径问题、网络问题，Agent 需要能处理这些中间状态。

1.2 Agent 基准的探索之路

行业尝试过几条路线：

RAG 基准（如 Natural Questions、TriviaQA）测的是检索+生成能力，不是 Agent 能力。

工具调用基准（如 API-Bank、ToolBench）测的是单轮工具调用，无法衡量复杂任务分解。

多智能体基准（如 Multi-Agent Bench）测的是多 Agent 协作，但本身场景过于理想化。

直到 2025 年，Terminal Bench 的前身诞生了——它从「用 shell 执行真实操作」这个角度切入，第一次把「能不能做到」变成了可量化的分数。

1.3 Terminal Bench 的核心设计哲学

Terminal Bench 的设计哲学是三个字：真实性。

具体来说，它遵循三个原则：

1. 任务来自真实生产环境：不是人工编造的题目，而是从真实 DevOps 场景、运维脚本、数据库维护中提炼出来的任务模板。
2. 评测基于执行结果：不是让模型输出答案然后人工评分，而是让模型在沙箱中执行命令，根据文件系统状态、命令退出码、输出内容来判定成功与否。
3. 可复现可扩展：评测集开源，支持社区贡献新任务，保持持续演进。

二、Terminal Bench 2.1 评测体系架构

2.1 任务分类体系

Terminal Bench 2.1 将 AI Agent 的终端任务分为六大类：

2.2 评测环境设计

Terminal Bench 2.1 的评测环境采用容器化沙箱 + 最小化文件系统快照：

# 评测环境的简化示意（Python pseudocode）
class TerminalSandbox:
    def __init__(self, task_category: str):
        # 1. 加载预置的最小化文件系统快照
        self.fs_snapshot = load_snapshot(f"{task_category}_base.img")
        # 2. 启动隔离的网络命名空间
        self.netns = create_network_namespace()
        # 3. 设置资源限制（CPU/内存/磁盘）
        set_resource_limits(cpu_quota=50000, memory_limit_mb=512)
        # 4. 挂载只读的系统命令目录
        mount_system_bins(readonly=True)
        # 5. 开启审计日志（记录所有命令及结果）
        self.audit_log = start_command_audit()
    
    def execute_command(self, command: str, timeout: int = 30) -> CommandResult:
        """执行一条命令，返回结果"""
        start_time = time.time()
        proc = subprocess.run(
            command,
            shell=True,
            capture_output=True,
            timeout=timeout,
            cwd=self.working_dir,
            env=self.environment
        )
        return CommandResult(
            command=command,
            exit_code=proc.returncode,
            stdout=proc.stdout.decode('utf-8', errors='replace'),
            stderr=proc.stderr.decode('utf-8', errors='replace'),
            duration_ms=int((time.time() - start_time) * 1000),
            fs_changes=self.audit_log.get_changes_since_last_call()
        )

关键设计细节：

• 文件系统快照：每个任务类别预置一个最小文件系统，包含必要的工具（bash、coreutils、部分应用），避免模型在「找命令」这个环节浪费时间。
• 网络命名空间隔离：网络相关任务可以访问真实网络，但与主机隔离，防止危险操作。
• 退出码语义：Terminal Bench 定义了一套标准退出码语义（0=成功、1=一般错误、2=致命错误），用于判断任务完成度。
• 文件系统变更追踪：每次命令执行后，自动记录文件系统的变更（创建/修改/删除的文件），用于最终状态验证。

2.3 评分机制

Terminal Bench 2.1 的评分不是简单的「对/错」二分，而是引入了三档评分体系：

最终分数 = 所有任务得分的加权平均，权重由任务难度和覆盖度决定。

def score_task(result: CommandResult, task: TerminalTask) -> float:
    """
    Terminal Bench 2.1 评分算法
    task.target_state: 期望的最终文件系统状态
    result.fs_changes: 实际的命令执行后的文件系统变更
    """
    # 第一步：检查退出码
    if result.exit_code != 0:
        # 即使退出码非零，也可能完成了部分目标
        partial_score = calculate_partial_completion(result, task)
        return partial_score * 0.6  # 部分完成最高 60%
    
    # 第二步：验证文件系统状态
    expected = parse_target_state(task.target_state)
    actual = parse_current_state(result.fs_changes)
    
    match_ratio = compute_state_match(expected, actual)
    
    # 第三步：检查是否有意外副作用
    side_effects = detect_unintended_changes(result.fs_changes, task.allowed_changes)
    if side_effects:
        match_ratio *= 0.8  # 有副作用打八折
    
    return match_ratio * 100.0

def compute_state_match(expected: StateDict, actual: StateDict) -> float:
    """计算状态匹配度"""
    if not expected:
        return 1.0 if result.exit_code == 0 else 0.0
    
    matched_keys = 0
    total_keys = len(expected)
    
    for key, expected_value in expected.items():
        if key not in actual:
            continue
        actual_value = actual[key]
        
        if isinstance(expected_value, list):
            # 集合类：顺序无关，去重比较
            if set(expected_value) == set(actual_value):
                matched_keys += 1
        elif isinstance(expected_value, str):
            # 字符串：支持通配符和正则
            if fnmatch(actual_value, expected_value) or \
               re.match(expected_value, actual_value):
                matched_keys += 1
        else:
            # 精确匹配
            if actual_value == expected_value:
                matched_keys += 1
    
    return matched_keys / total_keys if total_keys > 0 else 0.0

三、核心评测维度深度解析

3.1 Terminal Bench 2.1 的五大核心维度

Terminal Bench 2.1 不只是测「能不能做完」，而是将评测分解为五个维度：

维度一：规划能力（Planning）
Agent 能否将高层目标拆解为正确的子任务序列？这是最难测的能力，因为正确的规划需要对任务域的深刻理解。

# 一个典型的高难度规划任务
# 目标：「分析服务器负载飙升原因，需要在 5 分钟内给出报告」

# 初级 Agent 的规划（线性思维）：
# step 1: top  # 只看进程
# step 2: free -m  # 只看内存
# step 3: exit  # 没有整合分析

# Terminal Bench 认可的规划路径（结构化思维）：
# step 1: uptime && w  # 先看整体负载和登录用户
# step 2: top -bn1 | head -20  # 找高 CPU 进程
# step 3: ss -s  # 看网络连接状态
# step 4: journalctl --since "-10 minutes"  # 看最近的系统日志
# step 5: df -h  # 看磁盘空间
# step 6: dmesg | tail -20  # 看内核消息
# step 7: echo "=== 报告 ===" && ...  # 生成结构化报告

维度二：工具选择（Tool Selection）
给定任务，Agent 能否选择正确的工具？同一个目标可以用多种工具达成，但效率差异巨大。

# 场景：在 10GB 的日志文件中找错误
# 低效方案：grep "ERROR" access.log  # 逐行扫描，O(n)
# 高效方案：rg "ERROR" access.log -c  # 使用 ripgrep 的 count 模式
# 最优方案：rg "ERROR" access.log -c --json  # 输出结构化结果便于后处理

维度三：错误处理（Error Recovery）
当命令执行失败时，Agent 能否分析错误信息并采取正确的恢复行动？

# Terminal Bench 中常见的错误处理路径测试
error_scenario = {
    "task": "将 /data/backup.tar.gz 解压到 /opt/app",
    "expected_behavior": """
        1. 首次尝试: tar -xzf /data/backup.tar.gz -C /opt/app
        2. 如果报错 "Permission denied":
           -> 分析：权限不足
           -> 尝试: sudo tar -xzf /data/backup.tar.gz -C /opt/app
        3. 如果报错 "No space left":
           -> 分析：磁盘空间不足
           -> 尝试: df -h 查看空间，清理后重试
        4. 验证: ls /opt/app | head -5  # 确认文件已解压
    """,
    "scoring_criteria": {
        "auto_recovery": "能在3次内找到正确路径",
        "error_diagnosis": "能从错误信息中提取关键线索",
        "state_preservation": "不丢失之前的进度"
    }
}

维度四：状态管理（State Management）
Agent 能否在多步骤任务中维护中间状态，包括变量、文件路径、前序步骤的结果？

# 典型的状态管理测试
# 目标：批量重命名 /data/logs 下的所有 .log.2026-08-* 文件为 .log.bak.2026-08-*

# 考察点：Agent 需要记住中间变量（文件列表），并在循环中正确使用
files=$(find /data/logs -name "*.log.2026-08-*")
count=0
for f in $files; do
    newname="${f%.log.2026-08-*}.log.bak.2026-08-*"
    mv "$f" "$newname" 2>/dev/null || true
    count=$((count + 1))
done
echo "Renamed $count files"

维度五：效率（Efficiency）
在保证正确性的前提下，Agent 使用了多少步命令？走了多少弯路？

# 效率评分算法
def efficiency_score(commands: list[str], optimal_path: list[str]) -> float:
    """
    commands: Agent 实际执行的命令序列
    optimal_path: 理论最优命令序列（由专家标注）
    """
    actual_steps = len(commands)
    optimal_steps = len(optimal_path)
    
    # 步数比超过 2x 效率极差
    if actual_steps > optimal_steps * 2:
        return 0.3
    
    # 步数比 1.5x-2x 效率一般
    elif actual_steps > optimal_steps * 1.5:
        return 0.6
    
    # 步数比接近最优
    elif actual_steps <= optimal_steps * 1.2:
        return 1.0
    
    # 步数略多于最优
    else:
        return 0.85

3.2 各模型在 Terminal Bench 2.1 上的实测数据（2026年8月最新）

根据 2026 年 8 月 13 日发布的最新评测数据，以下是主流模型在 Terminal Bench 2.1 上的得分：

关键发现：

1. Kimi K3 在规划能力上领先：其思维链（Chain-of-Thought）在面对「先做什么再做什么」这类问题时，正确率最高。
2. DeepSeek V4-Pro 在效率上领先：其 Token 消耗比 Fable 5 低 47%，在同等任务完成度下使用的命令步数最少。
3. Claude Opus 4.8 的错误处理最强：遇到报错时，它的诊断准确率最高，能更快找到恢复路径。

四、Terminal Bench 2.1 的技术实现细节

4.1 任务生成与标注流程

Terminal Bench 2.1 的任务集构建经过严格流程：

阶段一：任务采集（1-2周）

• 从 GitHub Issues、DBA 日志、DevOps 工程师访谈中收集真实任务
• 排除涉及真实密码、密钥、个人信息的任务
• 保留 300+ 原始任务候选

阶段二：规范化与分级（1周）

• 将原始任务翻译为标准 Shell 命令模板
• 由两名专家独立标注预期命令序列和目标状态
• 标注分歧由第三名专家仲裁
• 最终保留约 180 个有效任务

阶段三：难度分级与平衡（3天）

• 按复杂度、工具组合、前置条件等维度打分
• 确保各难度档位的任务数量均衡
• 计算任务间相关性（避免任务间有知识泄漏）

# 任务模板示例（YAML格式简化）
task:
  id: "TB-2026-047"
  title: "日志归档与清理"
  category: "filesystem_operations"
  difficulty: 3.5
  
  description: |
    在 /var/log/app 目录下，有大量按日期分割的日志文件。
    请将 2026-07 的日志（app-2026-07-*.log）打包压缩为 
    /tmp/archive/app_logs_2026_07.tar.gz，然后删除原始文件，
    最后统计压缩包大小并输出报告。
  
  environment:
    initial_files:
      - /var/log/app/app-2026-07-01.log
      - /var/log/app/app-2026-07-15.log
      - /var/log/app/app-2026-08-01.log
    allowed_commands:
      - tar
      - gzip/gunzip
      - find
      - ls
      - rm
      - du
      - echo
  
  ground_truth:
    expected_sequence: |
      mkdir -p /tmp/archive
      tar -czf /tmp/archive/app_logs_2026_07.tar.gz \
        /var/log/app/app-2026-07-*.log
      rm /var/log/app/app-2026-07-*.log
      du -h /tmp/archive/app_logs_2026_07.tar.gz
    target_state:
      /tmp/archive/app_logs_2026_07.tar.gz: exists
      "/var/log/app/app-2026-07-*.log": absent
    max_steps: 6
    time_limit_seconds: 120
  
  evaluation:
    success_criteria:
      - "压缩包存在且非空"
      - "原始日志文件已删除"
      - "不包含 2026-08 的文件"
    partial_credit_rules:
      100: "完全符合"
      60: "压缩包正确但未清理原始文件"
      30: "命令语法正确但执行有误"
      0: "未完成任务"

4.2 沙箱安全机制

Terminal Bench 2.1 的沙箱必须满足三个安全要求：隔离性（不污染宿主机）、可重现性（同模型同任务同结果）、可控性（可注入错误、可模拟故障）。

# 基于 Linux namespace + seccomp 的安全沙箱实现
import subprocess
import os

class SecureTerminalSandbox:
    def __init__(self):
        # 1. 用户命名空间：将 root 映射为非特权用户
        # 2. 网络命名空间：仅允许本地网络
        # 3. PID 命名空间：隔离进程视图
        # 4. mount 命名空间：独立的文件系统视图
        
        self.security_profile = {
            "uid_map": "0 1000 1",  # 容器内 root -> 宿主机 uid 1000
            "allowed_syscalls": [
                # 文件操作
                "read", "write", "open", "close", "stat", 
                "fstat", "lstat", "poll", "lseek", "mprotect",
                "mmap", "brk", "rt_sigaction", "rt_sigprocmask",
                "ioctl", "pread64", "pwrite64", "readv", "writev",
                # 进程
                "execve", "exit", "wait4", "kill",
                # 网络（仅本地）
                "socket", "connect", "accept", "sendto", "recvfrom",
            ],
            "denied_paths": [
                "/etc/shadow", "/root", "/home/*/.ssh",
                "/proc/1", "/proc/sys/kernel"
            ],
            "max_cpu_seconds": 30,
            "max_memory_mb": 512,
            "max_disk_mb": 1024
        }
    
    def _build_seccomp_profile(self) -> str:
        """生成 seccomp profile，限制系统调用"""
        import json
        return json.dumps({
            "defaultAction": "SCMP_ACT_KILL",
            "architectures": ["SCMP_ARCH_X86_64", "SCMP_ARCH_AARCH64"],
            "syscalls": [
                {"name": name, "action": "SCMP_ACT_ALLOW"}
                for name in self.security_profile["allowed_syscalls"]
            ]
        })
    
    def run(self, command: str, cwd: str = "/workspace") -> CommandResult:
        """在沙箱中运行命令"""
        seccomp_profile = self._build_seccomp_profile()
        
        # 使用 unshare 创建命名空间 + chroot 限制文件系统
        cmd = [
            "unshare", "--pid", "--user", "--map-root-user",
            "--mount", "--uts", "--ipc", "--cgroup",
            "sh", "-c",
            f"chroot /sandbox/root sh -c '{command}'"
        ]
        
        proc = subprocess.run(
            cmd,
            capture_output=True,
            timeout=self.security_profile["max_cpu_seconds"],
            cwd=cwd
        )
        
        return CommandResult(
            command=command,
            exit_code=proc.returncode,
            stdout=proc.stdout.decode('utf-8', errors='replace'),
            stderr=proc.stderr.decode('utf-8', errors='replace'),
            sandbox_violation=self._check_violations()
        )

五、Terminal Bench 2.1 对模型训练的反馈

5.1 强化学习信号：从分数到梯度

Terminal Bench 2.1 最深远的意义在于它改变了模型训练范式。传统 RLHF（基于人类反馈的强化学习）依赖人工标注，效率低且成本高。Terminal Bench 提供了自动化的过程奖励信号：

# 基于 Terminal Bench 的过程奖励训练（Process Reward Training）
class TerminalRewardModel:
    """
    为 Terminal Bench 任务训练过程奖励模型。
    每个中间步骤都得到奖励信号，而不仅仅是最终结果。
    """
    
    def compute_step_reward(
        self,
        history: list[CommandStep],
        current_step: CommandStep,
        task: TerminalTask
    ) -> float:
        """
        计算当前步骤的奖励值
        history: 之前执行的命令序列及结果
        current_step: 当前要执行的命令
        task: 任务定义
        """
        reward = 0.0
        
        # 1. 工具选择奖励
        optimal_tools = set(parse_tools_from_gt(task.expected_sequence))
        selected_tools = parse_tools_from_command(current_step.command)
        if selected_tools.issubset(optimal_tools):
            reward += 0.2  # 使用了正确的工具子集
        
        # 2. 方向正确性奖励
        current_state = simulate_state(history)
        target_progress = compute_progress_towards_goal(current_state, task.target_state)
        if target_progress > 0.3:  # 进度超过 30% 才给奖励
            reward += 0.3 * target_progress
        
        # 3. 错误避免奖励
        if self._would_cause_error(current_step, history):
            reward -= 0.5  # 高额惩罚
        
        # 4. 效率奖励
        if len(history) <= task.max_steps * 0.8:
            reward += 0.1  # 在步数限制的 80% 以内
        
        return reward
    
    def build_trajectory_reward(
        self,
        trajectory: list[CommandStep],
        task: TerminalTask
    ) -> float:
        """
        计算完整轨迹的最终奖励
        """
        final_result = trajectory[-1]
        
        if final_result.exit_code != 0:
            # 命令执行失败的惩罚
            partial_completion = compute_partial(task, trajectory)
            return partial_completion * 0.4  # 最高 40%
        
        # 检查最终状态匹配度
        match_ratio = compute_state_match(
            final_result.fs_state,
            task.target_state
        )
        
        # 结合过程奖励和结果奖励
        process_reward = sum(
            self.compute_step_reward(trajectory[:i], trajectory[i], task)
            for i in range(len(trajectory))
        )
        
        result_reward = match_ratio * 0.6
        
        return process_reward * 0.4 + result_reward * 0.6

5.2 从 Terminal Bench 到 Agent 的能力闭环

Terminal Bench 2.1 催生了一个新的能力进化闭环：

模型执行 Terminal Bench 任务
       ↓
Terminal Bench 自动评分 + 过程奖励信号
       ↓
用奖励信号微调 / RL 训练模型
       ↓
新模型在 Terminal Bench 上得分提升
       ↓
真实 Agent 能力提升（泛化到其他终端任务）
       ↓
新增更难的任务到 Terminal Bench（闭环）

这个闭环的关键优势是：不需要人工标注过程奖励，评分完全自动化，训练效率大幅提升。DeepSeek V4-Pro 的评测报告显示，通过 Terminal Bench 信号进行 RL 训练后，其 Agent 能力在 Terminal Bench 2.1 上从 82.7 提升到 87.9，提升幅度达到 5.2 分。

六、行业影响与局限

6.1 正面影响

推动了 Agent 评测的标准化。 此前每家公司都有自己的内部评测集，互相之间无法比较。Terminal Bench 2.1 提供了一个公共基准，让模型对比有了共同语言。

加速了模型能力的迭代。 有了明确可量化的目标后，模型团队可以更精准地定位短板、规划优化方向。比如 GLM-5.2 在发现其「网络诊断」维度得分低后，专门在下一版本中增加了相关能力的训练。

为 Agent 产品选型提供了依据。 企业用户在选择 Agent 供应商时，不再只能看宣传材料，而是可以直接对比 Terminal Bench 分数。Terminal Bench 2.1 得分 85+ 的模型，通常在真实生产环境中的任务成功率也超过 80%。

6.2 局限与挑战

任务集的代表性有限。 Terminal Bench 2.1 主要覆盖 Linux/Shell 场景，但 Agent 的应用场景远不止终端。Windows GUI 操作、浏览器自动化、数据库客户端等场景目前覆盖不足。

「刷分」风险。 当 Terminal Bench 成为行业标准后，模型团队有动机针对评测集进行过拟合训练。这要求评测集保持持续更新和新任务的注入。

多模态 Agent 评测空白。 当前 Terminal Bench 主要处理文本命令，对于需要视觉理解（如「看截图判断服务是否正常」）、语音交互的 Agent，无法评测。

跨语言能力未充分测试。 大多数任务以 Linux shell 为载体，但如果 Agent 需要在 PowerShell、Docker CLI、Kubernetes kubectl 等不同环境中工作，Terminal Bench 的覆盖度仍不够。

6.3 未来演进方向

根据 Terminal Bench 团队在 GitHub 上的 Roadmap，2.x 版本将重点关注以下方向：

1. Browser Bench：基于 Playwright 的浏览器自动化评测，覆盖 GUI Agent 场景
2. Database Bench：针对 SQL 查询、数据分析任务的评测体系
3. Kubernetes Bench：Pod 部署、服务治理、Helm 操作的评测
4. 对抗性任务注入：增加故意「捣乱」的评测任务，测试 Agent 的鲁棒性
5. 多 Agent 协作评测：测试多个 Agent 协作完成复杂任务的效率和质量

七、实战：用 Terminal Bench 评测你的 Agent

7.1 快速上手

Terminal Bench 2.1 已开源，可以通过以下方式快速体验：

# 克隆评测框架
git clone https://github.com/TerminalBench/TerminalBench2.1.git
cd TerminalBench2.1

# 安装依赖
pip install -r requirements.txt

# 下载评测集（需要申请访问权限）
python scripts/download_dataset.py --token YOUR_TOKEN

# 运行评测
python -m terminal_bench.cli \
    --model openai/gpt-4o \
    --tasks ./tasks/v2.1 \
    --output ./results/gpt4o_results.json

# 生成报告
python -m terminal_bench.report \
    --input ./results/gpt4o_results.json \
    --format html --output ./reports/gpt4o_report.html

7.2 API 集成评测

如果你有自己的模型服务，可以通过 REST API 接入评测：

import requests
import json

class TerminalBenchAPI:
    def __init__(self, api_base: str, api_key: str):
        self.api_base = api_base
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def submit_model(self, model_name: str, provider: str) -> str:
        """注册待评测模型，返回 model_id"""
        resp = requests.post(
            f"{self.api_base}/models",
            headers=self.headers,
            json={"name": model_name, "provider": provider}
        )
        return resp.json()["model_id"]
    
    def run_evaluation(
        self,
        model_id: str,
        task_ids: list[str],
        max_steps: int = 20,
        timeout_per_step: int = 30
    ) -> dict:
        """提交评测任务"""
        resp = requests.post(
            f"{self.api_base}/evaluations",
            headers=self.headers,
            json={
                "model_id": model_id,
                "task_ids": task_ids,
                "max_steps_per_task": max_steps,
                "timeout_seconds_per_step": timeout_per_step,
                "parallel": 4  # 并发数
            }
        )
        return resp.json()  # 包含 evaluation_id
    
    def get_results(self, evaluation_id: str) -> dict:
        """获取评测结果"""
        resp = requests.get(
            f"{self.api_base}/evaluations/{evaluation_id}",
            headers=self.headers
        )
        result = resp.json()
        
        if result["status"] == "running":
            print(f"进度: {result['progress']}/{result['total_tasks']}")
            return None  # 仍在运行
        
        return result


# 使用示例：评测自定义 Agent 模型
client = TerminalBenchAPI(
    api_base="https://api.terminalbench.ai/v2",
    api_key="your_api_key"
)

# 注册模型
model_id = client.submit_model(
    model_name="my-agent-v2",
    provider="custom"
)

# 提交评测（只评测 5 星难度任务）
result = client.run_evaluation(
    model_id=model_id,
    task_ids=["TB-2026-047", "TB-2026-089", "TB-2026-123"],
    max_steps=15
)

# 轮询结果
import time
while result is None:
    time.sleep(30)
    result = client.get_results(result.get("evaluation_id"))

# 打印评测报告
print(f"Terminal Bench 2.1 综合得分: {result['overall_score']:.1f}")
print(f"规划能力: {result['dimensions']['planning']:.1f}")
print(f"工具选择: {result['dimensions']['tool_selection']:.1f}")
print(f"错误处理: {result['dimensions']['error_recovery']:.1f}")
print(f"状态管理: {result['dimensions']['state_management']:.1f}")
print(f"效率评分: {result['dimensions']['efficiency']:.1f}")

八、总结与展望

8.1 核心结论

1. Terminal Bench 2.1 是 2026 年最权威的 AI Agent 能力评测标准，它用真实终端任务替代了静态题库，让「能不能做到」变成了可量化的分数。

2. 模型在 Terminal Bench 上的表现与真实 Agent 任务成功率高度相关，得分 85+ 的模型在生产环境中通常有 80%+ 的任务完成率。

3. 评测闭环已经形成：Terminal Bench 的分数可以反过来指导模型训练，DeepSeek V4-Pro 通过这个闭环实现了 5.2 分的提升，这是传统 RLHF 难以达到的效率。

4. 评测体系本身也在进化，Browser Bench、Database Bench、Kubernetes Bench 即将补齐多场景覆盖的短板。

8.2 对开发者的建议

如果你在选型 Agent 框架：优先看目标模型在 Terminal Bench 2.1 上的分数，尤其是「错误处理」和「多步骤编排」维度，它们最能反映真实场景的可用性。

如果你在训练 Agent 模型：将 Terminal Bench 的过程奖励信号接入你的 RL 训练流程，这是目前最高效的自动化训练方式。

如果你在做 Agent 产品：用 Terminal Bench 的任务集做你自己的内部评测集，验证产品在目标场景下的真实能力边界，而不是只看宣传材料。

8.3 一个值得思考的问题

当 AI Agent 在 Terminal Bench 上拿到 95 分时，它是否真的「理解」了终端操作，还是只是在执行模式匹配？

这个问题没有标准答案。但有一点是确定的：Terminal Bench 2.1 让这个问题的讨论有了共同的基础。当各家模型的分数都在 85-90 之间徘徊时，我们就知道真正难的问题还没有被攻克；当某天所有模型都接近满分时，我们就知道 Agent 能力的下一个前沿在别处。

评测体系的进步，从来都是技术进步的先声。 Terminal Bench 2.1 正在定义 2026 年的 Agent 能力标准，而这场竞赛才刚刚开始。

参考资源

• Terminal Bench 2.1 GitHub: https://github.com/TerminalBench/TerminalBench2.1
• DeepSeek V4 评测数据: https://deepseekv4.wiki
• Artificial Analysis Intelligence Index v4.1 (2026年8月版)
• 各模型 Terminal Bench 原始评测报告（2026-08-13）