13.3 基准测试

本节介绍学术基准的选择与应用、在自有系统上的复现方法、基准评估报告的生成以及 NIST 标准化倡议的最新进展。

13.3.1 学术基准概览

智能体系统的评估需要接轨学术研究，建立可对标的基准。主要基准包括：

GAIA

来源：Meta-FAIR, Meta-GenAI & Hugging Face(2023)

特点：

• 三个难度等级(Level 1-3)

• 强调推理和工具使用的综合能力

• 人类表现远超当前最强模型

数据分布：

Level 1: 基础任务(简单推理+单工具)
Level 2: 中等任务(多步推理+多工具协作)
Level 3: 困难任务(长链推理+复杂工具组合)
总计: 466个任务

任务类型：

• 文件系统操作（解压、搜索、分析）

• 网页浏览与信息提取

• 数学计算与推理

• 多步骤问题解决

WebArena

来源：CMU（2023，发表于 ICLR 2024）

特点：

• 812 个现实网站任务

• 涵盖电商、社交论坛、协作软件开发、内容管理四大官方领域

• 需要真实交互（不是模拟）

任务分类（四大官方领域，合计 812 个任务）：

电商(OneStopShop):     购物、订单、评价类任务
社交论坛(Reddit 风格):  发帖、搜索、互动类任务
协作开发(GitLab):      仓库、Issue、合并请求类任务
内容管理(CMS):         店铺运营、内容维护类任务

SWE-Bench

来源：Princeton University（发表于 ICLR 2024；OpenAI 后续合作推出 SWE-bench Verified）

SWE-bench Verified：由 OpenAI Preparedness 团队于 2024 年 8 月发布，包含 500 个经过人工验证的高质量 issue-PR 对，从 SWE-Bench 原始 2294 个任务中精选。筛选标准是问题描述足够明确（非欠规格）、且 FAIL_TO_PASS 单元测试不会误判正确的修复，每个样本由三位标注者独立审查，是评估 Agent 代码理解和修改能力的重要基准。

特点：

• 原始 SWE-Bench：2,294 个真实 GitHub 问题

• Verified 版本：500 个经人工验证的高质量子集

• 需要修改代码、运行测试

• 评估代码理解与修改能力

评估维度：

• 是否通过 FAIL_TO_PASS 测试（问题确实被修复）

• 是否保持 PASS_TO_PASS 测试通过（未引入回归）

AgentBench

来源：Tsinghua University（发表于 ICLR 2024）

特点：

• 8 个官方环境（操作系统、数据库、知识图谱、数字卡牌、横向思维谜题、家务模拟、网购、网页浏览）

• 模拟真实工作场景

领域分布（下表为便于讲解的示意分布及任务量级，非 AgentBench 官方任务划分）：

知识库操作:   200 任务
数据库操作:   300 任务
Web浏览:      350 任务
文件操作:     200 任务
API调用:      200 任务
邮件管理:     100 任务
日程安排:     97 任务

13.3.2 在自有系统上复现基准

以上四大基准（GAIA、WebArena、SWE-Bench、AgentBench）提供了多维度的评测标准，但如何在自己的系统上高效地复现这些基准、收集性能指标是后续工作的关键。本节介绍了基准复现的具体方法和工具支持。

1. 构建 GAIA 的子集

GAIA 基准的实现代码：

import json
import random
from pathlib import Path

class GAIABenchmark:
    """GAIA基准实现"""

    def __init__(self, data_dir: str = "./data/gaia"):
        self.data_dir = Path(data_dir)
        self.tasks = self._load_tasks()

    def _load_tasks(self) -> dict:
        """加载GAIA任务"""
        tasks = {"level1": [], "level2": [], "level3": []}

        for level in ["level1", "level2", "level3"]:
            level_dir = self.data_dir / level
            if level_dir.exists():
                for task_file in level_dir.glob("*.json"):
                    with open(task_file) as f:
                        task = json.load(f)
                        tasks[level].append(task)

        return tasks

    def get_sample(self, level: str, size: int = 10) -> list:
        """获取该等级的样本"""
        tasks = self.tasks.get(level, [])
        return random.sample(tasks, min(size, len(tasks)))

    async def run_evaluation(self, agent, level: str, size: int = 10):
        """在该等级上运行评估"""
        tasks = self.get_sample(level, size)
        if not tasks:
            return {
                "level": level,
                "success_rate": 0.0,
                "total": 0,
                "results": [],
                "warning": f"No GAIA tasks found for {level} in {self.data_dir}",
            }
        results = []

        for task in tasks:
            try:
                # 执行任务
                result = await agent.execute(
                    instruction=task["instruction"],
                    ground_truth=task.get("ground_truth")
                )

                # 评估
                is_correct = self._evaluate_task(result, task)
                results.append({
                    "task_id": task["id"],
                    "correct": is_correct,
                    "result": result
                })
            except Exception as e:
                results.append({
                    "task_id": task["id"],
                    "correct": False,
                    "error": str(e)
                })

        # 计算成功率
        success_rate = sum(1 for r in results if r["correct"]) / len(results)
        return {
            "level": level,
            "success_rate": success_rate,
            "total": len(results),
            "results": results
        }

    def _evaluate_task(self, result, task) -> bool:
        """评估任务是否正确"""
        # 简化:字符串匹配
        ground_truth = task.get("ground_truth", "")
        return ground_truth.lower() in str(result).lower()

# GAIA基准评估使用示例
benchmark = GAIABenchmark()

# 在Level 1上测试
level1_results = asyncio.run(benchmark.run_evaluation(agent, "level1", size=10))
print(f"Level 1 Success Rate: {level1_results['success_rate']:.1%}")

2. WebArena 风格子集评估

下面是一个 WebArena 风格的 toy adapter，用于展示评估接口。官方 WebArena 是自托管环境，覆盖在线购物、论坛、协作开发和企业内容管理等站点；真实评测应对齐官方任务和环境，而不是直接使用下列示意域名。

class WebArenaBenchmark:
    """WebArena基准实现"""

    def __init__(self, domain: str = "ecommerce"):
        """
        domain: 'ecommerce', 'social_media', 'forum', 'government'
        """
        self.domain = domain
        self.tasks = self._get_sample_tasks()

    def _get_sample_tasks(self) -> list:
        """获取示例任务"""
        tasks = {
            "ecommerce": [
                {
                    "id": "shop_001",
                    "instruction": "在Amazon上搜索'笔记本电脑',按价格从低到高排序",
                    "expected_steps": ["navigate", "search", "sort"],
                    "ground_truth": "sorted by price ascending"
                },
                {
                    "id": "shop_002",
                    "instruction": "添加商品到购物车并查看总价",
                    "expected_steps": ["add_to_cart", "view_cart"],
                    "ground_truth": "total price displayed"
                }
            ],
            "social_media": [
                {
                    "id": "social_001",
                    "instruction": "在Twitter上发布一条包含#AgentBench标签的推文",
                    "expected_steps": ["navigate", "compose", "post"],
                    "ground_truth": "tweet posted"
                }
            ]
        }
        return tasks.get(self.domain, [])

    async def run_evaluation(self, agent, size: int = 5):
        """运行评估"""
        tasks = self.tasks[:size]
        results = []

        for task in tasks:
            try:
                # 模拟网页交互
                trajectory = await agent.interact_with_web(
                    instruction=task["instruction"]
                )

                # 检查是否完成了预期步骤
                completed_steps = [step for step in task["expected_steps"]
                                 if step in [call.tool_name for call in trajectory]]

                success = len(completed_steps) == len(task["expected_steps"])

                results.append({
                    "task_id": task["id"],
                    "success": success,
                    "steps_completed": len(completed_steps),
                    "steps_expected": len(task["expected_steps"])
                })
            except Exception as e:
                results.append({
                    "task_id": task["id"],
                    "success": False,
                    "error": str(e)
                })

        success_rate = sum(1 for r in results if r["success"]) / len(results)
        return {
            "domain": self.domain,
            "success_rate": success_rate,
            "total": len(results),
            "results": results
        }

13.3.3 基准评估报告生成

基准报告不应只给出一个分数。对于第三方或可对外引用的评测，报告还应说明：本次评测主张属于能力激发、安全防护还是模型比较；被测系统的 harness、工具、上下文、护栏、turn/token/retry/time/cost 预算是什么；是否做过 reward hacking、拒答掩盖、样本污染、坏题和 sandbagging 检查；人工复核样本如何影响最终判定。否则读者无法判断分数是模型能力上限、某个 harness 下的当前表现，还是评测设置本身的产物。

实现如下：

import json
from datetime import datetime
import pandas as pd

class BenchmarkReport:
    """基准评估报告"""

    def __init__(self, agent_name: str):
        self.agent_name = agent_name
        self.results = []
        self.timestamp = datetime.now().isoformat()

    def add_result(self, benchmark_name: str, metrics: dict):
        """添加评估结果"""
        self.results.append({
            "benchmark": benchmark_name,
            "metrics": metrics,
            "timestamp": datetime.now().isoformat()
        })

    def generate_report(self, output_file: str = "benchmark_report.json"):
        """生成报告"""
        report = {
            "agent_name": self.agent_name,
            "generated_at": self.timestamp,
            "benchmarks": self.results,
            "summary": self._compute_summary()
        }

        with open(output_file, "w") as f:
            json.dump(report, f, indent=2)

        return report

    def _compute_summary(self) -> dict:
        """计算汇总统计"""
        success_rates = [r["metrics"].get("success_rate", 0) for r in self.results]

        return {
            "avg_success_rate": sum(success_rates) / len(success_rates) if success_rates else 0,
            "best_benchmark": max(self.results, key=lambda x: x["metrics"].get("success_rate", 0))
                             ["benchmark"] if self.results else None,
            "benchmarks_count": len(self.results)
        }

    def to_dataframe(self) -> pd.DataFrame:
        """转为DataFrame用于分析"""
        data = []
        for result in self.results:
            row = {"benchmark": result["benchmark"]}
            row.update(result["metrics"])
            data.append(row)
        return pd.DataFrame(data)

    def print_summary(self):
        """打印汇总"""
        summary = self._compute_summary()
        print(f"\n{'='*60}")
        print(f"Agent: {self.agent_name}")
        print(f"Generated: {self.timestamp}")
        print(f"{'='*60}")
        print(f"\nBenchmark Results:")
        print(f"{'Benchmark':<20} {'Success Rate':<15}")
        print(f"{'-'*35}")

        for result in self.results:
            benchmark = result["benchmark"]
            sr = result["metrics"].get("success_rate", 0)
            print(f"{benchmark:<20} {sr:>6.1%}")

        print(f"\n{'='*60}")
        print(f"Average Success Rate: {summary['avg_success_rate']:.1%}")
        print(f"Best Performing: {summary['best_benchmark']}")
        print(f"{'='*60}\n")

# 综合基准评估使用示例
report = BenchmarkReport("MiniHarness-v1.0")

# 评估GAIA
gaia_benchmark = GAIABenchmark()
level1_result = asyncio.run(gaia_benchmark.run_evaluation(agent, "level1", size=10))
report.add_result("GAIA Level 1", {"success_rate": level1_result["success_rate"]})

# 评估WebArena
web_benchmark = WebArenaBenchmark("ecommerce")
web_result = asyncio.run(web_benchmark.run_evaluation(agent, size=5))
report.add_result("WebArena E-commerce", {"success_rate": web_result["success_rate"]})

# 生成报告
report.generate_report()
report.print_summary()

13.3.4 NIST AI 智能体标准化倡议

NIST 发起 AI 智能体标准化倡议，当前公开材料聚焦标准制定、开源协议社区、安全与身份研究等方向。下面的维度和代码是本书用于工程评估的示意性映射，不代表 NIST 已发布的合规 API 或标准任务集合。

标准化维度

1. 功能分类：

   • 任务类型（信息检索、事务处理、推理等）

   • 能力等级（基础、中级、高级）

   • 复杂度度量

2. 安全评估：

   • 对抗鲁棒性

   • 隐私保护

   • 可解释性

3. 性能评估：

   • 任务成功率

   • 效率指标

   • 成本效益

4. 可靠性评估：

   • 错误处理能力

   • 恢复能力

   • 一致性

合规性检查

具体实现如下：

class AgentStandardsReadiness:
    """示意性的智能体标准化准备度检查"""

    def __init__(self):
        self.requirements = {
            "functional_classification": False,
            "safety_assessment": False,
            "performance_evaluation": False,
            "reliability_assessment": False,
            "documentation": False,
            "testing_coverage": False,
        }

    def check_compliance(self, system) -> dict:
        """检查系统合规性"""

        results = {
            "functional_classification": self._check_function_classification(system),
            "safety_assessment": self._check_safety(system),
            "performance_evaluation": self._check_performance(system),
            "reliability_assessment": self._check_reliability(system),
            "documentation": self._check_documentation(system),
            "testing_coverage": self._check_testing(system),
        }

        compliance_score = sum(results.values()) / len(results)
        results["overall_compliance"] = compliance_score

        return results

    def _check_function_classification(self, system) -> float:
        """功能分类评估"""
        # 检查系统是否有明确的任务分类
        return 0.8 if hasattr(system, "task_categories") else 0.0

    def _check_safety(self, system) -> float:
        """安全评估"""
        # 检查是否有安全防护
        has_permissions = hasattr(system, "permission_engine")
        has_sandboxing = hasattr(system, "sandbox")
        return (has_permissions + has_sandboxing) / 2

    def _check_performance(self, system) -> float:
        """性能评估"""
        # 检查是否有性能指标
        return 0.7 if hasattr(system, "metrics") else 0.0

    def _check_reliability(self, system) -> float:
        """可靠性评估"""
        # 检查是否有错误处理和恢复机制
        has_error_handling = hasattr(system, "error_handler")
        has_recovery = hasattr(system, "recovery_mechanism")
        return (has_error_handling + has_recovery) / 2

    def _check_documentation(self, system) -> float:
        """文档检查"""
        # 检查是否有完整文档
        return 0.8  # 假设有文档

    def _check_testing(self, system) -> float:
        """测试覆盖率检查"""
        # 检查是否有测试套件
        return 0.75 if hasattr(system, "test_suite") else 0.0

# 使用
compliance = AgentStandardsReadiness()
results = compliance.check_compliance(harness_system)

print(f"智能体标准化准备度评分: {results['overall_compliance']:.1%}")
for criterion, score in results.items():
    if criterion != "overall_compliance":
        print(f"  {criterion}: {score:.1%}")

13.3.5 基准评估的最新动态

智能体评估基准在持续演进，以下是值得关注的最新进展：

SWE-bench / Terminal-Bench 演进：SWE-bench Verified 仍是 500 个经过人工筛选的问题子集，适合做软件工程 Agent 的回归参考；OpenAI 发布 GPT-5.2-Codex 时则重点报告了 SWE-Bench Pro 与 Terminal-Bench 2.0 等更贴近真实终端任务的结果。这一趋势再次印证了 Harness 工程的重要性——同一底座模型在不同 Harness、工具权限和执行环境中的表现差异巨大。具体分数应以排行榜或厂商发布页的查询日期为准。

长时任务的时间跨度：与上述以“单题成功率”为核心的基准互补，METR 在《Measuring AI Ability to Complete Long Tasks》中提出“任务完成时间跨度”（task-completion time horizon）——把能力刻画为智能体在给定成功率阈值（其公开页同时报告 50% 与 80% 两档）下能够独立完成的人类专家任务时长，前沿模型大致呈现每约七个月翻倍的趋势（具体跨度不宜写死，以 METR 报告为准）。这一视角对 Harness 工程尤为贴切：真正延长可达时间跨度的往往不是底座模型本身，而是上下文管理、任务持久化、错误恢复与预算调度等 Harness 能力——正是它们决定了长链推理中的错误累积能被压制多远。由此，时间跨度也可视为对 14.3.1 节所述“可靠性的理论上限”的一种可度量的经验刻画。

GAIA Level 3：作为通用 AI 助手能力的高阶测试，GAIA Level 3 一度由 Writer 的 Action Agent 以 61%（2025-03）领跑，此后 HAL 等公开排行榜上的成绩仍在持续刷新；该层级远低于人类水平的得分，反映出复杂多步骤任务仍然是智能体的瓶颈。

评估资源整合：Phil Schmid 整理了 50+ 智能体评估基准的合集，涵盖代码生成、网页导航、工具使用、多步推理等维度。对于 Harness 工程师而言，选择与自身场景匹配的基准进行定期回归测试，比追求单一排行榜排名更有价值。

行业采用差距：根据 LangChain《State of Agent Engineering》报告，虽然 89% 的组织已部署可观测性，但系统化评估的采用率仅为 52%。这意味着近半数的生产级智能体缺乏客观的质量度量——这是 Harness 工程亟需填补的空白。

---

本节总结：基准测试将自有系统与学术标准对标，GAIA、WebArena、SWE-Bench、AgentBench 涵盖了智能体系统的多个维度。NIST 标准化倡议标志着该领域走向成熟。