README.md

metadata

license: other
license_name: mixed-research-use
license_link: LICENSE.md
pretty_name: ContextProgress-Bench
language:
  - en
task_categories:
  - video-classification
  - robotics
tags:
  - robotics
  - progress-estimation
  - reward-modeling
  - progress-reward-model
  - embodied-ai
  - video
  - benchmark
size_categories:
  - n<1K
configs:
  - config_name: episodes
    data_files:
      - split: test
        path: episodes.jsonl
    default: true
  - config_name: subtasks
    data_files:
      - split: test
        path: subtasks.jsonl

ContextProgress-Bench

ContextProgress-Bench is the benchmark of ProgressCompass: Embodied Progress Reward Models Are Lost Without the Right Context. It tests context-dependent progress estimation: robot-manipulation episodes in which the current frame alone cannot tell how far the task has come, because progress depends on what happened earlier.

🌐 Project page · 📄 Paper (arXiv) · 💻 Code: coming soon

Every task needs at least one of three forms of context:

• State Recall: a fact needed for progress, such as which mat a block came from, was visible earlier and has left the frame.
• Sequence Tracking: steps follow a fixed order, and one frame does not show which are done.
• Recurrence Disambiguation: repeated actions produce look-alike frames at very different progress.

Tasks (hand-selected)	24
Episodes (5 sampled at random per task)	120
Annotated ground-truth subtask clips	552
Frames	71,708
Duration	45.1 min
Sources	RMBench, RoboDojo, LIBERO-Mem

What is in the paper

The paper runs a paired diagnosis of five Progress Reward Models (PRMs) on this benchmark. Each PRM keeps its own input format in both runs; without context it scores the full episode under the episode instruction, and with context it scores each annotated subtask clip under that subtask's instruction. Without context, every PRM is far off (MAE 15.6–31.0 on a 0–100 scale), even those that read the whole history; with the right context, each cuts its error by 77–82%. ProgressCompass then supplies that context to a frozen PRM with general-purpose VLMs, and cuts the error of RoboMeter-4B from 25.4 to 9.3.

Quick start

from datasets import load_dataset
from huggingface_hub import snapshot_download

episodes = load_dataset("Sterzhang/ContextProgress-Bench", "episodes", split="test")   # 120 rows
subtasks = load_dataset("Sterzhang/ContextProgress-Bench", "subtasks", split="test")   # 552 rows
print(episodes[0]["instruction"], episodes[0]["subtask_boundaries"])

root = snapshot_download("Sterzhang/ContextProgress-Bench", repo_type="dataset")       # videos, ~225 MB
video_path = f"{root}/{episodes[0]['video']}"

episodes.jsonl and subtasks.jsonl are flat indexes over the per-episode manifest.json files described below; the video field is a path relative to the repository root.

Ground-truth progress

For an episode with subtasks [s_k, e_k), k = 0 … K−1, the progress of frame f in subtask k is

p(f) = (k + (f - s_k) / (e_k - 1 - s_k)) / K          # 0 at the first frame, 1 at the last

so progress rises linearly within each subtask and every subtask has the same weight. The ten episodes with a gt_progress field (all of RMBench/observe_and_pickup and RoboDojo/match_and_pick_from_conveyor) use delayed_linear progress instead: 0 until start_frame, then linear to 1 at end_frame. See gt_progress. Scores are reported on a 0–100 scale.

---

This repository holds the task data of the benchmark. It contains no baseline predictions and no model outputs.

The data is stored in its final, ready-to-read form: using the benchmark requires no build, copy, or instruction-processing step.

Everything needed to use the benchmark is in this directory and described below.

Scope

Tasks	24
Episodes per task	5
Full-task videos	120
Ground-truth subtask clips	552
Frames	71,708
Duration	2,705.67 s (45.09 min)

Where the videos come from

None of the videos were recorded for this benchmark. Every episode is taken from one of three publicly released robot-manipulation datasets and re-cut into ground-truth subtask clips here. Tasks are grouped by that source dataset, which is the one partition every episode belongs to exactly once.

Source	Tasks	Episodes	GT clips	Frames	Duration	FPS	What it is
RMBench	9	45	224	29,018	967.27 s	30	Memory-dependent robotic manipulation benchmark; simulated manipulation tasks.
RoboDojo	13	65	308	39,610	1584.40 s	25	Unified sim-and-real benchmark for generalist robot manipulation policies.
Liberomem	2	10	20	3,080	154.00 s	20	Memory-sensitive task suite built on LIBERO, a lifelong robot-learning benchmark.

Citations for the three sources are in References at the end of this file.

What this benchmark adds on top of the source videos:

• the selection of which episodes to include;
• the ground-truth subtask boundaries, derived per source as described in Ground-truth subtask boundaries and reviewed by hand;
• rewritten per-subtask and main instructions; and
• the per-task inventory and statistics tabulated here.

The video frames themselves are unmodified. Anyone redistributing this directory is also redistributing data from the three datasets above, so check their terms before publishing it.

Directory structure

ContextProgress-Bench/
├── RMBench/
├── RoboDojo/
└── Liberomem/

Each holds its tasks:

<Source>/<Task>/demo_clean/episodes/<Episode>/

cover_blocks and swap_blocks each exist under both RMBench and RoboDojo. They are different tasks with different recordings, and the source directory keeps them apart.

What each task tests

Progress in these tasks cannot be read off the current frame alone; something earlier in the episode is needed. The column below names the form of context a task primarily demands:

• State Recall — a fact needed for progress was visible earlier and is no longer observable in the current frame.
• Sequence Tracking — steps follow a fixed order, so progress requires knowing which steps are done and which comes next.
• Recurrence Disambiguation — look-alike frames sit at very different progress, so a repeated event must be told apart from its earlier occurrences.

This label is the primary demand, not an exclusive one. Most episodes require more than one of the three, and a single instruction can give rise to all three at once. The label records which form a task was selected to stress; it does not mean the other two are absent. Counts of tasks or episodes per form therefore do not partition the benchmark and will sum to more than 24 and 120 respectively. Earlier versions of this directory encoded the label as a top-level Count/, Sequence/, State/ split, which wrongly implied a partition; the split has been removed and the label kept here.

Each manifest.json also carries the label in its primary_setting field.

RMBench

Task	Primary setting	What the task is	GT clips
classify_blocks	Recurrence Disambiguation	Sort two colour classes of blocks into the left and right baskets, completing the first colour before the second and moving one block at a time.	30
cover_blocks	State Recall	Cover three coloured blocks from left to right, then uncover them in red-to-green-to-blue colour order.	30
observe_and_pickup	State Recall	Remember the reference object on a shelf and, after it is occluded, pick up the matching object from a set on the table.	10
place_block_mat	State Recall	Move each red block onto the green mat and return it to its original blue mat, processing the blocks from left to right.	30
press_button	Recurrence Disambiguation	Press the left and middle buttons according to two visible counts, then press the right confirmation button once. Every press is an independent event.	45
put_back_block	State Recall	Move a block from its starting mat to the space between two mats, press the button, then return the same block to its original mat.	15
rearrange_blocks	Sequence Tracking	Move the block between two blue mats onto the empty mat, press the button, then move the block that started on a mat into the space between the mats.	15
storage_blocks	Recurrence Disambiguation	Store all blocks in a basket. Two arms may handle two blocks simultaneously, followed by any remaining single block.	29
swap_blocks	State Recall	Use the empty mat to complete three block transfers, then press the button.	20

RoboDojo

Task	Primary setting	What the task is	GT clips
classify_objects	Sequence Tracking	Sort the episode's object classes into three baskets in the specified category order, moving one object at a time.	33
cover_blocks	State Recall	Cover three coloured blocks with cups from left to right, then uncover them in the colour order given by the instruction.	30
fill_egg_holder	Recurrence Disambiguation	Place four eggs into the holder one at a time, then close the holder lid.	25
fill_pen_holder	Sequence Tracking	Insert five pens into the pen holder in the colour order given by the instruction.	25
hang_mugs	Sequence Tracking	Hang three mugs on the rack in right-to-middle-to-left spatial order.	15
insert_tubes	Sequence Tracking	Insert three matching pieces in the specified middle-to-right-to-left order.	15
match_and_pick_from_conveyor	State Recall	Remember the first reference object on the conveyor and pick up its later matching instance after distractor objects appear.	5
organize_table	Sequence Tracking	Place an alarm clock, figurine, mouse and keyboard at their destinations in the required order.	20
pack_objects_into_box	Sequence Tracking	Put four distinct objects into a box in the order given by the instruction.	20
play_stacking_toy	Sequence Tracking	Place all ten toy pieces onto the corresponding pegs according to shape and colour priority.	50
sort_nesting_dolls_by_size	Sequence Tracking	Arrange five nesting dolls from smallest to largest.	25
store_laptop_and_headphones	Sequence Tracking	Place the headphones on their stand, close the laptop, then place the laptop in the vertical stand.	15
swap_blocks	State Recall	Track the changing source and destination states across three block transfers and press the button after each transfer.	30

Liberomem

Task	Primary setting	What the task is	GT clips
cream_cheese_empty_basket	State Recall	Put the cream-cheese block into the specified basket, then pick up the other basket, which remains empty.	10
cream_cheese_filled_basket	State Recall	Put the cream-cheese block into the specified basket, then pick up that same basket, which now contains the block.	10

Task counts by primary setting — again, these are primary labels, not a partition:

Primary setting	Tasks	Episodes
State Recall	10	50
Sequence Tracking	10	50
Recurrence Disambiguation	4	20

Episode structure

<Source>/<Task>/demo_clean/episodes/<Episode>/
├── full_video.mp4
├── manifest.json
└── subtasks/
    └── subtaskNN/
        ├── video.mp4
        └── instruction.json

• full_video.mp4 — the complete task video.
• manifest.json — identifiers, the main instruction, frame count, fps, the provenance of the subtask boundaries, and one entry per ground-truth subtask giving its frame range and instruction.
• subtasks/subtaskNN/ — one ground-truth subtask clip cut from the full video, with the instruction for that segment.

Every task has exactly five episodes, episode1 through episode5. Subtask directories are consecutive and zero-padded from subtask00. Episodes carry between 1 and 11 ground-truth subtasks.

Frame rates differ by source: RMBench 30 fps, RoboDojo 25 fps, Liberomem 20 fps. Code that samples by time rather than by frame index must read fps from the manifest.

Episode numbering

episode1–episode5 are benchmark IDs assigned here. The source datasets use their own non-contiguous IDs, which earlier versions of this directory used directly. The original ID is preserved in two places:

• the original_episode field of every manifest.json and every subtasks/*/instruction.json; and
• episode_id_mapping.json, a machine-readable map for all 24 tasks.

Source	Task	Original IDs for episode1 … episode5
Liberomem	cream_cheese_empty_basket	1 , 2 , 4 , 7 , 8
Liberomem	cream_cheese_filled_basket	1 , 2 , 5 , 7 , 9
RMBench	classify_blocks	7 , 9 , 11 , 14 , 18
RMBench	cover_blocks	6 , 12 , 16 , 17 , 19
RMBench	observe_and_pickup	0 , 2 , 4 , 12 , 19
RMBench	place_block_mat	4 , 10 , 14 , 15 , 16
RMBench	press_button	1 , 5 , 13 , 18 , 19
RMBench	put_back_block	2 , 8 , 9 , 11 , 18
RMBench	rearrange_blocks	0 , 7 , 14 , 16 , 19
RMBench	storage_blocks	0 , 1 , 13 , 16 , 18
RMBench	swap_blocks	0 , 7 , 12 , 15 , 17
RoboDojo	classify_objects	0 , 1 , 3 , 4 , 5
RoboDojo	cover_blocks	1 , 2 , 5 , 8 , 12
RoboDojo	fill_egg_holder	1 , 5 , 6 , 7 , 10
RoboDojo	fill_pen_holder	1 , 2 , 9 , 11 , 12
RoboDojo	hang_mugs	1 , 3 , 7 , 8 , 15
RoboDojo	insert_tubes	0 , 1 , 3 , 9 , 16
RoboDojo	match_and_pick_from_conveyor	5 , 7 , 12 , 15 , 19
RoboDojo	organize_table	0 , 4 , 6 , 7 , 10
RoboDojo	pack_objects_into_box	8 , 12 , 13 , 16 , 19
RoboDojo	play_stacking_toy	1 , 3 , 5 , 7 , 13
RoboDojo	sort_nesting_dolls_by_size	0 , 6 , 8 , 9 , 19
RoboDojo	store_laptop_and_headphones	3 , 9 , 10 , 16 , 19
RoboDojo	swap_blocks	9 , 10 , 14 , 17 , 18

The source datasets, and any analysis produced before this renumbering, refer to episodes by their original IDs.

Manifest fields

Field	Meaning
dataset, task	source dataset and task name
primary_setting	the form of context this task primarily demands (see above); not exclusive
episode	the benchmark ID, episode1–episode5
original_episode	the episode ID in the source dataset
main_instruction	the instruction for the full video
source_video	always full_video.mp4
source_frame_count, fps	length and frame rate of the full video
boundary_source	how the ground-truth subtask boundaries were derived
subtasks	one entry per ground-truth subtask: subtask_id, start_frame, end_frame_exclusive, instruction
source	Liberomem only: the originating LIBERO-Mem task, episode, HDF5 file and demo ID

Subtask ranges are half-open: start_frame is included and end_frame_exclusive is not. The ranges tile the full video without gaps, so the last subtask's end_frame_exclusive equals source_frame_count.

gt_progress — read this before computing ground truth

Ten episodes carry an extra gt_progress object, and evaluation code must honour it: all five episodes of RoboDojo/match_and_pick_from_conveyor and all five of RMBench/observe_and_pickup. No other task uses the field:

"gt_progress": {
  "mode": "delayed_linear",
  "start_frame": 366,
  "end_frame": 442,
  "value_before_start": 0.0,
  "reason": "Observation and memorization are not physical progress. Progress starts when the robot begins the final pickup."
}

Both tasks open with a phase in which the robot only observes and memorises — watching a reference object pass on the conveyor, or waiting for the target to be occluded — and that waiting is not physical progress. Ground-truth progress therefore stays at value_before_start (0.0) for every frame before start_frame, then rises linearly to 1.0 at end_frame.

Code that derives ground truth from the subtasks boundaries alone will score these ten episodes against the wrong curve. The other 110 episodes have no gt_progress field and use the subtask boundaries directly.

Ground-truth subtask boundaries

Every episode stores its full video, main instruction, manifest, and segmented ground-truth subtask videos. Boundary provenance differs by source:

• RMBench — most tasks use cumulative frame lengths from the original language annotation. storage_blocks uses placement events followed by video review of basket visibility. place_block_mat uses video-validated action midpoints derived from the original segment boundaries.
• RoboDojo — candidate boundaries are aligned from LeRobot gripper and action signals, then reviewed episode by episode. A fixed action order is reused only after cross-episode endpoint review.
• Liberomem — boundaries begin from HDF5 gripper-release transitions, are shifted to the first frame in which the block is visibly separated from the gripper or begins falling, and are then human-reviewed.

The number of clips under subtasks/, the boundaries in manifest.json, and the clip counts tabulated above can therefore be cross-checked per episode.

References

[1] T. Chen et al., "RMBench: Memory-Dependent Robotic Manipulation Benchmark with Insights into Policy Design," arXiv preprint arXiv:2603.01229, 2026. DOI: 10.48550/arXiv.2603.01229.

[2] T. Chen et al., "RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies," arXiv preprint arXiv:2607.04434, 2026. DOI: 10.48550/arXiv.2607.04434.

[3] B. Liu et al., "LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning," Advances in Neural Information Processing Systems 36, Datasets and Benchmarks Track, 2023. DOI: 10.52202/075280-1939.

[4] N. Chung et al., "Rethinking Progression of Memory State in Robotic Manipulation: An Object-Centric Perspective," Proceedings of the AAAI Conference on Artificial Intelligence, vol. 40, no. 5, pp. 3407-3415, 2026. DOI: 10.1609/aaai.v40i5.37337.

License

The videos are re-cut, unmodified frames from three public datasets and keep the terms of their sources: RMBench, RoboDojo and LIBERO-Mem (built on LIBERO). Use them for research, and check each source's terms before any other use. Our annotations (episode selection, subtask boundaries, rewritten instructions, manifests and indexes) are released under CC BY 4.0. See LICENSE.md.

Citation

@article{zhang2026progresscompass,
  title   = {ProgressCompass: Embodied Progress Reward Models Are Lost Without the Right Context},
  author  = {Zhang, Jianshu and Wu, Keliang and Qian, Chengxuan and Yang, Xiyuan and Zhang, Ce
             and Tian, Ariel and Liu, Anbang and Lu, Haoran and Liu, Han},
  journal = {arXiv preprint arXiv:2609.36684},
  year    = {2026}
}

Please also cite the source datasets listed in References.