ComponentBench

Diagnosing Component-Level Failures in Computer-Use Agents

ComponentBench is a diagnostic benchmark for computer-use agents that targets the middle layer between atomic GUI-grounding tests (e.g., ScreenSpot) and long-horizon workflow benchmarks (e.g., WebArena, OSWorld). It evaluates agents on individual UI component interactions — toggling button groups, setting sliders, using date pickers — that are short enough to diagnose specific failures but rich enough to reflect real modern web interfaces.

• Companion code repository: https://github.com/TianchenGuan/ComponentBench
• Live benchmark site: https://www.interfacegym.com
• Log viewer (published runs): https://www.interfacegym.com/?mode=log (v1), https://www.interfacegym.com/?mode=log&bench=v2 (v2)

Overview

Metric	Value
Canonical component types	97
Interaction families	14
Tasks — Full (v1)	2,910
Tasks — Core (v2)	912
UI libraries	3 (Ant Design, MUI, Mantine)
Observation modes evaluated	4 (AX-tree, Set-of-Marks, Pixel, Browser-Use)
Task templates	24
Human reference traces	2,910 (v1) + 912 (v2)

This Hugging Face repository contains the static data assets (task definitions, human reference trajectories, derived difficulty annotations, and ontology metadata). The benchmark itself runs through the Next.js site in the companion code repository — tasks are served at /task/<taskId>?mode=benchmark and a hidden DOM banner (#cb-success-banner) provides programmatic success verification.

Repository layout

ComponentBench/
├── tasks/
│   ├── v1/     # 97 YAML files — the Full benchmark (2,910 tasks)
│   └── v2/     # 19 YAML files — the Core benchmark (912 harder tasks)
├── human_traces/
│   ├── human_traces_v1_clean.tar.zst   # cleaned v1 reference trajectories
│   └── human_traces_v2_clean.tar.zst   # cleaned v2 reference trajectories
├── difficulty/
│   ├── realized_axes__audit_*.jsonl        # 7-axis difficulty scores per task
│   ├── realized_features__audit_*.jsonl    # raw features (≤24 per task)
│   ├── realized_thresholds__audit_*.json   # normalization parameters
│   └── qa_report__audit_v2.json            # audit QA report (v2 algorithm)
└── metadata/
    ├── canonical_components.csv  # 97 component types × family / role
    ├── difficulty_axes.csv       # 7 difficulty axes definitions
    └── task_templates.csv        # 24 task templates

Splits

ComponentBench provides two task suites that share an ontology but differ in scope:

• v1 / Full (2,910 tasks): broad coverage across 97 canonical component types and three libraries (Ant Design, MUI, Mantine). Designed for diagnostic comparisons of observation modes and models.
• v2 / Core (912 tasks): a smaller, harder benchmark organized around 19 interaction-centered generation units with richer designed factors (theme, density, disabled states, advanced controls). Recommended for tracking frontier model progress.

v1 is the default; v2 is not a strict superset.

Task YAMLs (tasks/v1/, tasks/v2/)

Each YAML file groups tasks of a single canonical component type. Per task:

• id, name, canonical_type, implementation_source (antd / mui / mantine)
• browsergym_goal: the natural-language instruction shown to the agent
• difficulty: designed difficulty bucket / tier
• scene_context: theme, density, disabled flags, and other controlled factors
• success_condition: the programmatic check (mirrored by the live site's success banner)

Task IDs are stable across versions and follow <type>-<library>-T<NN>, e.g. accordion-antd-T01.

Human reference traces (human_traces/)

Recorded through the live site's /record interface and normalized to match agent action format. Each tar.zst archive contains one trace.jsonl per task with step-by-step actions (click, type, key, drag, scroll), viewport dimensions, and timing.

The cleaning pipeline merges adjacent typing keystrokes into single type actions so step counts are directly comparable with agents that paste text in one step. Numbers from the difficulty report:

Suite	Tasks	Avg normalized steps	Avg duration
v1	2,910	2.7	—
v2	912	5.21	8.3 s

To unpack: tar -I zstd -xf human_traces_v1_clean.tar.zst

Difficulty annotations (difficulty/)

Important naming convention: the audit_v1 / audit_v2 suffix refers to the audit algorithm version, not the benchmark version. All audit outputs cover the v1 (Full) benchmark, 2,910 tasks each.

• audit_v2_FINAL — current canonical audit (24 features → 7 axes), used in the paper.
• audit_v1, audit_v1.1, audit_v1.2 — earlier iterations, retained for reproducibility / provenance.

Per task, the audit reports:

• axis_scores_continuous: real-valued scores in [0, 1] on 7 axes (precision_requirement, target_acquisition, density_choice_interference, depth_layering, feedback_dynamics, semantic_observability, disambiguation_load)
• axis_ratings_1to5: integer ratings derived from the continuous scores
• tier: L0 / L1 / L2 / L3
• bucket: easy / mid / hard

If you only want one file: use realized_axes__audit_v2_FINAL.jsonl. Reference: difficulty_axes.csv.

Metadata (metadata/)

• canonical_components.csv — 97 component types with their interaction family, role, and source-library availability
• difficulty_axes.csv — definitions of the 7 difficulty axes
• task_templates.csv — 24 task templates with brief descriptions

Usage

from datasets import load_dataset

# (Coming) Once we publish a loading script the dataset will be loadable with:
# ds = load_dataset("TianchenGuan/ComponentBench", "v1")

# For now: download files directly via huggingface_hub.
from huggingface_hub import snapshot_download
local_dir = snapshot_download(repo_id="TianchenGuan/ComponentBench", repo_type="dataset")

To actually evaluate agents, clone the companion code repository:

git clone https://github.com/TianchenGuan/ComponentBench.git
cd ComponentBench
pip install -e . && playwright install chromium
cd site && npm install && npm run prebuild && npm run dev
# In another shell:
python scripts/run_benchmark.py --mode pixel --canonical_types button --libraries antd --max_tasks 2

Headline results (paper)

ComponentBench-Core (912 tasks), task success rate (%):

Model	Browser-Use	AX-tree	SoM	Pixel
Gemini 3 Flash	95.2	89.6	87.1	85.4
GPT-5.4	90.4	81.5	77.0	83.8
GPT-5 mini	87.0	83.1	78.5	49.0
UI-TARS-1.5-7B	—	—	—	12.6

Key finding: varying the observation or action space can shift task success by over 30 percentage points within a single model — GPT-5 mini degrades from 87.0% (Browser-Use) to 49.0% (pixel-only).

Citation

@inproceedings{componentbench2026,
  title={ComponentBench: Diagnosing Component-Level Failures in Computer-Use Agents},
  author={Anonymous},
  booktitle={COLM},
  year={2026}
}

License

MIT