meat000124/mhbench_handover_test

MHBench — Handover, fixed base (G1 × 2)

50 successful two-operator demonstrations of Isaac-HandoverFixed-G1x2-v0: two Unitree G1 humanoids passing a bottle across a kitchen counter, one human operator per robot, both in Meta Quest 3 headsets across a federated two-process Isaac Sim link. 17,634 frames at 50 Hz, 5.9 minutes of simulated demonstration.

Both robots stand still. What is hard here is not reaching the bottle but the exchange: only one robot holds it at a time, by design, so there is an instant where neither has a firm hold and the object's fate depends on two operators agreeing about when that instant is. The bottle also changes hands within each robot — picked up with one hand, moved to the other, then offered across — so a policy has to learn four distinct grips, not one.

Collected 2026-08-14 (c4ed0d3, dirty tree). Every success was auto-detected rather than kept by hand: mhbench.tasks.handover_fixed.mdp.bottle_placement_success held for the last 10 consecutive steps.

This release is LeRobot v2.1: parquet rows, H.264 video and meta/. It loads as it stands — point a LeRobot or GR00T dataset path at the repository root. The HDF5 archive it was exported from is not published here; it holds the sim-rate wrenches, the raw operator input and the replayable simulator states, none of which survive this format.

One channel here is computed, not measured. The wrist orientation in observation.eef_state was reconstructed by forward kinematics, because the branch this was collected on recorded wrist position without rotation. It is exact to 7.2e-05 of a degree against a task that does record it — the section Wrist orientation has the numbers. Every other column is as recorded.

Layout

meta/
  info.json         features, dtypes, per-dimension names, fps, path patterns
  modality.json     which slice of which column each key is
  episodes.jsonl    one line per episode: index, task, length
  tasks.jsonl       the three instructions (see Language)
  mhbench_provenance.json
                    which recording each episode came from, what was dropped,
                    and that the wrist rotation was computed
data/chunk-000/episode_000000.parquet   ... episode_000049.parquet
videos/chunk-000/observation.images.ego_a/episode_000000.mp4    colour
                 observation.images.ego_b/...
                 observation.images.scene/...
                 observation.depth.ego_a/...                    metres, lossless
                 observation.depth.ego_b/...
configs/operators.yaml    the legend for every meta/* integer code

meta/stats.json is not shipped: GR00T writes it on the first training run, indexed by the chunk length that run uses.

What a policy reads

NVIDIA's own G1 contract, dimension for dimension. State and action follow the unitree_g1_full_body_with_waist_height_nav_cmd embodiment shipped in Isaac-GR00T (and written by GR00T-WholeBodyControl), so a policy trained on one robot of this dataset reads and writes exactly what an upstream single-G1 policy does. The one departure is a robot_a_/robot_b_ prefix on every key, because one row here holds two robots and a LeRobot row cannot hold two left_arm keys. This is the same contract as the other MHBench task releases, so a model can be trained across them without a conversion.

State — 43 measured joint angles per robot, in seven groups, URDF order:

key	dims
{robot}_left_leg / _right_leg	6 + 6
{robot}_waist	3
{robot}_left_arm / _right_arm	7 + 7
{robot}_left_hand / _right_hand	7 + 7

Each hand is thumb_0, thumb_1, thumb_2, middle_0, middle_1, index_0, index_1.

Action — 35 per robot: joint targets for the arms, hands and waist, plus the two locomotion commands.

key	dims
{robot}_left_arm / _right_arm	7 + 7	joint targets, relative to the angles measured at the start of the chunk
{robot}_left_hand / _right_hand	7 + 7	joint targets, absolute
{robot}_waist	3	joint targets, absolute
{robot}_base_height_command	1	hip height, metres
{robot}_navigate_command	3	vx, vy, wz

The legs are in the state and not in the action. Locomotion is commanded as a velocity and a height, and the balance controller resolves the legs — the same division upstream makes. Their target columns are written all the same, so a reader can find them; no config consumes them.

Nobody walks in this task, so the two command keys are nearly constant: navigate_command is zero throughout and base_height_command is the standing 0.72 m. They are kept because the contract has them and dropping a key per task is how two datasets stop being one benchmark — but a normaliser that divides by the spread needs a guard, and meta/mhbench_provenance.json lists exactly which dimensions never move.

Also described in meta/modality.json and read by no default config, matching what the upstream generator emits plus one addition:

key	dims
{robot}_{left,right}_wrist_pos / _wrist_abs_quat	3 + 4 each	measured wrist pose, pelvis frame, wxyz (observation.eef_state); the commanded one is action.eef. See Wrist orientation
{robot}_root	7	pelvis pose, world frame, xyzw
{camera}_camera_pose	7 each	where that camera was for this row's frame, world, xyzw — what the depth is back-projected with
{robot}_wrench	12	left force, left torque, right force, right torque at the end of each control step — a real G1 has these sensors
object	7	the bottle's pose, which no robot could measure
grasp_latched	4	the magnetic latch's own state, which has no hardware counterpart

Language

Three instructions, because the roles are not symmetric — one robot gives and the other receives. annotation.human.task_description is the pair's; …_robot_a and …_robot_b are each robot's own. Each column holds a row index into tasks.jsonl, as LeRobot expects, not the sentence itself.

Pass the bottle from one end of the counter to the other with a hand-to-hand handover.

A — Pick up the bottle from the counter with your left hand, transfer it to your right hand, and hand it across to your partner.

B — Receive the bottle with your right hand, transfer it to your left hand, and set it down at the far end of the counter.

Wrist orientation is computed

observation.eef_state holds a wrist pose per hand. Its position is what the simulator measured. Its orientation is not in the recording at all: the four *_eef_rot observation terms were added to this task after these fifty demonstrations were collected, so the files carry *_eef_pos and nothing beside it. The export computes the rotation from the joint angles on the same row, walking the pelvis → waist → shoulder → elbow → wrist chain of Isaac Lab's own G1 URDF. A collection made today would record it directly, and would be byte-comparable with this one to within the figures below.

This is a derivation, not a guess, and it is checked rather than asserted:

checked against	result
CoCarry, which does record the simulator's quaternion, all 50 demos	4.9e-07 per component — 7.2e-05 of a degree — over 94,604 wrist-rows
Pinocchio on the same URDF	1.1e-16
the recorded wrist position, which pins the joint mapping this rests on	see "How it was checked"

Nothing else in the release is affected: joint angles, actions, wrenches, camera poses and depth are all as recorded, and the wrist positions in the same column are measured. meta/mhbench_provenance.json and the feature's own info block in meta/info.json both say the rotation was computed, so a consumer comparing wrist orientation across MHBench tasks can tell which is which without reading this file.

If you train the default contract, this does not reach you at all. The state a policy reads is the 43 joint angles per robot and nothing else — the wrist pose was dropped from the default in 1969d34 precisely because it is redundant with the joint angles up to forward kinematics, which is the same fact this reconstruction rests on. observation.eef_state remains in the parquet and in modality.json for a config that asks for it by name.

The demonstrations

Across all 50, with the range and the median:

	range	median
frames	298 – 459	348
bottle travel along the counter	−1.29 – −1.13 m	−1.20 m
bottle drift across the counter	−0.08 – +0.06 m	+0.00 m
robot A's hands latched	5 – 24 % of steps	9 % left, 18 % right
robot B's hands latched	9 – 22 % of steps	14 % left, 13 % right
real-time factor	0.245 – 0.289	0.278

All four hands latch in every episode, none of them for most of it: the bottle spends much of each demonstration standing on the counter or in flight between grips. The four latch fractions are the clearest signal in the release that this is a sequence of grasps rather than one sustained hold.

The scene is randomised, unlike MHBench's earlier CoCarry release. The bottle's start and the target pad are each drawn per episode over roughly a 10 cm × 10 cm square (measured spread: 0.097 m in X, 0.099 m in Y for the bottle; 0.090 × 0.096 m for the target). The target is not a number stored beside the scene — the pad's own pose is the goal, so a replayed or re-rendered episode is scored against the target it was collected with. The robots' own spawn is fixed to the millimetre.

Success requires the bottle within ±0.15 m of that episode's pad in X and Y, ±0.06 m in height, tilted under 15°, moving under 0.05 m/s and 0.15 rad/s, with every hand released for at least 0.20 s. The handoff itself is logged but does not gate: with both robots rooted and nothing else in the scene able to move the bottle, a bottle that ends up on the far pad has been handed over by construction.

Images

Five H.264 streams per episode, 240×320, one frame per row:

Video key
observation.images.ego_a	what operator A's robot saw
observation.images.ego_b	what operator B's robot saw
observation.images.scene	fixed third-person
observation.depth.ego_a	the same view in metres
observation.depth.ego_b

The ego lens is this benchmark's rather than the hardware's — 90° horizontal, 25° down, so each operator can see their own hands and the counter (mhbench.g1.cameras).

Depth

Still an ordinary h264 MP4 that any reader opens, but lossless, and its pixels are a number rather than a picture: millimetres, split across two channels, zero where the camera got no return.

import imageio.v2 as imageio, numpy as np

frames = np.stack([f for f in imageio.get_reader("videos/chunk-000/observation.depth.ego_a/episode_000000.mp4")])
metres = ((frames[..., 0].astype(np.uint16) << 8) | frames[..., 1]) / 1000.0
metres[metres == 0] = np.nan          # no return

In a video player it looks like green stripes, and that is the file being correct. B is always zero; R is the high byte, which never passes about 20 in a room this size and so renders nearly black; G is the low byte, which wraps every 256 mm — that is the banding. The stripes are the low-order millimetres, which is exactly what a viewable 8-bit depth video throws away (that one is wrong by metres; this one by 0.5 mm). Decode it and the same frame is a clean depth map. MHBench ships scripts/preview_depth_video.py to write a colourised, human-viewable copy beside it — for eyes only, never for training.

meta/info.json says the same thing per camera (depth.encoding, depth.units_per_metre, depth.invalid_value), so nothing here has to be assumed. Worst-case error is the 0.5 mm rounding — finer than the float16 the simulator recorded, past one metre.

To back-project it, each depth feature also carries its camera's intrinsics (camera.fx/fy/cx/cy, constant across the release), and observation.camera_pose carries where the camera was on every row. In this task the robots do not walk, but their torsos lean, so the ego cameras still move and a fixed extrinsic would still be wrong:

x = (u - cx) * d / fx          # right
y = (v - cy) * d / fy          # down
z = d                          # forward -- distance along the optical axis
p_world = R(quat_xyzw) @ np.stack([z, -x, -y]) + pos    # +X is the view direction

These pixels were rebuilt from recorded state after the session (scripts/restore_dataset_images.py), and they had to be. Two things the headset put in the session's own frames do not belong in a dataset:

• Robot A had no head. It is hidden during a session so it does not sit between operator A's eye and their hands (mhbench.teleop.self_occlusion), but USD visibility belongs to the stage rather than to a camera and Kit renders one stage — so it was hidden from ego_b and scene too. Only Robot B kept its head, because operator B's headset runs in a second process with its own stage.
• The recorder's status toast was drawn into the room. A rounded pill hovering against the back wall — RESET not saved in red, or SUCCESS demo 40 saved in green — present in 13,878 of 17,634 scene frames, 78.7%, in every episode. It is an XR overlay widget and it reached the recording cameras the same way the missing head did. This one was not merely ugly: it states the episode's outcome inside the frame, so a policy reading the scene camera could have learned to predict success from a caption on the wall rather than from the handover.

Rebuilding in a process with no headset removes both: nothing is hidden and nothing is overlaid. Measured on the rebuilt release, the wall band that carried the panel is clean in 0 of 17,634 frames.

This is not a physics replay — each frame's recorded articulation state is written straight into the scene and rendered again, so it is the same instant through the same lens, not the same bytes. The exposure matches the session's: 1.003 / 1.004 / 1.006 for ego_a / ego_b / scene against the frames the session recorded. An earlier rebuild of this dataset came out a flat 1.089× brighter, because the live XR process and the offline one load different Kit experience files whose lighting defaults disagree; mhbench.runtime.configure_render pins the light transport to the live values now. MHBench's CoCarry release was rebuilt the same way, so the two are consistent with each other and with a live session.

Known limitations

The wrist orientation is computed — see above. The single caveat worth carrying into a paper's method section.

The frames are a re-render, not the session's own pixels — see Images above. The geometry restores exactly and the exposure matches to within 0.6%; what differs is temporal-accumulation state around edges and moving bodies, which a re-render of a teleported scene cannot reproduce.

No locomotion at all. Both robots are rooted; navigate_command is identically zero and base_height_command never leaves 0.72 m. Six of the 70 consumed action dimensions are therefore constant. This is the task's design — it isolates the exchange — but it means the dataset cannot teach walking, and a policy trained here has never been asked to move its base.

Every session ran at 0.245–0.289× realtime — about 13 Hz against the 50 Hz control rate. Both operators were teleoperating in slow motion, and whatever that does to human timing is in the demonstrated behaviour. The cause is the XR render and encode share rather than physics (docs/teleop.md §5).

Grasp is an abstraction. grasp_abstraction = 1: a magnetic surface latch, not a finger-object contact solve. states/hand_contact/* is therefore identically zero — the latch holds the bottle at a standoff and the palms never touch it. For a handover this matters more than it does for a two-handed carry: the moment of transfer is a latch handing off to another latch, not one set of fingers yielding to another.

One operator pair, one scene, one bottle. terrain_id = 0, partner_id = 0, operator_id_a = 0, operator_id_b = 1, role_a_leader = 1. The bottle and target placement vary per episode; nothing else does. 50 demonstrations meets the collection target, but they are 50 samples of one configuration with a 10 cm jitter, not a distribution over scenes.

Loading it

import json, pyarrow.parquet as pq, numpy as np

root = "."                                    # this repository
modality = json.load(open(f"{root}/meta/modality.json"))
table = pq.read_table(f"{root}/data/chunk-000/episode_000000.parquet")
column = np.stack(table.column("observation.state").to_numpy(zero_copy_only=False))

entry = modality["state"]["robot_a_left_arm"]
left_arm = column[:, entry["start"]:entry["end"]]          # (T, 7), joint angles

Every key is a slice of a named column, so read meta/modality.json rather than hardcoding offsets — that is the file the exporter, its tests and the training configs all agree through.

For GR00T, register the embodiment config that matches the variant you are training (one policy for the pair, or one per robot) and point at this directory:

python gr00t/experiment/launch_train.py \
    --embodiment-tag new_embodiment \
    --modality-config-path <MHBench>/configs/gr00t/mhbench_duo.py \
    --dataset-path <this repository>

launch_train.py rather than launch_finetune.py: the action chunk is 50 steps (1.0 s at 50 Hz) and the finetune entry point validates chunks against a default of 40.

For ACT or Diffusion Policy, scripts/data_convertion.py repacks these same rows into the containers those expect — add --depth for a policy that takes depth.

How it was checked

Every episode was compared against the recording it came from, key by key, through meta/modality.json alone — the way a loader reads it. Joint state, actions, commands, wrenches and camera poses match the source exactly (max|difference| = 0), every depth frame round-trips within the 0.5 mm quantisation over 2.7 G pixels, no quaternion changes hemisphere, and each video's frame count equals its parquet's row count.

The computed wrist orientation was checked twice over: Pinocchio walking Isaac Lab's URDF reproduces the exported quaternion, and — the check that matters, because it does not share the export's assumptions — the same forward kinematics reproduces the recorded wrist position on every row of all 50 episodes, which is what pins the joint-name mapping the rotation depends on.

.venv/bin/python scripts/test_export_lerobot.py     # the export's own gate
.venv/bin/python scripts/verify_dataset.py datasets/handoverfixed/data