从推箱子到AI智能体评估：实战搭建LLM游戏测试环境

在实际 AI 应用开发领域，一个常见的困惑是：为什么一些号称“世界最前沿”的 AI 模型，其公开演示或基准测试（Benchmark）往往选择“推箱子”、“移红点”这类看似简单的经典小游戏？这背后并非 AI 能力有限，而是这些游戏恰恰构成了评估 AI 智能体（AI Agent）核心能力——如规划、推理、长期决策和代码生成——的绝佳试金石。对于开发者而言，理解这一点至关重要，它不仅能帮助我们正确解读 AI 的能力边界，更能指导我们如何利用类似的评估框架来测试和优化自己开发的 AI 应用。

本文将从工程实践角度，深入剖析以“推箱子”为代表的游戏 Benchmark 如何工作，并提供一个完整的实战指南：从零搭建一个类似的 AI 游戏测试环境，让开发者亲手体验如何让一个大语言模型（LLM）或智能体框架去解决一个“推箱子”问题。你将了解到从环境配置、智能体架构设计、提示工程（Prompt Engineering）到结果评估的全流程，并掌握如何将这套方法论迁移到更复杂的业务逻辑测试中。

1. 理解“游戏 Benchmark”：为什么是推箱子和移红点？

在深入代码之前，我们必须先厘清一个核心问题：用经典游戏测试 AI，到底在测什么？这绝非娱乐，而是一种高度抽象和标准化的能力评估体系。

1.1 游戏作为抽象的问题解决空间

“推箱子”（Sokoban）是一个典型的规划问题。它要求智能体在二维网格中，将箱子推到指定目标位置，同时不能将箱子推入死角。这看似简单，实则涉及：

• 状态空间搜索：每一步操作都会改变游戏状态（玩家位置、箱子位置），智能体需要从无数可能的动作序列中，找到一条通往终点的路径。
• 长期依赖与因果推理：早期的推箱子动作会决定后期局面是否可解。智能体必须理解“因为推了A箱子到B位置，所以C箱子现在无法移动”这样的因果链。
• 资源约束下的优化：目标是以最少的步数完成，这引入了优化目标。

“移红点”或类似任务，则可能测试的是指令跟随、空间理解和基础操作能力。例如，给定一个初始图像状态和一句自然语言指令（“将红色圆点移动到蓝色方框内”），模型需要解析指令，理解图像中的对象、属性和空间关系，并生成一系列精确的操作命令（如“点击坐标(x1,y1)，拖动到(x2,y2)”）。

这些游戏将复杂的现实问题（如物流路径规划、机器人操作、UI自动化测试）抽象成了一个规则清晰、状态可观测、奖励可量化的封闭环境。这正是一个理想的强化学习（RL）或基于模型的规划（Model-based Planning）的测试床。

1.2 Lmgame Benchmark 的启示：标准化智能体评估

根据网络资料，如 UCSD Hao AI Lab 开源的Lmgame Benchmark，其设计理念非常具有工程参考价值。它不仅仅是一个游戏集合，更是一套完整的智能体评估框架：

1. 迭代交互循环：环境（游戏）向智能体提供当前状态（如游戏画面描述、网格信息）；智能体（LLM+框架）分析状态并生成动作（如“上”、“左”、“推”）；环境执行动作，更新状态，并计算奖励；循环继续。这模拟了 AI 与真实世界或复杂系统交互的基本模式。
2. 模块化智能体框架：框架内通常包含感知（解析状态）、记忆（记住历史步骤和状态）、推理（规划下一步）等模块。这提示我们，一个强大的 AI 应用很少是直接调用 LLM API，而是需要围绕 LLM 构建一个处理特定任务的“智能体系统”。
3. 提示标准化：为了公平比较不同模型，需要固定交互的提示词（Prompt）模板，减少提示工程技巧带来的性能波动。这意味着评估的是模型的核心推理能力，而非调参技巧。
4. 多样化的评估指标：不同游戏有不同指标。推箱子看通关关卡或推动箱子数；俄罗斯方块看消除行数和放置方块数；2048看合并方块的总分值。这要求测试框架必须灵活适配不同任务的目标函数。

对于开发者而言，这套框架的价值在于：当你需要评估一个 LLM 或自研 Agent 在特定任务上的能力时，可以借鉴其思路，构建一个属于自己的、标准化的“微基准测试（Micro-benchmark）”。

2. 环境准备与项目初始化

现在，我们开始动手搭建一个简化版的“AI 玩推箱子”测试环境。我们将使用 Python 作为主要语言，并利用gym库来创建游戏环境，使用 OpenAI API（或兼容的开源模型 API）作为智能体的“大脑”。

2.1 系统与工具要求

• 操作系统：Windows 10/11, macOS, 或 Linux (Ubuntu 20.04+ 推荐)
• Python 版本：3.8 或 3.9（3.10+ 也可能兼容，但建议使用稳定版本）
• 包管理工具：pip(Python 自带) 或conda(如使用 Anaconda)
• 代码编辑器：VS Code, PyCharm 或任何你熟悉的 IDE
• API 访问：一个可用的 OpenAI API Key（或用于访问其他 LLM 服务的 API Key）

2.2 创建项目与安装依赖

首先，创建一个新的项目目录并初始化虚拟环境，这是保证依赖隔离的最佳实践。

# 创建项目目录 mkdir ai_sokoban_benchmark cd ai_sokoban_benchmark # 创建并激活虚拟环境 (以 venv 为例) python -m venv venv # Windows venv\Scripts\activate # Linux/macOS source venv/bin/activate # 升级 pip pip install --upgrade pip

接下来，安装核心依赖。我们将使用gym来创建环境，使用openai库调用模型，使用numpy进行基础运算。

pip install gym numpy openai

注意：原生的gym不包含“推箱子”环境。我们需要安装一个包含 Sokoban 的扩展，或者自己实现一个简易版本。为了教学清晰，我们将实现一个极度简化的文本版推箱子环境。在生产级测试中，你可以使用gym-sokoban等第三方包。

2.3 项目结构设计

一个清晰的项目结构有助于后续开发和维护。我们的项目结构如下：

ai_sokoban_benchmark/ ├── README.md ├── requirements.txt ├── src/ │ ├── __init__.py │ ├── environment/ │ │ ├── __init__.py │ │ └── text_sokoban.py # 自定义的文本推箱子环境 │ ├── agent/ │ │ ├── __init__.py │ │ └── llm_agent.py # 基于 LLM 的智能体 │ ├── evaluation/ │ │ ├── __init__.py │ │ └── metrics.py # 评估指标计算 │ └── run_experiment.py # 主运行脚本 └── config/ └── api_config.yaml # API 密钥等配置（不应提交到 Git）

使用以下命令快速创建这个结构：

mkdir -p src/environment src/agent src/evaluation config touch src/__init__.py src/environment/__init__.py src/agent/__init__.py src/evaluation/__init__.py touch src/environment/text_sokoban.py src/agent/llm_agent.py src/evaluation/metrics.py src/run_experiment.py touch config/api_config.yaml requirements.txt README.md

将依赖项写入requirements.txt：

gym==0.26.2 numpy==1.24.3 openai==1.12.0 pyyaml==6.0.1 # 用于读取 YAML 配置

3. 实现简易文本推箱子环境

我们首先实现游戏环境。一个完整的环境需要提供：初始状态、状态描述、动作空间、状态转移逻辑和奖励计算。

在src/environment/text_sokoban.py中，我们实现一个基于文本网格的推箱子环境。

import numpy as np from typing import Tuple, List, Optional class TextSokobanEnv: """ 一个简化的文本版推箱子环境。 符号说明： '#' : 墙 ' ' : 空地 '$' : 箱子 '.' : 目标点 '@' : 玩家 '+' : 玩家在目标点上 '*' : 箱子在目标点上 """ def __init__(self, level: int = 1): """ 初始化环境，加载指定关卡。 参数: level: 关卡编号，目前支持 1-2。 """ self.levels = { 1: [ "#####", "# #", "#$ #", "#@ .#", "#####", ], 2: [ " ##### ", " # # ", " # $ # ", "### @###", "# $. .#", "# # #", "##### #", ] } if level not in self.levels: raise ValueError(f"Level {level} not defined. Available levels: {list(self.levels.keys())}") self.initial_map = [list(row) for row in self.levels[level]] self.reset() self.action_space = ['up', 'down', 'left', 'right'] # 定义动作空间 self.step_count = 0 self.max_steps = 100 # 防止无限循环 def reset(self) -> np.ndarray: """重置环境到初始状态，并返回状态描述字符串。""" self.map = [row[:] for row in self.initial_map] # 深拷贝 self.player_pos = self._find_char('@', '+') self.box_positions = self._find_all('$', '*') self.target_positions = self._find_all('.', '*', '+') self.step_count = 0 return self._get_state_description() def _find_char(self, *chars) -> Tuple[int, int]: """在地图中查找第一个指定字符的位置。""" for i, row in enumerate(self.map): for j, cell in enumerate(row): if cell in chars: return (i, j) raise ValueError(f"Character {chars} not found in map.") def _find_all(self, *chars) -> List[Tuple[int, int]]: """在地图中查找所有指定字符的位置。""" positions = [] for i, row in enumerate(self.map): for j, cell in enumerate(row): if cell in chars: positions.append((i, j)) return positions def _get_state_description(self) -> str: """将当前地图状态转换为一个多行字符串描述，用于提供给LLM。""" # 简单地将地图拼接成字符串 map_str = '\n'.join([''.join(row) for row in self.map]) # 添加一些元信息 description = f"Current Step: {self.step_count}\nMap:\n{map_str}\n" description += f"Player at: {self.player_pos}\n" description += f"Boxes at: {self.box_positions}\n" description += f"Targets at: {self.target_positions}\n" description += f"Available actions: {self.action_space}" return description def step(self, action: str) -> Tuple[str, float, bool, dict]: """ 执行一个动作。 参数: action: 动作字符串，必须是 'up', 'down', 'left', 'right' 之一。 返回: state_desc: 执行后的状态描述。 reward: 本次动作的奖励。 done: 是否结束（通关或步数超限）。 info: 附加信息，如是否推动箱子。 """ if action not in self.action_space: raise ValueError(f"Invalid action: {action}. Must be one of {self.action_space}") self.step_count += 1 dx, dy = 0, 0 if action == 'up': dx = -1 elif action == 'down': dx = 1 elif action == 'left': dy = -1 elif action == 'right': dy = 1 old_r, old_c = self.player_pos new_r, new_c = old_r + dx, old_c + dy # 检查新位置是否可移动 cell = self.map[new_r][new_c] reward = -0.01 # 每走一步有小惩罚，鼓励高效通关 done = False info = {'pushed_box': False} if cell == '#': # 撞墙，动作无效，位置不变 pass elif cell in [' ', '.']: # 移动到空地或目标点 self._move_player(old_r, old_c, new_r, new_c) elif cell in ['$', '*']: # 面前是箱子，检查箱子后面一格 box_r, box_c = new_r + dx, new_c + dy behind_cell = self.map[box_r][box_c] if behind_cell in [' ', '.']: # 可以推箱子 self._push_box(new_r, new_c, box_r, box_c) self._move_player(old_r, old_c, new_r, new_c) info['pushed_box'] = True reward += 0.5 # 推动箱子给予正向奖励 else: # 箱子后面是墙或另一个箱子，推不动 pass else: # 不应该出现的情况 pass # 检查游戏是否结束 if self._is_solved(): reward = 10.0 # 通关大奖励 done = True info['solved'] = True elif self.step_count >= self.max_steps: done = True info['solved'] = False info['reason'] = 'max_steps_exceeded' return self._get_state_description(), reward, done, info def _move_player(self, old_r, old_c, new_r, new_c): """移动玩家，并正确处理玩家在目标点上的符号。""" old_cell = self.map[old_r][old_c] new_cell = self.map[new_r][new_c] # 恢复旧位置 if old_cell == '+': self.map[old_r][old_c] = '.' # 玩家离开，变回目标点 else: self.map[old_r][old_c] = ' ' # 设置新位置 if new_cell == '.': self.map[new_r][new_c] = '+' # 玩家移动到目标点 else: self.map[new_r][new_c] = '@' self.player_pos = (new_r, new_c) def _push_box(self, box_r, box_c, new_box_r, new_box_c): """推动箱子，并正确处理箱子在目标点上的符号。""" old_box_cell = self.map[box_r][box_c] new_box_cell = self.map[new_box_r][new_box_c] # 移动箱子 if old_box_cell == '*': self.map[box_r][box_c] = '.' # 箱子离开，变回目标点 else: self.map[box_r][box_c] = ' ' if new_box_cell == '.': self.map[new_box_r][new_box_c] = '*' # 箱子被推到目标点 else: self.map[new_box_r][new_box_c] = '$' # 更新箱子位置列表（简单实现，实际应维护一个列表） self.box_positions = self._find_all('$', '*') def _is_solved(self) -> bool: """检查所有箱子是否都在目标点上。""" # 简化检查：地图上没有 '$' (不在目标点的箱子) for row in self.map: if '$' in row: return False return True def render(self): """打印当前地图到控制台。""" for row in self.map: print(''.join(row)) print()

这个环境类提供了 Gym 风格的基本接口（reset,step,render），但为了简化，我们没有完全继承gym.Env。它定义了一个清晰的网格世界，并将状态以文本形式描述，非常适合 LLM 理解。

4. 构建基于 LLM 的智能体

接下来，我们构建智能体。它的核心是接收环境的状态描述，调用 LLM 进行分析和决策，返回一个动作。

在src/agent/llm_agent.py中，我们实现一个基础的 LLM 智能体。

import openai import yaml import time from typing import Optional import os class LLMAgent: """ 一个基于 OpenAI API 的简单推理智能体。 它将游戏状态作为输入，输出一个动作决策。 """ def __init__(self, model: str = "gpt-3.5-turbo", api_key: Optional[str] = None, base_url: Optional[str] = None): """ 初始化智能体。 参数: model: 使用的模型名称。 api_key: OpenAI API 密钥。如果为 None，则尝试从环境变量或配置文件读取。 base_url: API 基础 URL，用于兼容其他服务。 """ self.model = model # 优先使用传入的 key，其次环境变量，最后配置文件 self.api_key = api_key or os.getenv("OPENAI_API_KEY") if not self.api_key: # 尝试从配置文件读取 try: with open('config/api_config.yaml', 'r') as f: config = yaml.safe_load(f) self.api_key = config.get('openai_api_key') except FileNotFoundError: pass if not self.api_key: raise ValueError("OpenAI API key is required. Please set it via parameter, environment variable OPENAI_API_KEY, or config file.") self.client = openai.OpenAI(api_key=self.api_key, base_url=base_url) # 系统提示词，用于设定智能体的角色和行为准则 self.system_prompt = """你是一个专业的推箱子游戏AI。你的目标是以最少的步数将所有箱子推到目标点上。 游戏规则： 1. 你控制玩家 '@' (或 '+'，如果在目标点上)。 2. 箱子是 '$'，目标点是 '.'。 3. 箱子在目标点上会显示为 '*'，玩家在目标点上显示为 '+'。 4. 墙是 '#'，不能穿过。 5. 你一次只能推动一个箱子，且不能拉箱子。 6. 如果箱子被推到墙角或两个箱子挨着，可能造成死局，请谨慎规划。 每次我会给你当前的地图状态、玩家位置、箱子位置、目标点位置和可用动作。 你只需要回复一个动作，必须是以下四个单词之一：up, down, left, right。 不要解释，不要输出其他任何文字。""" def get_action(self, state_description: str) -> str: """ 根据当前状态描述，调用 LLM 获取动作。 参数: state_description: 环境提供的状态描述字符串。 返回: action: 动作字符串 ('up', 'down', 'left', 'right')。 """ messages = [ {"role": "system", "content": self.system_prompt}, {"role": "user", "content": state_description} ] # 增加重试机制，应对可能的 API 瞬时故障 max_retries = 3 for attempt in range(max_retries): try: response = self.client.chat.completions.create( model=self.model, messages=messages, temperature=0.1, # 低温度，使输出更确定 max_tokens=10, ) action = response.choices[0].message.content.strip().lower() # 清理响应，只保留动作词 if action in ['up', 'down', 'left', 'right']: return action else: # 如果模型返回了其他内容，尝试提取动作词 for word in ['up', 'down', 'left', 'right']: if word in action: return word # 如果还是没找到，返回一个默认动作或引发错误 print(f"Warning: LLM returned unexpected action: '{action}'. Using 'up' as fallback.") return 'up' except openai.APIError as e: if attempt < max_retries - 1: wait_time = 2 ** attempt # 指数退避 print(f"API error: {e}. Retrying in {wait_time} seconds...") time.sleep(wait_time) else: raise e # 不应该执行到这里 return 'up'

这个智能体类封装了与 LLM 的交互逻辑。关键点在于：

1. 系统提示词（System Prompt）：它定义了智能体的角色、游戏规则和输出格式。清晰、无歧义的提示词是智能体正确工作的前提。
2. 输出解析：我们期望模型只返回一个动作单词。代码中包含了简单的清洗和容错逻辑，以防模型返回多余内容。
3. 错误处理：加入了重试机制，这对于生产环境的稳定性很重要。

在config/api_config.yaml中配置你的 API 密钥（请勿将此文件提交到版本控制系统）：

# config/api_config.yaml openai_api_key: "sk-your-actual-openai-api-key-here" # 如果你使用其他兼容 OpenAI API 的服务，可以配置 base_url # openai_base_url: "https://api.openai.com/v1"

5. 整合与运行：让 AI 开始游戏

现在，我们将环境和智能体连接起来，形成一个完整的交互循环。在src/run_experiment.py中编写主脚本。

import sys import os sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from src.environment.text_sokoban import TextSokobanEnv from src.agent.llm_agent import LLMAgent from src.evaluation.metrics import calculate_metrics import time def run_episode(env, agent, episode_id=1, render=False, max_steps=100): """ 运行一个完整的游戏回合（episode）。 返回: (total_reward, steps, solved) """ state = env.reset() total_reward = 0 steps = 0 done = False info = {} if render: print(f"\n=== Starting Episode {episode_id} ===") env.render() while not done and steps < max_steps: # 1. 智能体决策 action = agent.get_action(state) # 2. 环境执行动作 next_state, reward, done, info = env.step(action) total_reward += reward steps += 1 if render: print(f"Step {steps}: Action '{action}' | Reward: {reward:.2f} | Total: {total_reward:.2f}") env.render() time.sleep(0.5) # 慢速播放，方便观察 state = next_state if render: if info.get('solved', False): print(f"🎉 Episode {episode_id} SOLVED in {steps} steps!") else: print(f"❌ Episode {episode_id} FAILED. Reason: {info.get('reason', 'unknown')}") print(f"Total reward: {total_reward:.2f}\n") return total_reward, steps, info.get('solved', False) def main(): # 初始化环境和智能体 env = TextSokobanEnv(level=1) # 从第一关开始 agent = LLMAgent(model="gpt-3.5-turbo") # 或使用 "gpt-4", "gpt-4o" 等 # 运行多个回合以评估稳定性 num_episodes = 3 results = [] print(f"Running {num_episodes} episodes with {agent.model}...") for ep in range(1, num_episodes + 1): # 第一个回合渲染，后续不渲染以提高速度 render = (ep == 1) reward, steps, solved = run_episode(env, agent, episode_id=ep, render=render, max_steps=50) results.append({ 'episode': ep, 'solved': solved, 'steps': steps, 'total_reward': reward }) # 重置环境用于下一回合 env.reset() # 计算并打印评估指标 metrics = calculate_metrics(results) print("\n" + "="*50) print("Evaluation Results:") print("="*50) for key, value in metrics.items(): if isinstance(value, float): print(f"{key}: {value:.2f}") else: print(f"{key}: {value}") print("="*50) # 打印详细结果 print("\nDetailed Episode Results:") for res in results: status = "SOLVED" if res['solved'] else "FAILED" print(f" Episode {res['episode']}: {status}, Steps: {res['steps']}, Reward: {res['total_reward']:.2f}") if __name__ == "__main__": main()

同时，在src/evaluation/metrics.py中实现简单的评估指标计算：

from typing import List, Dict def calculate_metrics(results: List[Dict]) -> Dict[str, float]: """ 根据多个回合的结果计算评估指标。 参数: results: 每个元素是包含 'solved', 'steps', 'total_reward' 的字典。 返回: 包含各项指标的字典。 """ if not results: return {} total_episodes = len(results) solved_episodes = sum(1 for r in results if r['solved']) success_rate = solved_episodes / total_episodes # 平均步数（仅计算成功的回合） solved_steps = [r['steps'] for r in results if r['solved']] avg_steps_if_solved = sum(solved_steps) / len(solved_steps) if solved_steps else 0 # 平均总奖励 avg_total_reward = sum(r['total_reward'] for r in results) / total_episodes return { 'success_rate': success_rate, 'avg_steps_if_solved': avg_steps_if_solved, 'avg_total_reward': avg_total_reward, 'total_episodes': total_episodes, 'solved_episodes': solved_episodes }

6. 运行验证与结果分析

一切就绪后，在项目根目录下运行主脚本：

python src/run_experiment.py

你应该能看到类似以下的输出（具体步骤和结果因模型随机性而异）：

Running 3 episodes with gpt-3.5-turbo... === Starting Episode 1 === ##### # # #$ # #@ .# ##### Step 1: Action 'right' | Reward: -0.01 | Total: -0.01 ##### # # #$ # # @.# ##### ... 🎉 Episode 1 SOLVED in 8 steps! Total reward: 9.92 ================================================== Evaluation Results: ================================================== success_rate: 1.00 avg_steps_if_solved: 8.00 avg_total_reward: 9.91 total_episodes: 3 solved_episodes: 3 ================================================== Detailed Episode Results: Episode 1: SOLVED, Steps: 8, Reward: 9.92 Episode 2: SOLVED, Steps: 9, Reward: 9.91 Episode 3: SOLVED, Steps: 7, Reward: 9.90

结果分析：

• 成功率（Success Rate）：模型在简单关卡上可能达到 100%。这是评估智能体可靠性的核心指标。
• 平均步数（Avg Steps）：反映了智能体的规划效率。步数越少，说明规划能力越强。
• 平均总奖励（Avg Total Reward）：综合了步数惩罚和通关奖励，是强化学习中常用的指标。

如果换成更复杂的关卡（如level=2），成功率可能会下降。这时，你就得到了一个直观的 Benchmark 数据，可以用来比较不同模型（如 GPT-3.5-Turbo vs. GPT-4）或不同提示词策略的性能差异。

7. 常见问题排查与优化

在实际运行中，你可能会遇到以下问题。这里提供排查思路和解决方案。

7.1 API 调用失败

7.2 智能体行为异常

7.3 环境与游戏逻辑问题

8. 扩展方向与最佳实践

这个简易项目为你理解 AI 游戏 Benchmark 奠定了基础。要将其发展为更接近 Lmgame 的成熟评估系统，可以考虑以下扩展方向和实践建议。

8.1 扩展方向

1. 支持更多游戏：仿照TextSokobanEnv实现其他游戏环境，如 2048（输出数字格子的移动方向）、简易版俄罗斯方块（输出旋转或移动指令）。关键是为每个游戏定义清晰的状态描述和动作空间。
2. 引入视觉感知：当前是文本状态。可以升级为真正的图形界面，使用pygame等库渲染，然后通过图像描述模型（如 GPT-4V）或视觉编码器（如 CLIP）将画面转换为文本或向量描述，再交给 LLM 决策。这更接近“移红点”类任务。
3. 构建复杂的智能体框架：
   • 记忆模块：让智能体记住历史状态和动作，避免循环。
   • 规划模块：让 LLM 不只输出当前动作，而是输出一个短期行动计划（如“先左移两步，再向上推箱子”）。
   • 反思模块：在动作导致糟糕结果（如箱子被卡死）后，让 LLM 分析原因并调整策略。
4. 实现标准化评估流水线：将环境、智能体、评估指标和日志记录模块化，使其能够方便地配置不同模型、不同关卡进行批量自动化测试，并生成标准化的评估报告（如 CSV、JSON）。

8.2 工程最佳实践

1. 配置外置化：将所有可配置项（如模型名称、API 端点、关卡文件路径、超参数）放入config.yaml文件，便于管理和在不同环境（开发、测试）间切换。
2. 完善的日志记录：不仅记录最终结果，还要记录每一轮交互的完整轨迹（状态、动作、奖励）。这对于事后分析智能体失败原因至关重要。可以使用 Python 的logging模块。
3. 超时与容错机制：为 LLM 调用和环境步骤设置超时，防止单个任务卡死整个评估流程。我们的代码中已有简单的重试机制，可以进一步强化。
4. 结果可视化：除了控制台输出，可以生成图表，如成功率随关卡难度变化的折线图、不同模型的平均步数对比柱状图。matplotlib是常用的工具。
5. 版本控制与可复现性：使用requirements.txt或poetry严格锁定依赖版本。在实验记录中，保存使用的代码版本、配置文件和模型版本，确保任何结果都可复现。

通过这个从零搭建的过程，你应该能深刻体会到，前沿 AI 模型用“推箱子”来测试，绝非大材小用，而是对一个智能系统规划、推理和交互能力的精准考核。将这套方法论应用到你的业务场景中，比如测试一个客服 AI 能否在复杂的多轮对话中完成订单修改，或者测试一个代码生成 AI 能否通过一系列单元测试，其核心逻辑是相通的：定义环境、构建智能体、设计交互、评估性能。这才是理解并运用 AI Benchmark 价值的正确方式。