| --- |
| license: apache-2.0 |
| pretty_name: Video-Arena |
| language: |
| - en |
| task_categories: |
| - video-text-to-text |
| tags: |
| - video-understanding |
| - long-video |
| - games |
| - agentic |
| - spatiotemporal-reasoning |
| - benchmark |
| size_categories: |
| - n<1K |
| viewer: false |
| --- |
| |
| <div align="center"> |
|
|
| <p align="center"> |
| <img src="https://huggingface.co/datasets/THUSI-Lab/Video-Arena/resolve/main/assets/logos/affiliations.png" alt="miHoYo · Tsinghua University · University of Chinese Academy of Sciences · The University of Hong Kong" width="100%" style="width:100%;max-width:100%;"> |
| </p> |
|
|
| <h1 align="center" style="font-size:3.2em;line-height:1.1;margin:0.2em 0 0.15em;">Video-Arena</h1> |
|
|
| <h2 align="center" style="font-size:1.5em;line-height:1.3;font-weight:600;margin:0 0 0.9em;border:none;">A Scalable Agentic Video Benchmark for Spatiotemporal Capability</h2> |
|
|
| <p align="center" style="font-size:1.08em;line-height:1.8;"> |
| <b>Kuan Zhang</b><sup>1,2,*,‡</sup> <b>Yukun Chen</b><sup>1,3,*,‡</sup> <b>Zhihao Yang</b><sup>1,3,*,‡</sup> Yue Su<sup>4</sup> Xiangnan Wu<sup>3</sup><br> |
| Zirong Chen<sup>2</sup> Run Luo<sup>1,5,‡</sup> Tao Tan<sup>1</sup> <b>Yinhe Zheng</b><sup>1,†</sup> <b>Yiming Li</b><sup>2,†</sup> |
| </p> |
| |
| <p align="center" style="line-height:1.75;"> |
| <sup>1</sup>miHoYo Honkai AI R&D Team · <sup>2</sup>College AI, Tsinghua University<br> |
| <sup>3</sup>University of Chinese Academy of Sciences · <sup>4</sup>MMLab, The University of Hong Kong · <sup>5</sup>National University of Singapore |
| </p> |
| |
| <p align="center" style="font-size:0.9em;"> |
| <sup>*</sup>Equal contribution <sup>†</sup>Corresponding author <sup>‡</sup>Work done while interning at miHoYo |
| </p> |
|
|
| <p align="center"> |
| <a href="https://videoarena-bench.github.io" style="display:inline-block;margin:2px;"><img src="https://img.shields.io/badge/Project-Page-1f6feb?style=for-the-badge&logo=googlechrome&logoColor=white" alt="Project Page" style="display:inline-block;vertical-align:middle;margin:0;"></a> |
| <a href="https://arxiv.org/abs/2610.14158" style="display:inline-block;margin:2px;"><img src="https://img.shields.io/badge/arXiv-2610.14158-b31b1b?style=for-the-badge&logo=arxiv&logoColor=white" alt="arXiv 2610.14158" style="display:inline-block;vertical-align:middle;margin:0;"></a> |
| <a href="https://huggingface.co/datasets/THUSI-Lab/Video-Arena" style="display:inline-block;margin:2px;"><img src="https://img.shields.io/badge/%F0%9F%A4%97%20Dataset-THUSI--Lab%2FVideo--Arena-ffcc4d?style=for-the-badge" alt="Dataset" style="display:inline-block;vertical-align:middle;margin:0;"></a> |
| <a href="https://www.apache.org/licenses/LICENSE-2.0" style="display:inline-block;margin:2px;"><img src="https://img.shields.io/badge/License-Apache%202.0-2ea44f?style=for-the-badge" alt="License: Apache 2.0" style="display:inline-block;vertical-align:middle;margin:0;"></a> |
| </p> |
|
|
| </div> |
|
|
| <p align="center"> |
| <img src="https://huggingface.co/datasets/THUSI-Lab/Video-Arena/resolve/main/assets/teaser.jpg" alt="Video-Arena: perceive, interpret and track a hidden game state from video" width="100%"> |
| </p> |
|
|
| <p align="center"><i>Watch one long, HUD-free match and report, for every critical event, what happened (T1), how it changed the hidden game state (T2), and where that leaves the match (T3).</i></p> |
|
|
| ## Overview |
|
|
| Video-Arena asks a model to watch a full recording of a real game and reconstruct a **hidden game |
| state variable** <i>V</i><sub>t</sub> (a win probability, a net-worth lead, a score) that is never drawn on screen. |
| Scoreboards, clocks, evaluation bars, kill feeds and names are removed when the video is rendered, |
| so the only way to report <i>V</i><sub>t</sub> is to have followed the whole match. |
|
|
| - **180 cases, 9 games, 6 genres**: Go, Chess and Gomoku (board), Doudizhu (card), CS2 (FPS), |
| DOTA 2 (MOBA), StarCraft II (RTS), and Google Research Football and Badminton (sports). There are 20 cases per |
| game, about 74 hours of video and 15,278 reference tuples. |
| - **Ground truth from the game, not from annotators.** Replay and demo parsers, engine traces, |
| and pinned evaluators (KataGo, Stockfish, Rapfi, a hidden-hand PIMC estimator). |
| - **One deterministic judge per game.** Strict tuple F1 (all three tiers right, time within |
| ±3 s); no LLM judge anywhere. |
| - **Two protocols, two runtimes.** Protocol A (single-request video understanding) and Protocol B |
| (an agent in a sandbox with the video, ffmpeg and Python), each runnable natively or on |
| [Harbor](https://github.com/harbor-framework/harbor). |
|
|
| This repository is the complete release: the videos, the ground truth, the judges and the |
| evaluation code. The case-building pipelines are not released; `docs/GROUND_TRUTH.md` documents |
| how every label was produced and which engine and budget it was pinned to. |
|
|
| <p align="center"> |
| <img src="https://huggingface.co/datasets/THUSI-Lab/Video-Arena/resolve/main/assets/pipeline.jpg" alt="Video-Arena pipeline: data supply, per-game adapters, golden set, two protocols and one judge" width="100%"> |
| </p> |
|
|
| ## Files on Hugging Face |
|
|
| ```text |
| Video-Arena/ |
| |-- README.md this card |
| |-- LICENSE Apache-2.0 |
| |-- docs/ |
| | |-- PROTOCOLS.md the two protocols in full, and what a comparable run requires |
| | |-- HARBOR.md running both protocols on Harbor: image, datasets, network modes |
| | `-- GROUND_TRUTH.md per-game source, GT mechanism, V definition, engine versions |
| |-- tools/ |
| | |-- va_core.py the corpus contract: resolve, instruction_for, extract_answer, run_judge |
| | |-- score.py score an answers/ directory; --oracle / --empty self-checks |
| | |-- run_protocol_a.py native Protocol A runner (frame grid + one chat call) |
| | |-- run_protocol_b.py native Protocol B runner (sandbox + your agent command) |
| | |-- make_harbor.py build the Harbor dataset (Protocol B, or --protocol A) |
| | `-- harbor/ |
| | |-- Dockerfile the offline sandbox image (ffmpeg + Python video stack) |
| | |-- protocol_a_agent.py the Harbor agent for Protocol A |
| | `-- validate_harbor.py offline check of a generated Harbor dataset |
| `-- tasks/ |
| |-- go/ chess/ gomoku/ doudizhu/ cs2/ dota2/ sc2/ gfootball/ badminton/ |
| `-- <game>/ |
| |-- instruction.md the task: event vocabulary, V definition, answer schema |
| |-- answer_seed.json the empty answer {"events": []} |
| |-- judge.py the deterministic scorer (standard library only) |
| |-- cases.json the frozen 20 case ids, in order |
| |-- CASE_TYPES.json per-case stratification label |
| |-- media/<case_id>.mp4 the video, the only model input |
| `-- gt/<case_id>_gt.json reference tuples, for the offline scorer only |
| ``` |
|
|
| `tasks/badminton/` additionally holds `ATTRIBUTION.md` (the ShuttleSet notice). |
|
|
| | Game | Genre | Cases | Video | Avg. length (min) | Size | |
| |---|---|---:|---|---:|---:| |
| | Go | board | 20 | 612² · 25 fps | 31.8 | 5.4 MB | |
| | Chess | board | 20 | 548² · 1 fps | 31.0 | 2.3 MB | |
| | Gomoku | board | 20 | 504² · 25 fps | 3.2 | 1.0 MB | |
| | Doudizhu | card | 20 | 1280×720 · 24 fps | 4.4 | 48 MB | |
| | CS2 | FPS | 20 | 768² · 15 fps | 38.9 | 369 MB | |
| | DOTA 2 | MOBA | 20 | 768² · 15 fps | 47.8 | 813 MB | |
| | StarCraft II | RTS | 20 | 1536² · 5.6 fps | 19.4 | 2.5 GB | |
| | GFootball | sports | 20 | 1280×720 · 24 fps | 25.0 | 7.2 GB | |
| | Badminton | sports | 20 | 1280×720 · 15 fps | 19.9 | 271 MB | |
| | **Total** | | **180** | | | **≈ 11.8 GB** | |
|
|
| ## Getting Started |
|
|
| **1. Download** the whole release, or only the code plus the games you need: |
|
|
| ```bash |
| hf download THUSI-Lab/Video-Arena --repo-type dataset --local-dir Video-Arena |
| |
| # e.g. code + the three board games only (a few MB) |
| hf download THUSI-Lab/Video-Arena --repo-type dataset --local-dir Video-Arena \ |
| --include "tools/*" "docs/*" "tasks/go/*" "tasks/chess/*" "tasks/gomoku/*" |
| ``` |
|
|
| **2. Self-check the corpus and the scorer.** Python 3.8+, standard library only, no network: |
|
|
| ```bash |
| cd Video-Arena |
| python tools/va_core.py # corpus check: 9 games x 20 cases, every file present |
| python tools/score.py --oracle # ground truth fed back: all 180 cells must read 1.0 |
| python tools/score.py --empty # the empty seed: all 180 cells must read 0.0 |
| ``` |
|
|
| **3. Prepare the environment for the runs you need.** Scoring needs nothing beyond Python, but running the protocols does: |
|
|
| | To run | Needs | |
| |---|---| |
| | Protocol A, native | `ffmpeg` + `ffprobe` on PATH, and an OpenAI-compatible endpoint | |
| | Protocol B, native | the agent's whole toolset **on this machine** (see below); nothing is installed for the agent | |
| | Harbor, A or B | Docker and `harbor` (Python 3.11+); the image built from `tools/harbor/Dockerfile` carries the toolset | |
|
|
| In Protocol B the agent is told that ffmpeg, Python and the video tools are *already installed*, and is |
| forbidden to install anything. The runners never install packages. For a native Protocol B run, set |
| up the same toolset as the Harbor image, so that native and Harbor numbers are comparable: |
|
|
| ```bash |
| # Debian/Ubuntu; on macOS: brew install ffmpeg tesseract |
| sudo apt-get install -y ffmpeg tesseract-ocr tesseract-ocr-eng |
| pip install numpy scipy pandas pillow opencv-python-headless scikit-image imageio imageio-ffmpeg av matplotlib pytesseract tqdm |
| ``` |
|
|
| `run_protocol_b.py` checks this before the first cell. A missing `ffmpeg`, `ffprobe` or `python3` is a hard error; missing |
| Python modules or tesseract only print a warning. |
|
|
| ## Running the Evaluation |
|
|
| The same 180 cases are asked two ways, with identical task text: one `instruction.md` per game is |
| rendered per protocol by `va_core.instruction_for()`. Every runner writes |
| `<out>/answers/<game>/<case_id>.json`, which `tools/score.py` scores. |
|
|
| | | Protocol A · video understanding | Protocol B · agentic | |
| |---|---|---| |
| | Model input | 1 FPS frame grid, at most 256 frames, longest side 768 px, explicit timestamps | the full `match.mp4` in a sandbox, plus `instruction.md` and a seeded `answer.json` | |
| | Interaction | one request, one reply holding one JSON object; no tools | a coding agent over many turns; samples frames and writes its own tools | |
| | Budget | one call | 200 turns and 120 min per cell | |
| | Native | `tools/run_protocol_a.py` | `tools/run_protocol_b.py --agent-cmd ...` | |
| | Harbor | `make_harbor.py --protocol A` + `protocol_a_agent` | `make_harbor.py` + any Harbor agent | |
|
|
| ### Native Protocol A |
|
|
| Any OpenAI-compatible `/chat/completions` endpoint that accepts images: |
|
|
| ```bash |
| export VA_API_KEY=... |
| python tools/run_protocol_a.py --model <model> --base-url https://<endpoint>/v1 \ |
| --game all --out runs/<model>-A --workers 5 |
| python tools/score.py --answers runs/<model>-A/answers |
| ``` |
|
|
| Useful flags: `--game <name>` (repeatable), `--limit N` (first N cases per game), |
| `--reasoning-effort`, `--extra-body '{"chat_template_kwargs": {"enable_thinking": true}}'` (e.g. a |
| Qwen model on vLLM), and `--jpeg-q` for gateways with a request-body cap (the frame grid never |
| changes; `run.json` records the quality used). |
|
|
| ### Native Protocol B |
|
|
| The runner builds a fresh sandbox per cell (outside the repo, holding only the three files) and |
| runs your agent CLI inside it. The placeholders are `@PROMPT_FILE@`, `@PROMPT@` and `@SANDBOX@`. |
|
|
| ```bash |
| python tools/run_protocol_b.py --game all --out runs/<agent>-B --workers 3 \ |
| --agent-cmd "claude -p @PROMPT_FILE@ --max-turns 200" |
| python tools/score.py --answers runs/<agent>-B/answers |
| ``` |
|
|
| The agent runs on this machine with the toolset from step 3; if `--agent-cmd` starts the agent in a |
| container of its own, add `--skip-preflight`. The runner enforces the wall clock (`--timeout-min 120`). Pass the same turn cap |
| (`--max-turns 200`) to your agent's own flag. The native runner does not enforce isolation: the prompt forbids |
| network use, so audit the agent transcript afterwards, or use Harbor. |
|
|
| ### Harbor (Protocol A and B) |
|
|
| On Harbor the sandbox is offline at the network level, and the ground truth lives only in a separate |
| verifier container. The toolset is baked into the image (`python:3.11-slim` + ffmpeg, tesseract, tmux |
| and the Python video stack), because it cannot be fetched once a trial is offline. The generated datasets hold task folders only; the videos are mounted from this |
| repository. |
|
|
| ```bash |
| # the sandbox image |
| docker build -t video-arena/base:latest tools/harbor |
| export VA_MEDIA_ROOT="$PWD/tasks" # each task mounts $VA_MEDIA_ROOT/<game>/media/<case_id>.mp4 |
| |
| # Protocol B |
| python tools/make_harbor.py --out harbor/video-arena |
| python tools/harbor/validate_harbor.py harbor/video-arena |
| harbor run -p harbor/video-arena -a oracle # must score 1.0 on all 180 trials |
| harbor run -p harbor/video-arena -a terminus-2 -m <provider/model> --ak max_turns=200 -n 3 |
| |
| # Protocol A |
| python tools/make_harbor.py --out harbor/video-arena-a --protocol A |
| PYTHONPATH=tools/harbor harbor run -p harbor/video-arena-a \ |
| -a protocol_a_agent:ProtocolA -m openai/<model> -n 5 --ak reasoning_effort=high |
| ``` |
|
|
| Agents that run inside the container (`claude-code`, `codex`, ...) need the model API reachable |
| during the agent phase only. Generate with `--net phase` and add `--allow-agent-host <api host>`. |
| On Docker hosts without Harbor egress control, use `--net docker`. The agent runs as the |
| unprivileged user `agent`. [`docs/HARBOR.md`](docs/HARBOR.md) has the full details, including the |
| Protocol A agent options. |
|
|
| ## Answer Format and Scoring |
|
|
| Every game uses the same root key: an answer is `{"events": [ ... ]}`, one complete tuple per |
| row, in the schema given by that game's `instruction.md`. Each judge has one CLI: |
|
|
| ```bash |
| python tasks/<game>/judge.py --answer ANSWER.json --gt tasks/<game>/gt/<case_id>_gt.json \ |
| --out reward.json --tol 3.0 |
| ``` |
|
|
| - **Headline: strict tuple F1.** A predicted row matches a reference row when every non-temporal |
| field is equal and the time is within ±3 s. Matching is one-to-one and independent of row order. |
| - **Diagnostics:** T1 event-localization F1, T2 update accuracy and T3 state accuracy (macro-averaged). |
| - **Reporting:** the overall number is the mean of the nine game means. Quote `n_scored/n_cases`. |
| A cell that never ran is `missing`; a cell that ran and left no answer scores 0.0 and stays |
| in the mean. Protocol B trajectories are stochastic, so cite game means rather than single cells. |
|
|
| See [`docs/PROTOCOLS.md`](docs/PROTOCOLS.md) for the complete rules of a comparable run. |
|
|
| ## Data Hygiene |
|
|
| The ground truth ships in the clear so that the scorer can be inspected. Keep `gt/` out of prompts |
| and out of Protocol B sandboxes; `va_core.resolve()` hands the GT path only to the offline scorer. |
| Every `instruction.md` and `_gt.json` carries a `CANARY` line. **Please do not train on this |
| benchmark.** Case ids are permanent: a case is never renamed, and a new render gets a new id. |
|
|
| ## License |
|
|
| Video-Arena is a **purely scientific research** project. We carry out **no commercial activity** of |
| any kind with it: the benchmark is not sold, licensed for a fee, or used in any product or service. |
|
|
| - **Data (videos and ground truth): non-commercial research use only.** The renders are |
| information-reduced derivatives of game replays and game data, with no player names, faces, |
| avatars, ranks, audio or other personal data. Do not use them for commercial purposes and do not |
| train on them. |
| - **Game copyright belongs to the publishers.** All game content, copyrights and trademarks remain |
| the property of their publishers and owners, in particular Blizzard Entertainment (StarCraft II) |
| and Valve Corporation (Dota 2, Counter-Strike 2). Badminton derives from |
| [ShuttleSet](https://arxiv.org/abs/2306.04948) (MIT, © 2022 Wei-Yao Wang), and its notice in |
| `tasks/badminton/ATTRIBUTION.md` must accompany any redistribution of those renders. |
| - **Code: Apache-2.0.** The evaluation code, judges and documentation are released under the |
| Apache License 2.0. It covers our code only and grants no right to any game content. |
|
|
| `docs/GROUND_TRUTH.md` lists the sources, access dates and engine versions for every game. Please |
| read the upstream terms before use. |
|
|
| ## Citation |
|
|
| ```bibtex |
| @article{zhang2026videoarena, |
| title = {Video-Arena: A Scalable Agentic Video Benchmark for Spatiotemporal Capability}, |
| author = {Zhang, Kuan and Chen, Yukun and Yang, Zhihao and Su, Yue and Wu, Xiangnan and |
| Chen, Zirong and Luo, Run and Tan, Tao and Zheng, Yinhe and Li, Yiming}, |
| journal = {arXiv preprint arXiv:2610.14158}, |
| year = {2026} |
| } |
| ``` |
|
|
