README.md

---
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