Hugging Face's logo

Datasets:
datapointai
/
robot-policy-human-preferences-55k

Tasks:
Robotics
Reinforcement Learning
Modalities:
Tabular
Text
Video
Formats:
parquet
Languages:
English
Size:
10K - 100K
Tags:
robotics
vision-language-action
vla
human-feedback
human-preferences
preference-learning
Libraries:
Datasets
Dask
Polars
License:
Dataset card Data Studio Files
xet
 Community

You need to agree to share your contact information to access this dataset

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

You agree to use this dataset under the CC-BY-4.0 license with attribution to Datapoint AI, and you agree not to attempt to re-identify annotators. The robot video clips are derived from Apache-2.0 robot evaluation recordings published on the Hugging Face Hub (see Source data).

Log in or Sign Up to review the conditions and access this dataset content.

Robot policy human preferences: 55K votes across 5 robot foundation models

This dataset contains 54,940 validated pairwise votes, exactly 10 for each of 5,494 pairs of real robot runs. Each pair shows two policy models attempting the same task from a matched starting layout on the same bimanual robot. The votes compare 5 vision-language-action models (MolmoAct 2, OpenVLA-OFT, π0.5-DROID, Cosmos Policy, X-VLA) on 8 manipulation tasks, judged by 7,130 annotators in 156 countries. Every run is included as an MP4 clip.

Built on the Datapoint annotation platform.

Key features

  • Ten judges on every pair. Each pair of runs was judged by 10 people, so every comparison carries a preference margin rather than a single label.
  • Same task, same start. All five models attempted the same 8 tasks on the same bimanual YAM robot. Within each task, runs were paired by matching their first frames, so most pairs start from the same object layout.
  • Real robots, not simulation. The 2,861 clips are real autonomous runs (27.5 hours at real speed) taken from robot evaluation recordings published on the Hugging Face Hub by allenai and Jiafei1224 (see Source data). We ran our own human evaluation on the raw videos. Tasks come in two conditions: in-distribution layouts and out-of-distribution layouts and objects.
  • Blind judging. Annotators saw two unlabeled clips, the task, and one question: "Which robot did the task better?" Model names were never shown.
  • Uniform presentation. Every clip is the top camera, trimmed to the run, played at 2x speed with a 1.5 second hold on the final frame, encoded as a 640×360 H.264 MP4 without audio.
  • Every clip included. The default videos config embeds all 2,861 clips once, with a typed Video column; pairs join to them by key.

Tasks

Task Shown to annotators Clips Pairs Split
candy_sorting Sort the candies into the boxes by type. 369 727 train
cup_stacking Stack the cups inside one another, largest to smallest. 334 607 test
cup_storing Put the cups into the container. 361 700 train
pegboard Hang the tools on the pegboard. 367 707 train
pipette Attach a tip to the pipette. 361 710 train
popcorn_microwave Open the microwave and put the popcorn packet inside. 346 654 train
test_tubes Move the test tubes onto the tray. 369 712 train
toy_storing Put the toys on the shelf. 354 677 train

Video preview

The same starting layout for "Sort the candies into the boxes by type," run by three of the models:

MolmoAct 2

OpenVLA-OFT

π0.5-DROID

Dataset structure

Config Rows Description
videos (default) 2,861 One MP4 clip per robot run, with source and format metadata
pairs 5,494 One pair of runs with vote counts, labels, and the winner
responses 54,940 One individual human vote
tasks 8 One task with the instruction shown and the source instructions
models 5 One model with its identifier and developer

videos

Column Type Description
video video The MP4 clip, decoded by the datasets library on access
video_key string {model_id}/{task_id}/{condition}/e{episode} join key used by pairs
model_id, task_id, condition string Policy, task, and in_distribution or out_of_distribution
source_dataset, source_episode_index string/int The Ai2 LeRobot dataset and episode the clip was cut from
camera, playback_speed string/float top camera, played at 2.0x
source_duration_seconds, duration_seconds float Run length at real speed, and clip length as shown
codec, pixel_format, width, height, fps, frame_count, byte_size mixed Encoding metadata
sha256 string SHA-256 digest of the MP4 bytes

pairs

Column Type Description
pair_key string Unique pair identifier
task_id, condition string Task and condition
model_a, model_b string The two policies being compared. Screen side was randomized
video_a_key, video_b_key string Join keys into the videos config
start_layout_distance float First-frame distance used to match the runs. Lower means a closer starting layout
votes_a, votes_b int Vote counts used by the leaderboard; they sum to 10
label_a, label_b float Preference fractions. Ties are 0.5/0.5
trust_weighted_votes_a, trust_weighted_votes_b float Vote counts weighted by trust score
winner string a, b, or tie
num_votes int Total votes for the pair (10)

responses

Each row is one human vote. The config holds exactly the 10 validated votes per pair that the Elo fit consumed.

Column Type Description
pair_key string Joins to pairs
task_id, condition string Task and condition
chosen string a or b, the run the annotator preferred
annotator string Salted hash. Stable across the dataset, not linkable to accounts
trust_score float Annotator trust score (0 to 1) when the vote was cast
time_taken_ms int Time spent on the judgment. The median is about 32 seconds
completed_at timestamp When the vote was cast
country string Annotator country (ISO 3166-1 alpha-2)

Splits

The videos, pairs, responses, and tasks configs have train and test splits. The test split holds out one whole task, cup_stacking, chosen with a fixed seed. No task or clip appears in both splits, so a reward model trained on train can be evaluated on an unseen task. models is a reference table.

Usage 

from datasets import load_dataset

pairs = load_dataset("datapointai/robot-policy-human-preferences-55k", "pairs", split="train")
row = pairs[0]
print(row["task_id"], row["model_a"], "vs", row["model_b"], "->", row["winner"], f'({row["votes_a"]}-{row["votes_b"]})')

Train a robot reward or preference model

With 10 votes per pair you can keep only decisive comparisons:

tasks = {t["task_id"]: t["instruction_shown"] for t in load_dataset("datapointai/robot-policy-human-preferences-55k", "tasks", split="train")}
MIN_MARGIN = 0.7  # keep pairs where the winner took >= 7 of 10 votes

def to_pref(row):
    confidence = max(row["label_a"], row["label_b"])
    if row["winner"] == "tie" or confidence < MIN_MARGIN:
        return None
    chosen, rejected = ("a", "b") if row["winner"] == "a" else ("b", "a")
    return {"task": tasks[row["task_id"]], "chosen": row[f"video_{chosen}_key"],
            "rejected": row[f"video_{rejected}_key"], "confidence": confidence}

pref_rows = [d for d in (to_pref(r) for r in pairs) if d]

Get the clips 

from datasets import Video

videos = load_dataset("datapointai/robot-policy-human-preferences-55k", "videos", split="train")
videos = videos.cast_column("video", Video(decode=False))  # raw MP4 bytes; decoding needs torchcodec
position = {key: i for i, key in enumerate(videos["video_key"])}
clip = videos[position[pref_rows[0]["chosen"]]]["video"]["bytes"]

The source_dataset and source_episode_index columns point to the original LeRobot recordings on the Hub, which also hold the left and right cameras, joint states, and actions at full speed.

Leaderboard

Elo ratings from a Bradley–Terry fit on raw votes, centered so the 5 models average 1000. Rank spread shows the ranks each model can hold within its 95% bootstrap interval.

Robot policy Elo rankings: 5 robot policies ranked by Elo score

The chart shows the live leaderboard, which gives each of the 8 tasks an equal share of the fit. The table below fits all votes at once, so its values differ by less than 2 Elo points.

Rank Model Elo Rank spread Win rate
1 MolmoAct 2 1082.5 1–1 64.0%
2 OpenVLA-OFT 1048.8 2–2 58.5%
3 π0.5-DROID 1033.5 3–3 55.9%
4 Cosmos Policy 947.0 4–4 41.0%
5 X-VLA 888.2 5–5 31.3%

The order is the same on in-distribution and out-of-distribution layouts:

Model In-distribution Elo Out-of-distribution Elo
MolmoAct 2 1086.8 1073.7
OpenVLA-OFT 1046.4 1054.0
π0.5-DROID 1034.4 1031.5
Cosmos Policy 950.7 938.7
X-VLA 881.7 902.2

MolmoAct 2 has the highest Elo on most tasks. Per-task leaders: candy_sorting: MolmoAct 2, cup_stacking: π0.5-DROID, cup_storing: MolmoAct 2, pegboard: MolmoAct 2, pipette: OpenVLA-OFT, popcorn_microwave: MolmoAct 2, test_tubes: MolmoAct 2, toy_storing: MolmoAct 2.

51% of pairs were decided by 8 votes or more, against 11% for coin flips, and 8.8% split 5–5, against 24.6% for coin flips. Refitting with each vote weighted by its trust_score gives the same order.

Agreement with Ai2's success-rate evaluation

Ai2 reports average task scores for these five policies on the same eight tasks (MolmoAct 2 blog). The human preference ranking matches its order exactly:

Model Elo (this dataset) Rank Ai2 average score
MolmoAct 2 1082.5 1 0.51
OpenVLA-OFT 1048.8 2 0.36
π0.5-DROID 1033.5 3 0.32
Cosmos Policy 947.0 4 0.16
X-VLA 888.2 5 0.05

Pairwise votes also separate runs that all fail: X-VLA averages 0.05 in Ai2's evaluation, but annotators prefer its run in 31% of its comparisons, crediting partial progress that a binary success score does not record.

Comparison to related work

This dataset RoboArena RobotArena∞
Human judgments 54,940 votes 2,672 A/B preferences 8,749 votes
Judges per pair 10 1 (the evaluator who ran the session) not reported
Robot runs 2,861 real 9,589 real simulated (real-to-sim)
Policies 5 15 not reported
Votes released yes yes no

Intended use

Use this dataset to:

  • Train and evaluate reward, preference, or progress models for robot manipulation.
  • Benchmark VLM judges of robot behavior against human consensus.
  • Study annotator agreement on robot video.
  • Audit the leaderboard.

The clips are evaluation runs, sped up 2x for judging. They are not a training corpus for robot policies; use the source recordings for that. Don't use this dataset to attempt to identify annotators.

Source data

The robot runs come from 80 LeRobot evaluation datasets on the Hugging Face Hub, released under Apache-2.0. We cut each run from its source recording and ran our own human evaluation on the videos.

Hub account Source datasets Clips in this dataset
allenai 60 2,403
Jiafei1224 20 458

Each clip's source_dataset and source_episode_index columns name the exact dataset and episode it was cut from.

All 80 source datasets

License

Votes, labels, and all metadata are released under CC-BY-4.0. The video clips are derived from the recordings listed under Source data, released by their publishers under Apache-2.0. We trimmed each clip to its run, kept only the top camera, re-encoded it at 640×360, sped it up 2x, and added a 1.5 second final-frame hold. The clips remain under Apache-2.0; a copy of the license is in LICENSE-APACHE-2.0.

Acknowledgments

The robot runs were published on the Hugging Face Hub by the Allen Institute for AI (allenai) and by Jiafei1224.

More Datapoint datasets

Citation 

@dataset{datapoint_robot_policy_preferences_2026,
  title   = {Robot Policy Human Preferences 55K},
  author  = {{Datapoint AI}},
  year    = {2026},
  url     = {https://huggingface.co/datasets/datapointai/robot-policy-human-preferences-55k},
  note    = {54,940 pairwise votes over 5 robot policies and 8 tasks, 10 votes per pair}
}
Downloads last month
28
Total file size:
2.09 GB