File size: 7,522 Bytes
360df42 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | ---
license: mit
language:
- en
task_categories:
- other
tags:
- computer-use-agents
- gui-agents
- benchmark
- web-agents
- browser-agents
- componentbench
pretty_name: ComponentBench
size_categories:
- 1K<n<10K
---
# 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/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
```python
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:
```bash
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
```bibtex
@inproceedings{componentbench2026,
title={ComponentBench: Diagnosing Component-Level Failures in Computer-Use Agents},
author={Anonymous},
booktitle={COLM},
year={2026}
}
```
## License
MIT
|