Guide
How Is Robot Pretraining Data Annotated?
Short answer
Robot pretraining data is annotated by capturing synchronized video, depth, and IMU on a calibrated rig, then labeling hand pose, action segments, and contact events against that synchronized data rather than a single RGB frame. Public research such as EgoScale and GR00T N1 instead derives pseudo-labels from SLAM, hand-pose estimation, and inverse-dynamics models. Labels are QA-checked, then delivered in the training format requested.
Last reviewed:
What does annotating robot pretraining data mean?
Captured video is only pixels until it carries the structured signals a policy trains on. Annotating pretraining data means attaching those signals — where the hands are, what action is happening, when contact occurs, which pixels belong to which object — to the video and depth they describe, at the timestamp they occurred. Without that layer, egocentric footage is watchable but not trainable: a policy has no way to extract a trajectory or an action boundary from raw RGB alone.
There are two broad ways to produce that layer. One is to measure it live, during capture, from calibrated sensors on a synchronized rig — the approach described on /custom-collection/egocentric-video-annotation and /custom-collection/action-labeled-egocentric-video. The other is to estimate it after the fact from RGB alone, using computer-vision models such as SLAM and hand-pose estimation, or to infer it implicitly with a learned inverse-dynamics model — the approach EgoScale and GR00T N1 each describe in their published methodology. This guide walks through both, plus the calibration, QA, and delivery steps that sit around them.
This page is the pipeline overview. For the full wrist- and hand-pose field spec, see /guides/hand-pose-and-wrist-action-labels-for-pretraining. For the commercial programs that ship these labels on a custom collection, see /custom-collection/egocentric-video-annotation and /custom-collection/action-labeled-egocentric-video.
What labels does robot pretraining data need?
A pretraining-ready episode needs labels that cover trajectory, grasp shape, contact, and — where the spec calls for it — object identity, not a single caption per clip. Firsthand’s episode schema, documented in full at /formats/episode-schema, ships the following annotation fields, each tied to the synchronized streams they describe.
| Label | What it captures | Delivered field |
|---|---|---|
| Hand pose | Per-joint 3D hand keypoints, per hand, with a visibility flag for occlusion | annotations/hand_joints (float32 [T, 2, 21, 3], metres) + annotations/hand_visible |
| Action segments | Discrete sub-action boundaries with a verb and noun per segment | annotations/action_segments — list[{start_ns, end_ns, verb, noun}] |
| Contact events | When and where a hand made or broke contact with an object | annotations/contact_events |
| Instance segmentation | Per-pixel masks for the hand, task object, and background, where the spec calls for it | annotations/instance_masks, annotations/objects |
| Body pose | Per-joint body keypoints, where the task requires whole-body context | annotations/body_joints |
| Gaze target | Where attention was directed, where the spec calls for it | annotations/gaze_target |
Annotation fields and what they capture
Not every episode needs every field — a tabletop manipulation skill spec might call for hand pose, action segments, and contact events only, while a mobile-manipulation spec adds body pose and instance segmentation. Which fields are in scope is set in the skill spec, per /guides/how-to-write-a-skill-spec.
How are action segments labeled in egocentric video?
An action segment marks where one sub-action ends and the next begins inside a longer task, rather than applying a single label to the whole clip. Each segment carries a start timestamp, an end timestamp, and a verb/noun pair �� for example pick up / knife, then place / cutting board — logged with nanosecond timestamps on the same PTP clock domain as the video and depth. That shared clock is what lets a policy line up an action boundary with the exact frame it occurred on, rather than an approximate one.
Because the verb and noun vocabulary is attached per segment rather than fixed for the whole dataset, a skill spec can define the exact action vocabulary a program needs — the terms a training stack already expects — instead of a generic taxonomy applied after the fact. See /guides/action-segmentation-for-robot-learning for more on why segment-level, rather than clip-level, labeling matters for long-horizon tasks.
How are hand pose and wrist actions labeled?
Hand pose is tracked live against the captured depth stream, per hand, and stored as annotations/hand_joints — 21 joints per hand, in metres, in the head-camera frame. A per-joint annotations/hand_visible flag records occlusion explicitly, so a finger the camera could not see is marked as such rather than silently estimated through. Wrist-level motion is recorded separately as 6-DoF IMU streams (streams/imu_wrist_l, streams/imu_wrist_r) at 200 Hz, giving the coarse trajectory that hand pose’s fine joint detail sits on top of.
This combination — wrist trajectory plus per-joint hand pose — is the same structure NVIDIA’s EgoScale uses to represent action in egocentric human video, documented in its arXiv paper and on NVIDIA’s GEAR lab research page. The difference covered later in this guide is how each number was produced: tracked live against depth versus estimated after the fact from RGB. See /guides/hand-pose-and-wrist-action-labels-for-pretraining for the full field-level breakdown, and /guides/3d-hand-pose-estimation-for-robotics for the fine-manipulation case specifically.
How do calibration and sync make labels usable?
A label is only as useful as the frame it is attached to. If a hand-joint sample and the video frame it describes were captured a few milliseconds apart, the label describes a slightly different moment than the image shows. Firsthand’s rig hardware-triggers every stream — video, depth, IMU, and hand-pose tracking — onto the same PTP clock domain, so a label and the frame it describes carry matching timestamps rather than being aligned after capture in software. See /guides/how-we-measure-sync-error for how cross-stream sync error is measured and reported.
Calibration is the other half of the same problem. hand_joints are recorded in metres in the head-camera frame, which only means what it claims to mean if the camera’s intrinsics and the SE(3) extrinsics between streams are measured accurately. That is checked per rig session against a reprojection-error threshold (rms_reproj_px < 0.28) rather than assumed to hold indefinitely from a one-time factory calibration. See /guides/camera-calibration-procedure for the calibration process itself.
What are pseudo-labels, and how do EgoScale and GR00T N1 use them?
A pseudo-label is an annotation produced by a model after capture, rather than measured live from calibrated sensors. NVIDIA’s EgoScale, documented on arXiv and on NVIDIA’s GEAR lab research page, derives its action labels for a 20,854-hour egocentric corpus using off-the-shelf SLAM (for camera and wrist trajectory) plus hand-pose estimation applied to RGB after the fact — not a purpose-built capture rig. NVIDIA’s GR00T N1, described in its arXiv paper, goes further for footage that has no action label at all: it uses latent actions and an inverse-dynamics model to pseudo-label unlabeled video, so footage without any ground-truth action signal can still contribute to pretraining rather than being discarded.
| Dimension | Captured labels (synchronized rig) | Pseudo-labels (SLAM, hand-pose estimation, inverse-dynamics models) |
|---|---|---|
| When produced | Live, during capture, from calibrated multi-stream data | After capture, from RGB alone (or from a learned inverse-dynamics model for unlabeled video) |
| Failure modes | Occlusion is flagged per joint rather than silently mis-estimated | Can degrade under occlusion, fast motion, or unusual lighting; trajectory can drift over long sequences |
| Depth source | Metric depth measured alongside RGB, used to ground hand joints | Monocular RGB only — no metric depth used |
| Scale of production | Bounded by rig collection time, but every label comes with a measurement, not an estimate | Can label a corpus at very large scale, since no live rig time is required |
| Best fit | Alignment stages and dexterous manipulation, where per-frame label precision matters most | Broad-coverage pretraining where volume matters more than per-frame precision, or unlabeled footage with no ground truth at all |
Human-verified (captured) labels vs pseudo-labels
Neither approach is wrong for its purpose — EgoScale’s own evaluation shows its pseudo-labeled pretraining recipe transferring to real task success. The distinction matters for planning a pretraining mixture: a broad pretraining stage can tolerate pseudo-label noise better than a small, closely matched alignment stage can, which is the same two-stage structure EgoScale itself uses. See /guides/building-a-robot-pretraining-data-mixture for how to plan that split, and /guides/gr00t-n1-data-pyramid-explained for more on how GR00T N1’s data pyramid uses pseudo-labels across its layers.
For a custom collection, the labeling method is specified in the capture spec itself — hand pose and action segments tracked live against depth on a synchronized rig — rather than reverse-engineered from documentation after delivery, the way a buyer has to check for a third-party public corpus.
How is annotation quality checked before delivery?
Annotation quality is checked in layers, at the stage where each failure mode actually occurs, rather than in a single pass at the end. Cross-stream sync error is validated against a fixed ceiling as footage is recorded. Coverage — including failure cases such as stalls, slips, and corrections — is checked against the capture spec’s required skill variations. Only footage that passes both checks counts toward the delivered total; footage that fails is logged and excluded rather than silently kept. See /guides/video-dataset-quality-assurance for the full multi-layer QA process and /guides/robot-pretraining-data-quality-checklist for the buyer-side checklist that verifies the same signals from the outside.
- Capture
- Video, depth, and IMU are recorded on a hardware-triggered PTP clock domain across the synchronized rig.
- Calibration and sync check
- Camera intrinsics and extrinsics are measured per rig session against a reprojection-error threshold; cross-stream sync error is checked against a fixed ceiling.
- Annotation
- Hand pose, action segments, contact events, and any spec-required masks or body pose are labeled against the synchronized depth and clock, not a single RGB frame.
- Coverage and QA check
- Recorded and labeled footage is checked against the capture spec’s required skill variations and failure-case coverage before it counts as a validated hour.
- Delivery
- Labels and streams are packaged into the requested training format under a buyer-owned license.
Pipeline stage, what happens, and what the QA layer checks at that stage.
How are labels delivered (formats and fields)?
The underlying label fields — hand_joints, hand_visible, action_segments, contact_events, and any spec-required masks or body pose — are the same across delivery formats, but each format projects them differently. RLDS and LeRobot fold labels into the per-step observation and action structure their loaders expect. HDF5 and zarr deliver the fields closest to their native form, with per-stream nanosecond timestamps, which is why Firsthand’s own QA tooling reads that format — it is the most complete for verifying sync directly. WebDataset keys samples by frame rather than by episode, with labels delivered inline as ann.json alongside the image and depth keys for that sample.
Whichever format is chosen, the canonical field layout is /formats/episode-schema — every delivery format is a projection of it, so switching formats later does not change what a label actually contains. See /guides/pretraining-data-delivery-formats for a fuller comparison of which format fits which training stack.
To request a custom collection with a specific annotation field spec — which labels, which formats, and which QA thresholds apply — start at /custom-collection/egocentric-video-annotation, /custom-collection/action-labeled-egocentric-video, or /custom-collection/pretraining-data-collection.
Related
- Robot pretraining data
- Egocentric video annotation (custom collection)
- Action-labeled egocentric video (custom collection)
- Hand pose and wrist action labels for pretraining
- Action labels (glossary)
- Inverse-dynamics model (glossary)
- Pseudo-labels (glossary)
- Multi-layer QA for video datasets
- What is the GR00T N1 data pyramid?
- Custom pretraining data collection
- How much annotation does robot training data need?
FAQ
How Is Robot Pretraining Data Annotated?, answered.
01What does it mean to annotate robot pretraining data?
It means attaching structured signals — hand pose, action-segment boundaries, contact events, and any masks or body pose the spec calls for — to captured video and depth at the timestamp they occurred, so a policy can extract a trajectory or action boundary rather than working from raw RGB alone.
02What labels does a pretraining-ready episode need?
At minimum, hand pose (annotations/hand_joints with a hand_visible occlusion flag) and action segments (annotations/action_segments) with verb/noun labels. Contact events, instance segmentation, body pose, and gaze target are added when the skill spec calls for them.
03What is the difference between captured labels and pseudo-labels?
A captured label is measured live during collection from calibrated, depth-grounded, synchronized streams, with occlusion flagged rather than estimated through. A pseudo-label is computed after capture from RGB using SLAM, hand-pose estimation, or a learned inverse-dynamics model, and can degrade under occlusion, fast motion, or drift over long sequences.
04How does EgoScale label its egocentric pretraining corpus?
EgoScale’s official paper and NVIDIA’s GEAR lab page describe deriving action labels from off-the-shelf SLAM and hand-pose estimation applied to RGB after capture, at the scale of its 20,854-hour corpus, rather than from a purpose-built synchronized rig.
05How does GR00T N1 use pseudo-labels?
GR00T N1’s data pyramid, described in its arXiv paper, uses latent actions and inverse-dynamics-model pseudo-labeling so egocentric video with no ground-truth action label can still contribute to pretraining, rather than being discarded.
06How is annotation quality checked before a dataset is delivered?
In layers, at the stage each failure mode occurs: sync error is checked against a fixed ceiling during capture, coverage is checked against the capture spec’s required variations and failure cases, and only footage that passes both counts toward the delivered total.
07Why does label sync and calibration matter for training?
A label is only as useful as the frame it is attached to. Hardware-triggering every stream onto the same PTP clock domain, and checking camera calibration per session against a reprojection-error threshold, keeps a hand-pose or action label matched to the exact moment the video shows.
08Which delivery formats carry the annotation fields?
RLDS, LeRobot, WebDataset, HDF5, and zarr all carry the same underlying fields, projected into each format’s own structure. The canonical field layout is documented at /formats/episode-schema.
Sources
Where is this documented?
- EgoScale (arXiv 2602.16710) (opens in a new tab)Official paper describing EgoScale’s egocentric pretraining corpus and its SLAM- and hand-pose-estimation-derived action labels. arxiv.org
- EgoScale — NVIDIA GEAR Lab (opens in a new tab)NVIDIA’s own research page for EgoScale, corroborating the corpus and labeling methodology. research.nvidia.com
- GR00T N1 (arXiv 2503.14734) (opens in a new tab)Describes the data pyramid and its latent-action, inverse-dynamics pseudo-labeling for unlabeled video. arxiv.org
- Firsthand: episode schema (opens in a new tab)The canonical field layout every delivery format projects from. ifirsthand.com
Check it against the sample pack.
40 episodes across 4 environments, delivered in the exact schema these guides describe.