RoboX-EgoTask

A premium egocentric dataset of real-world hand and object task demonstrations, recorded in first person through RoboX. This release bundles 17 task clips drawn from 5 full recordings (about 6 minutes of footage), each pairing clean RGB video with synchronized, robotics ready annotations: MediaPipe hand keypoints (21 joints, 2D and 3D), 6DoF camera pose, IMU, depth metadata, body pose, person segmentation, and per frame trajectory signals. It is built for embodied AI and egocentric robotics research, with predefined train, validation and test splits and a motion quality score on every clip.

Examples

All 17 clips are shown below with the QA overlay so the joint tracking is visible: MediaPipe hand landmarks rendered on top (left hand blue, right hand orange). The clips and recordings that ship for training are clean RGB without these overlays. Clips are grouped by the recording they came from.

Making tea (kitchen task)

Kitchen task demonstration	Opening a box of tea
Selecting a tea bag from the box	Placing the tea bag into the mug
Pouring hot water from the kettle into the mug

Loading the dishwasher (object transfer)

Opening the dishwasher door	Placing a blue plate with cutlery inside
Placing a white plate with cutlery inside	Placing a pot with its lid inside
Closing the dishwasher door

Picking up a GoPro box and accessory (object transfer)

Picking up the GoPro box from the shelf	Examining the GoPro box on the desk
Opening the bag with the head strap accessory	Placing the head strap accessory on the desk

Cleaning the sink

Spraying cleaning product onto the sink

Scrubbing the sink with a sponge

Wiping a computer case

Wiping the front panel with a cloth

Dataset Summary

Property	Value
Recordings	5
Clips	17
Duration	5 min 59 sec
Contributors	3 (anonymized)
Campaign	EgoTask
Export date	2026-05-28

Collection Methodology

Recordings are captured via RoboX as first-person egocentric videos with synchronized metadata. Depending on campaign type and device capability, recordings include:

• hand keypoints (21 joints, 2D + 3D)
• device IMU (accelerometer, gyroscope, gravity)
• 6DoF camera pose (position, orientation, velocity)
• camera intrinsics and exposure per frame
• scene structure and light estimates

Annotation Pipeline

1. On-device ARKit sensors provide hand keypoints, 6DoF camera pose, IMU, and camera intrinsics per frame
2. Object detection produces per-clip bounding boxes with class labels
3. Scene, action, and narration annotations are aligned to clip boundaries and clip-relative timestamps

Dataset Tiers

Two tier axes live on every clip:

1. dataset_tier: the bundle-level buyer tier the export was packaged at (base / pro / premium / custom). Same value on every clip in this bundle (see manifest.json::dataset_tier). Drives which annotation streams the runner emits.
2. buyer_tier_eligible: the highest tier the clip's source data supports, computed from source_modalities_available. Independent of dataset_tier, a Premium bundle can contain clips that only justify Pro or Base, and a Base bundle still surfaces eligibility so consumers can spot data that could be re-bundled at a higher tier.

Buyer tiers map to source modalities as follows:

• base: video asset plus any AI-derived labels (object detections, scene / activity tags). No structured robotics sensor data.
• pro: base plus the motion stack: 6DoF camera pose, camera intrinsics, IMU, hand keypoints when captured, and depth (LiDAR / TrueDepth) when available.
• premium: pro plus body pose (19-joint skeleton with stable person_id) and / or person segmentation (instance bbox per frame with the same person_id pool).

Tier distribution for this bundle (counts the clips' buyer_tier_eligible):

• base: 0 clips (0.0%)
• pro: 0 clips (0.0%)
• premium: 17 clips (100.0%)

A finer-grained sensor_tier label (rgbd_navigation / rgbd_full / full / motion_only / vision_only / video_only) is also stamped on every clip with a sensor bundle. It exposes the capture topology beyond the three-tier buyer ladder so robotics buyers can pick, e.g. "depth-equipped EgoNav only" without enumerating modality flags. Use sensor_tier (when present), exported_modalities and buyer_tier_eligible in clips.jsonl to filter by capability. manifest.json::included_modalities lists every modality actually contained in this export, and excluded_modalities lists modalities captured by the device but stripped by the active dataset tier.

Bimanual Activity

Every clip carries lightweight bimanual aggregates derived from per-frame hand state (annotations/hand_state/):

• is_bimanual_active: true when both hands were jointly active for ≥ 10% of clip frames
• bimanual_active_percent: fraction of frames where both hands were active (0–100)
• bimanual_active_duration_sec: estimated seconds where both hands were active
• hand_state_distribution: per-state frame counts: no_hand_visible / left_only / right_only / both_visible / both_active
• labels.bimanual: any of bimanual_grasp (both hands closed-grip with object contact for ≥ 20% of frames), handoff (in_hand side flips within 1.5 s), coordinated_action (sustained two-handed activity, ≥ 40% of frames, that did not qualify as bimanual_grasp)

A "hand is active" when it is visible AND either (a) holds a closed grip (power_grip / pinch / precision_grip), (b) overlaps any tracked object's bbox, or (c) reports a small thumb–index pinch distance.

Dataset Profiles

When this bundle was exported with a named dataset profile, the resolved recipe is recorded in manifest.json::profile. Profiles pin the bundle to a single campaign and apply extra clip-level filters on top of the chosen tier, for example, egograsp_bimanual_v1 keeps only EgoGrasp Premium clips with bimanual_active_percent ≥ 50.

Motion Quality Scoring

Every clip carries a motion_quality_score (0–100) derived from device telemetry the runner already extracts. Buyers can sort/filter low-quality clips without opening any MP4:

• clips.jsonl::motion_quality_score: composite score, 0–100
• clips.jsonl::quality_tier: one of excellent (≥ 85), good (≥ 65), usable (≥ 40), reject (< 40)
• clips.jsonl::motion_quality.*: component metrics that fed the score:
  • motion_smoothness: inverse of mean angular-velocity jerk (handheld shakiness)
  • activity_density_percent: fraction of frames with any signal (hands / objects / non-trivial camera motion)
  • active_frame_percent: fraction of frames where a hand is actively engaged
  • tracking_quality_percent: fraction with ARKit tracking_state == "normal"
  • low_light_percent: fraction with ambient lumens below 100 lm
  • motion_blur_risk_percent: fraction with linear OR angular velocity above the motion-blur thresholds
  • frame_jitter: {mean_interval_ms, std_interval_ms, max_deviation_ms, jitter_score} from frame timing

manifest.json::quality carries the dataset-wide tier distribution and mean score so consumers see overall bundle quality before drilling into clips. Missing telemetry (e.g. no light estimate on a legacy device) defaults to a neutral 50 contribution to the composite so older bundles are not penalised relative to fully-equipped captures.

Universal Trajectory Segmentation

In addition to the campaign-specific action segments under annotations/actions/, every clip carries a campaign-agnostic trajectory state stream derived from pose / IMU / Core Motion / hand activity signals. Robotics buyers training cross-campaign models can filter / join by trajectory state directly without ever consulting the campaign-specific taxonomy.

Three states (priority order: interaction > locomotion > idle):

• interaction: a hand is actively engaged with an object (hands_active or interaction_active). Walking-while-holding counts as interaction, not locomotion.
• locomotion: the body / camera is translating through space. Triggered by linear velocity ≥ 0.2 m/s, sustained IMU user-acceleration ≥ 0.15 m/s², or Core Motion walking/running/cycling/automotive activity at non-low confidence.
• idle: neither of the above. Hand visible but inactive, body stationary.

Per-clip surface on clips.jsonl::trajectory:

• state_distribution / state_percent / state_duration_sec: per-state frame counts, fraction, and seconds
• dominant_state: most-common state (ties broken by priority order)
• segments[]: merged timeline spans {state, start_sec, end_sec, start_frame, end_frame, frame_count} (segments shorter than 0.3 s are absorbed into their predecessor to suppress tracker hiccups)
• segment_count / frame_count

A flat clips.jsonl::dominant_trajectory_state field is duplicated alongside dominant_state so consumers can WHERE dominant_trajectory_state = 'locomotion' without unpacking the nested block.

Per-frame stream at annotations/trajectory/<clip>.jsonl preserves the underlying signals (linear velocity, IMU magnitude, GPS activity) so consumers can derive their own state machines (e.g. a 4-state walking_with_object refinement) without re-running the pipeline.

manifest.json::trajectory rolls up the bundle-wide dominant-state distribution and total seconds per state.

Intended Use

This dataset is intended for embodied AI and egocentric robotics research.

Duration Distribution

• min_sec: 2.5
• max_sec: 63.734
• mean_sec: 15.445
• median_sec: 12.0

Annotation Coverage

• hand_keypoints: 17/17 clips (100.0%)
• hand_state: 17/17 clips (100.0%)
• hand_landmarks_mediapipe: 17/17 clips (100.0%)
• trajectory: 17/17 clips (100.0%)
• object_tracks: 16/17 clips (94.1%)
• object_tracks_temporal: 0/17 clips (0.0%)
• object_tracks_ai_fallback: 16/17 clips (94.1%)
• sensors: 17/17 clips (100.0%)
• actions: 17/17 clips (100.0%)
• environment: 17/17 clips (100.0%)
• people: 16/17 clips (94.1%)
• body_pose: 2/17 clips (11.8%)
• segmentation: 16/17 clips (94.1%)

Annotation Coverage By Sensor Tier

• rgbd_full (17 clips): actions 17/17 (100.0%), body_pose 2/17 (11.8%), environment 17/17 (100.0%), hand_keypoints 17/17 (100.0%), hand_state 17/17 (100.0%), object_tracks 16/17 (94.1%), people 16/17 (94.1%), segmentation 16/17 (94.1%), sensors 17/17 (100.0%), trajectory 17/17 (100.0%)

Dataset Splits

• test: 1 clips, 1 recordings, 1 contributors
• train: 9 clips, 2 recordings, 1 contributors
• val: 7 clips, 2 recordings, 1 contributors

Object Distribution

• No object-level distribution available

Domain Distribution

• No domain-level distribution available

Structure

• recordings/: Clean RGB full recordings (training-safe; no baked hand overlays).
• clips/: Clean RGB task/action clips derived from recordings.
• overlays/: Optional QA/debug preview videos with rendered hand landmarks (see manifest.json::video_assets and per-row video blocks in metadata/recordings.jsonl / metadata/clips.jsonl). Left hand #4A90E2, right hand #FF8C42 when MediaPipe overlays are included.
• metadata/recordings.jsonl: Recording-level index
• metadata/clips.jsonl: Clip-level index (dataset index)
• metadata/contributors.jsonl: Anonymized contributor info
• metadata/splits.jsonl: Contributor-aware train/val/test split assignment
• taxonomy.json: Object/domain mapping derived from clip labels
• VALIDATION_REPORT.json: Bundle integrity and consistency checks
• SANITIZATION_REPORT.json: Buyer-facing privacy and sensitive-content scan summary
• USAGE_TERMS.md: Human-readable summary of license, commercial-use, exclusivity and buyer-assignment metadata (see also manifest.json::release)
• showcase/best_clips.json: Auto-selected best representative clips per campaign
• notebooks/explore_dataset.ipynb: Interactive exploration notebook (run in Jupyter)
• annotations/actions/: Temporal action segments per clip
• annotations/hand_keypoints/: Per-frame hand pose (21 joints). As of schema v1.5 this stream is sourced from MediaPipe HandLandmarker running in the export backend, see manifest.json::mediapipe_hands and clips.jsonl::hand_detection_source for provenance. The on-device iOS Vision hands are still captured by the app but are no longer the canonical source in the export bundle; this guarantees left/right chirality is consistent across all annotation streams.
• annotations/hand_landmarks_mediapipe/: Per-video-frame raw MediaPipe stream (one entry per frame at video fps, including frames where no hand was detected). Finer rate than hand_keypoints (which samples at iOS metadata rate, ~10 Hz). Same field shape as hand_keypoints entries.
• annotations/hand_state/: Per-frame bimanual state (left/right visible + active flags, per-hand grip, per-hand in_hand). Always rides along with hand_keypoints.
• annotations/trajectory/: Per-frame universal robotics trajectory state (idle / locomotion / interaction) plus the raw signals that produced it (linear velocity, IMU acceleration, Core Motion activity). Campaign-agnostic and orthogonal to the campaign-specific actions stored in annotations/actions/.
• annotations/object_tracks/: Per-frame object bounding boxes
• annotations/sensors/: IMU, 6DoF camera pose, intrinsics, plus a per-frame depth block (available, resolution, stats, intrinsics), full LiDAR/TrueDepth metadata when the device captured it (Pro+ tier)
• annotations/body_pose/: Per-frame body skeleton (19 joints) with stable person_id (Premium tier only)
• annotations/segmentation/: Per-frame person-segmentation bboxes with stable person_id and frame-level coverage ratio (Premium tier only)
• annotations/environment/: Scene and environment labels per clip
• annotations/people/: Clip-level people visibility and count derived from AI enrichment

Sensor Data Description

• annotations/sensors/ stores aligned per-frame measurements for IMU, camera pose, intrinsics, exposure, light estimate and a depth block (available, resolution, stats, intrinsics, LiDAR/TrueDepth metadata; the dense pixel map is not persisted). Recording- and clip-level rollups (depth_stats, depth_summary, lidar) are surfaced in metadata/recordings.jsonl and metadata/clips.jsonl
• annotations/hand_keypoints/ stores per-frame hand observations including grip type and 2D/3D joint data when available
• annotations/body_pose/ stores per-frame body skeletons with a stable person_id (IoU-tracked across frames), bbox_normalized, per-joint 2D coordinates and confidence, and an optional body_pose_summary rollup
• annotations/segmentation/ stores per-frame person-segmentation results, one persons[] entry per detected human (bbox + stable person_id, IoU-tracked across frames; the same identity is shared with annotations/body_pose/ when both signals fire on the same human), plus the device-reported coverage_ratio, covered_pixel_count and frame dimensions
• annotations/actions/ stores temporal clip-level action segments

Limitations

• Clean RGB videos in recordings/ and clips/ are the primary training source. Overlay videos under overlays/, when present, are rendered visualization assets for QA, debugging, and demo review only, do not treat them as raw sensor video.
• object tracks are only present when source frames include object detections
• this export is optimized for structured ML ingestion rather than human-readable storytelling

Data Loading

Clip metadata with the datasets library

The clip-level metadata is exposed as a loadable config with train, validation and test splits. This dataset is gated, so authenticate first with hf auth login (or pass token=True).

from datasets import load_dataset

ds = load_dataset("RoboXTechnologies/RoboX-EgoTask", "clips")
print(ds)

row = ds["train"][0]
print(row["clip_id"], row["task_category"], row["narration"])
print(row["video_url"])     # clean RGB clip
print(row["overlay_url"])   # same clip with hand landmarks rendered

Full per-frame annotations from a local copy

The config above is a flat summary, one row per clip. The complete per-frame streams (hand keypoints, sensors, trajectory and more) ship as JSONL under annotations/ and metadata/. Download or clone the repo, then read them directly:

import json
from pathlib import Path

root = Path("RoboX-EgoTask")  # path to the downloaded repo
clips = [json.loads(line) for line in (root / "metadata" / "clips.jsonl").read_text().splitlines()]
hand_clips = [c for c in clips if (c.get("exported_modalities") or {}).get("hand_keypoints_2d")]
print(clips[0]["clip_id"], clips[0]["labels"])

Streaming clip videos into PyTorch

A minimal Dataset that pulls each clip's MP4 on demand (cached after the first fetch) and decodes it to a tensor. Clips vary in length, so this uses batch_size=1; add a collate_fn that pads or samples a fixed number of frames to batch them.

import torch
from torch.utils.data import Dataset, DataLoader
from datasets import load_dataset
from huggingface_hub import hf_hub_download
import torchvision

REPO = "RoboXTechnologies/RoboX-EgoTask"

class EgoTaskClips(Dataset):
    def __init__(self, split="train"):
        self.rows = load_dataset(REPO, "clips", split=split)

    def __len__(self):
        return len(self.rows)

    def __getitem__(self, idx):
        row = self.rows[idx]
        path = hf_hub_download(REPO, f"clips/{row['clip_id']}.mp4", repo_type="dataset")
        video, _, _ = torchvision.io.read_video(path, output_format="TCHW")  # (T, C, H, W)
        return {"clip_id": row["clip_id"], "video": video, "label": row["task_category"]}

loader = DataLoader(EgoTaskClips("train"), batch_size=1, shuffle=True)
batch = next(iter(loader))
print(batch["clip_id"], batch["video"].shape)

Citation

@dataset{robox_egotask_2026,
  title={RoboX-EgoTask: An Egocentric Hand-Object Task Dataset},
  author={RoboX Team},
  year={2026},
  url={https://huggingface.co/datasets/RoboXTechnologies/RoboX-EgoTask},
  license={CC-BY-NC-4.0}
}

License

CC-BY-NC-4.0

Commercial use: ⛔ Not allowed, research and non-commercial use only

For commercial licensing inquiries: contact@robox.to

Usage Terms & Exclusivity

manifest.json::release is the canonical machine-readable contract attached to this bundle and USAGE_TERMS.md is the buyer-readable summary of the same data. Fields:

• license_id: short license slug (e.g. CC-BY-NC-4.0 / CC-BY-4.0 / ROBOX-COMMERCIAL-1.0).
• license_url: link to the full license text. The full text also ships in this bundle's LICENSE file.
• commercial_use_allowed: boolean derived from the license.
• exclusive: when true, RoboX has agreed not to license the same underlying data to other parties for the duration of the exclusivity window.
• exclusive_until: ISO 8601 expiry of the exclusivity arrangement (null for non-exclusive or perpetual-exclusive bundles).
• buyer_id / buyer_alias: opaque buyer identifier + buyer-facing display string when the bundle was prepared for a specific buyer; both null otherwise.
• warnings: informational slugs (e.g. exclusive_without_buyer) attached when the input combination is suspicious. The bundle still ships; operations reconciles these against the underlying contract.

Conservative defaults apply when the export request omits a field, so a buyer or tester never receives a permissive license / exclusivity flag by accident: CC-BY-NC-4.0, commercial_use_allowed=false, exclusive=false, buyer_id=null.