Aligned rollouts of a LIBERO-X fine-tune of GR00T-N1.7 (rohansiva/gr00t-libero-x-level123) on the LIBERO-X simulator, with K = 10 action chunks sampled at every policy inference. Sample 0 is the chunk the robot executes; the other 9 are drawn from the same observation and never executed. This is what sampling-based failure detectors such as STAC need, alongside the per-token backbone features used by representation probes (e.g. SAFE).

218 tasks (72 / 73 / 73 for LEVEL1 / LEVEL2 / LEVEL3) × 10 initial states = 2,180 episodes, all with features and all 10 samples.

This is the K=10 companion to podolinsky/gr00t-N1.7-libero-x-v2: same checkpoint, same 218 tasks, same initial states and seed (identical rollout_ids), but a separate run with a different execution horizon (8 of 16 actions per inference here, all 16 there). GR00T's flow-matching head is stochastic, so outcomes differ: 1,786 of 2,180 episodes have the same success label.

Every failure has a Gemini failure label (mode, onset, reason / recovery / prevention) and 2,170 of 2,180 episodes have keyword captions — see Labels and Failure statistics.

Benchmarks & model

LIBERO — Liu et al., Benchmarking Knowledge Transfer for Lifelong Robot Learning, arXiv:2306.03310
LIBERO-X — Wang et al., LIBERO-X: Robustness Litmus for Vision-Language-Action Models, RSS 2026, arXiv:2602.06556. Dataset: meituan/LIBERO-X.
GR00T N1 — NVIDIA, An Open Foundation Model for Generalist Humanoid Robots, arXiv:2503.14734. Base checkpoint: nvidia/GR00T-N1.7-LIBERO (libero_10); VLM backbone nvidia/Cosmos-Reason2-2B. Fine-tune: rohansiva/gr00t-libero-x-level123.
STAC — Agia et al., Unpacking Failure Modes of Generative Policies: Runtime Monitoring of Consistency and Progress, CoRL 2024, arXiv:2410.04640

Tasks

218 tasks (72 LEVEL1, 73 LEVEL2, 73 LEVEL3) — the finetune_set_v2 selection of the collecting repo, the same list as the K=1 v2 dataset. Each task has a skill and a signature (skill | object | relation | landmark); there are 8 skills and 72 signatures. The full per-task table is splits/splits.csv (level, skill, sig, room, scene, target_class, relation, landmark, compound, n_demos, file, lang, plus the split columns below).

Success rates

replan_steps = 8: GR00T predicts a 16-step chunk and 8 actions are executed per inference, so consecutive chunks overlap (the K=1 v2 dataset executed all 16). max_steps = 1200, seed 7, single RTX 4090. Success = the LIBERO-X BDDL goal predicate; every failure is unsatisfied_goal and runs to the 1200-step cap.

level	success rate	episodes
`LEVEL1`	64.3% (463/720)	720
`LEVEL2`	40.7% (297/730)	730
`LEVEL3`	22.2% (162/730)	730
all	42.3% (922/2180)	2180

The K=1 v2 run of the same tasks reached 67.1% / 46.2% / 23.8% (45.6% overall) with 16 actions executed per inference.

skill	tasks	episodes	success rate
`place_on_surface`	59	590	44.1%
`place_in_container`	47	470	37.9%
`place_relative_to_landmark`	40	400	53.5%
`stack_objects`	17	170	41.2%
`articulate_close`	17	170	28.2%
`articulate_open`	16	160	35.6%
`toggle_appliance_on`	13	130	54.6%
`toggle_appliance_off`	9	90	26.7%

Degenerate task. LEVEL3/11_EXTENSION_KITCHEN_SCENE20_LEVEL3__T104_turn_on_the_stove succeeds at control step 1 in all 10 episodes (n_control = 1, one inference): its goal predicate already holds in the initial state. The same happens in the K=1 v2 dataset. Those 10 episodes count as successes above; exclude them if that matters for your use.

Layout

<LEVEL>/<NN>_<task_stem>/ep<NNN>/
    rollout.json    metadata + per-policy clock records
    rollout.npz     the arrays below
    rollout.mp4     agentview video, 20 fps, one frame per control step
    wrist.mp4       eye-in-hand video, same timing
    labels.json     Gemini video description + failure localization (see Labels)
    labels.npz      the same phrases / failure fields as aligned arrays
    example.md      human-readable render of labels.json
manifest.csv                  one row per episode
splits/                       probe train/test splits over the 218 tasks (see Splits)
EXAMPLES.md                   all per-episode example.md cards in one file
failure_overview.png          failure-mode share + onset time (see Failure statistics)
FAILURE_ACTION_SUMMARIES.md   one row per failure: reason / recovery / prevention summaries
gemini_prompts.md             verbatim Gemini prompt templates (+ gemini_prompts.json)

The 10 episodes of the degenerate task (see Success rates) have no label files.

<LEVEL> is LEVEL1 / LEVEL2 / LEVEL3; <NN> is the 0-indexed position of the task in that level's finetune_set_v2 list.

Modalities & size


video	`rollout.mp4` (agentview) + `wrist.mp4` (eye-in-hand) — H.264, 256×256, `yuv420p`, 20 fps, one frame per control step. Vertical-flipped to a human-upright view (LIBERO-X native convention). ~0.9 GiB total.
arrays (`.npz`)	per-inference backbone features + K=10 action samples + per-control-step clocks. 2,180 files, up to 71 MiB each (~98.6 GiB).
tabular (`.csv`)	`manifest.csv` — one row per episode; `splits/splits.csv` — one row per task.

2,180 episodes, ~99.6 GiB total. 235,130 policy inferences, 1,877,831 control steps.

`rollout.npz`

Action samples (the addition over the K=1 datasets):

key	shape
`sampled_action_chunks`	`(n_policy, 10, 16, 7)` float32	all K = 10 raw chunks per inference, same observation
`predicted_action_chunks`	`(n_policy, 16, 7)` float32	the executed chunk, `== sampled_action_chunks[:, 0]`
`num_action_samples`	`()`	10
`executed_sample_index`	`()`	0

Chunks are the raw GR00T output (delta-EEF x,y,z,roll,pitch,yaw,gripper). The first replan_steps = 8 rows of sample 0 are executed.

Features, captured from the inference that produced sample 0 — the layer-16 residual stream of the Cosmos-Reason2-2B backbone (select_layer = 16 of 28), raw per-token, float16, stacked over the n_policy inferences:

key	shape	tokens
`base_image`	`(n_policy, 64, 2048)`	agentview, 8×8 after 2×2 merge
`wrist_image`	`(n_policy, 64, 2048)`	eye-in-hand, same
`language`	`(n_policy, 200, 2048)`	instruction tokens, zero-padded to 200
`language_mask`	`(n_policy, 200)` bool	real vs padding
`language_len`	`(n_policy,)` int32	real instruction token count
`state_features`	`(n_policy, 1536)`	the action head's embedded proprioceptive vector

Same feature schema as the other GR00T datasets in this family. Because the fine-tune froze the backbone, base_image / wrist_image / language are the same function of the observation as in those datasets.

Executed actions and clocks, per control step (n_control,): executed_actions (n_control, 7), control_step, sim_step, policy_step, chunk_index, video_frame_id (== control_step).

Scalars: success, replan_steps (8), n_policy, n_control, img_tokens (64), hidden (2048), control_hz (20), has_features (True).

Alignment contract

Same as the K=1 LIBERO-X datasets: sim_step == control_step for every row (native LIBERO-X --load-mode init, no settle steps); policy_step ids are sequential and each maps to a contiguous block of control steps; the executed action is the decoded chunk row,

executed_actions[t] == decode(predicted_action_chunks[policy_step[t], chunk_index[t]])

with the native LIBERO-X gripper convention (g -> sign(g) on dim 6). Every episode passed this check, and the check that predicted_action_chunks == sampled_action_chunks[:, 0], at collection time.

`manifest.csv`

One row per episode: level, task_index, task, prompt, episode, rollout_id, success, n_policy, n_control, control_hz, replan_steps, sim_failure_category, failing_predicate, elapsed_seconds, has_features, labeled_captions, labeled_failure, labeler_model, vlm_failure_onset_frame, dir. The four label columns come from the label pass (vlm_failure_onset_frame is blank for successes).

Labels

Each episode carries a Gemini gemini-3.5-flash (Batch API) description of its video and, for failures, a localized failure onset. Produced offline from rollout.mp4 + rollout.json only (no sim, no policy server). The exact prompt templates are in gemini_prompts.md / gemini_prompts.json, identical to podolinsky/groot-libero-10-features-v3 and podolinsky/pi0.5-libero-10-features-v3, and are also embedded verbatim in every labels.json under labeler.prompts. 2,170 of 2,180 episodes are labeled, including all 1,258 failures. The 10 unlabeled episodes are the degenerate one-step task: their video is a single frame, which the caption pass cannot process.

Two passes on one shared video session:

Failure localizer (fork of Dan Lawson's liberox-evals) — a coarse pass on the full video gives the failure mode (10-way taxonomy below), onset type (obvious_mistake / operator_intervention / timeout), onset time, and long + short reason / recovery / prevention strings; a second pass on a slowed ±window clip (1 clip-second = 1 rollout frame) refines the onset to a single frame (1,244 of 1,258 failures refined). Only runs on episodes the simulator scored as failures; {} for successes.
3-second keyword phrases — a second turn on the same session captions every consecutive 3 s window (2–6 word phrases), given the failure summary as context but told not to copy it in. 3–20 windows per episode (a failed episode is 60 s long).

Taxonomy (10 modes): wrong_object, wrong_target, press_failure, open_close_failure, grasp_failure, object_displacement, placement_or_insertion_failure, stuck_or_no_progress, timeout_or_insufficient_progress, other. Definitions are in gemini_prompts.md §1. The earlier 90-task LIBERO-X dataset (gr00t-N1.7-libero-x-features) was labeled with a different 8-way set and a different model, so mode counts are not directly comparable with it.

labels.json per episode: rollout_id / level / task_file / instruction / success; labeler (backend, model, refine, labeled_at, pipeline, prompts); semantic_timeline (list of {segment_index, t_start_sec, t_end_sec, control_step_start/end, policy_step_start/end, phrase, description}); vlm_failure (mode, onset type / seconds / timestamp / frame / step, coarse vs refined onset and window, confidence, justification, reason / recovery / prevention long + summary, token usage, vlm_raw_response; {} on success); failure_annotation (the onset mapped onto the collection clocks: failure_control_step, failure_sim_step, failure_policy_step, failure_chunk_index, first_post_failure_policy_step, failure_type, correction_action).

labels.npz is the array-aligned copy: sem_t_start, sem_t_end, sem_control_start, sem_control_end, sem_phrase, fail_onset_frame, fail_onset_seconds, fail_mode, fail_reason, fail_reason_summary, fail_recovery, fail_recovery_summary, fail_prevention, fail_prevention_summary.

Failure statistics

failure mode	n	% of failures	onset mean ± std (s)
wrong object	466	37.0%	5.8 ± 7.2
stuck / no progress	177	14.1%	15.5 ± 10.7
wrong target	155	12.3%	14.3 ± 9.7
object displacement	136	10.8%	15.1 ± 10.9
placement / insertion	125	9.9%	21.9 ± 10.2
grasp failure	113	9.0%	12.0 ± 9.7
open / close failure	59	4.7%	18.7 ± 11.5
press failure	19	1.5%	26.8 ± 18.5
other	5	0.4%	8.6 ± 7.4
timeout / insuff. progress	3	0.2%	60.0 ± 0.0

1,258 failures: 1,257 confidence: high, 1 medium. Onset type: obvious_mistake 1,088, operator_intervention 167, timeout 3. Overall onset 12.4 ± 11.3 s (median 9.3 s, range 0.0–60.0 s; a failed episode lasts 60 s). wrong_object is the largest mode at every level (84 of 257 failures in LEVEL1, 100 of 433 in LEVEL2, 282 of 568 in LEVEL3) and has the earliest onset. Per-failure reason / recovery / prevention summaries are in FAILURE_ACTION_SUMMARIES.md.

Splits (`splits/`)

Three probe train/test splits over the 218 tasks, increasing in difficulty (leave-task-out < leave-signature-out < leave-skill-out: skill-out removes a whole primitive from training; signature-out keeps the skill, just not that exact object / relation / landmark combination). They govern what a success/failure probe trains on vs. is evaluated on; the policy was run identically on all 218 tasks regardless of split.

split	train / test tasks	held out
`leave_task_out/`	175 / 43	20% of task instances, stratified by skill (seed 0); the same signatures remain in train
`leave_signature_out/`	162 / 56	16 whole signatures (~20% per skill, capped so no skill loses more than half); every skill still appears on both sides — `held_out_signatures.txt` lists which
`leave_skill_out/<skill>/`	159–209 / 9–59	one of the 8 skills entirely; all 8 folds provided

Each split's train.txt / test.txt lists BDDL filenames. Strip .bddl to get the task column of manifest.csv and join on that to select episodes (task names are unique across levels). splits/splits.csv carries the per-task metadata plus split_leave_task_out / split_leave_signature_out columns; leave-skill-out membership is the skill column. leave_skill_out/toggle_appliance_off has only 9 test tasks: that is the whole skill.

Provenance

Collected with scripts/baselines/stac/collect_groot_libero_x.py in the 12-Visual-Occlusion-Reasoning project against a local GR00T policy server (openpi-style msgpack websocket wrapping gr00t.policy.Gr00tPolicy, embodiment LIBERO_PANDA, features on), checkpoint rohansiva/gr00t-libero-x-level123. At each inference the server is queried K = 10 times on the same observation. Native convention, max_steps = 1200, replan_steps = 8, seed 7, env_resolution = 256. 0 alignment-gate failures, 0 errors across 2,180 episodes. rollout.json records the server's self-reported policy name as gr00t-n1.7-libero_10 (the base it wraps); the weights are the level123 fine-tune, recorded under checkpoint. Labels: the scripts/semantic_failure/ batch labeler (label_run.py --batch, Gemini Batch API); statistics: scripts/semantic_failure/build_failure_stats.py.