HubEgo-100K is released under the Creative Commons Attribution 4.0 license (CC BY 4.0). Please credit the dataset when you use it. Hub Data, Inc. uses the information below only to manage access and share dataset updates. We do not sell it.

HubEgo-100K

A 100,000-hour dataset of first-person video of skilled manual work, recorded by Hub contributors: building sites, workshops, salons, kitchens, shops, warehouses and homes, released in stages. This first release has 10,124 hours of RGB + IMU from 12,227 contributors, in LeRobot and MCAP formats.

Highlights

Real work, in the wild: No staged recording sessions; contributors film their own work in their own workplace or trades done in a home.
Skill variety: 62,000+ unique task descriptions across 56 task types and 30 categories, from bricklaying, wiring and plumbing to phone board microsoldering and watch repair.
Dexterous manipulation: Every episode is centered on the contributor's hands at work. Hands are in frame 95%+ of the time, and 96.9% of episode time is spent actively doing the task.
Hard tasks: 34% of the hours are annotated as hard and 47% as medium difficulty.
Real environments at scale: 15,548 single environments, in 11 setting types. 83% of hours are in workplaces: building sites, workshops, salons, commercial kitchens, shops, warehouses and farms.
Diverse contributors: 12,227 unique contributors, all first-party. Every hour was recorded by a Hub contributor, no third-party episodes.
Annotated: Every episode has a task description, a step-level instruction, an action family, a skill group, a difficulty level and environment.
High quality: 1920x1080 mono recordings at 30 fps (RGB + IMU), with accelerometer and gyroscope aligned to every frame, plus the full native sensor streams.
Open: CC BY 4.0, free to use, share and adapt, including commercially, with credit.

Dataset summary (release 1: 10K hours)

Hours of video	10,124 h (1,093,194,072 frames)
Episodes	72,754 (median 4.9 min, up to 30 min)
Contributors	12,227 unique contributors
Environments	15,548 single environments, in 11 setting types; 83% of hours in workplaces
Tasks	62,000+ unique task descriptions, 56 task types, 30 categories, 35 action families
Hands	in frame 95%+ of the time
Video	1920x1080, H.264, 30 fps, head-mounted, ultra-wide lens
Sensors	100 Hz IMU (accelerometer + gyroscope), aligned to every frame; full native streams (accelerometer, gyroscope, magnetometer, device motion, heading, barometer)
Format	LeRobot v3 + MCAP + per-episode catalog and annotations

Tasks and actions

Recordings follow a two-level taxonomy, in the spirit of the scenario labels in Ego4D (Grauman et al., CVPR 2022). Each episode belongs to one of 56 task types, grouped by industry into 30 work categories. The 18 largest categories each hold more than 200 hours, and the largest holds 13.1% of all hours.

Categories describe where the work happens; action families describe what the hands do. Every episode is labelled with one of 35 action families, a verb-level taxonomy comparable to the verb classes of EPIC-KITCHENS (Damen et al., IJCV 2022). The same motion recurs across settings: Assemble & install appears in 20 categories, Wash & scrub in 19 and Cut & trim in 17, so each skill is seen with many different tools, materials and viewpoints.

No single action family accounts for more than 10% of hours.

Hours per task are balanced so that no single task dominates. The full task list, with hours, is in catalog.parquet.

Where the work happens

Setting	What it covers
Trades done in homes	a trade or craft done in a home: a home sewing table or repair bench, or a tradesperson working in someone's home (plumbing, electrical, appliance and bike repair, jewelry, printing)
Workshop & repair bench	a dedicated workshop or repair shop
Construction & renovation site	building sites and homes under renovation
Salon & personal care	hair, nail, beauty and pet grooming, in a salon or at home
Commercial kitchen	restaurant, bakery and food-production kitchens
Shop floor	shops and supermarkets
Warehouse & logistics	stock rooms, warehouses, packing
Service & front of house	offices, clinics, hotels, reception
Farm & garden centre	fields, greenhouses, nurseries
Factory & industrial	production lines, factory floors
Household	home DIY and gardening, and service tasks done at home (laundry, room cleaning)

Diversity

Generalization in imitation learning scales with the number of environments and objects a policy sees, much more than with demonstrations per environment (Lin et al., ICLR 2025). HubEgo-100K is built on that axis: every contributor records in their own workplace or home.

Annotations

Every episode comes with structured annotations in meta/annotations.parquet (one row per episode_index):

Field	Content
`description`	short task description, e.g. "Machine-sew and overlock sleeveless top seams"
`task_instruction`	one or two sentences describing the main goal, actions and objects
`action_family`	the main manual action (cut, sew, assemble, fasten, clean, ...)
`skill_group`	the skill the task exercises (tool use, construction, electronics, food preparation, ...)
`difficulty`	easy / medium / hard
`environment`	where the episode was filmed
`on_task_share`	share of the episode spent on the task

meta/subtasks.parquet and meta/subtask_occurrences.parquet give the instruction texts as a subtask table with start and end times per episode. Annotations were produced by a dense video annotation with a vision-language model and have not been checked by people.

Data format

The head-mounted monocular recordings are in the mono/ folder, a LeRobot v3 dataset; later releases can add other capture setups as sibling folders. Inside mono/:

Video: videos/observation.images.main/, one MP4 per episode, 1920x1080 H.264 at 30 fps. 84% of episodes are the phone's original stream; the rest were recorded at 60 fps and converted to 30 fps.
Frame data: data/, LeRobot v3 parquet. observation.state holds the accelerometer (m/s², gravity included) and gyroscope (rad/s) at each frame's capture time.
Native sensors: mcap/, every sensor sample of every episode in MCAP (byte offsets in the catalog).
Catalog: catalog.parquet, one row per episode: task, category, duration, recording and device facts, quality signals.

To load a few episodes without downloading everything:

import glob
import pandas as pd
from huggingface_hub import hf_hub_download, snapshot_download
from lerobot.datasets.lerobot_dataset import LeRobotDataset

REPO, G = "Hubdata/HubEgo-100K", "mono"
EPISODES = [503, 203, 5]  # soldering a phone motherboard, fitting a piston ring, engine work
local = snapshot_download(REPO, repo_type="dataset", local_dir="HubEgo-100K", allow_patterns=[f"{G}/meta/**", f"{G}/catalog.parquet"])
root = f"{local}/{G}"
meta = pd.concat(map(pd.read_parquet, glob.glob(f"{root}/meta/episodes/*/*.parquet"))).set_index("episode_index")
cat = pd.read_parquet(f"{root}/catalog.parquet").set_index("episode_index")
for e in EPISODES:
    c, f = meta.loc[e, "data/chunk_index"], meta.loc[e, "data/file_index"]
    hf_hub_download(REPO, f"{G}/data/chunk-{c:03d}/file-{f:03d}.parquet", repo_type="dataset", local_dir=local)
    hf_hub_download(REPO, f"{G}/{cat.loc[e].video_path}", repo_type="dataset", local_dir=local)
ds = LeRobotDataset(REPO, root=root, episodes=EPISODES)

import pandas as pd
cat = pd.read_parquet("hf://datasets/Hubdata/HubEgo-100K/mono/catalog.parquet")
ann = pd.read_parquet("hf://datasets/Hubdata/HubEgo-100K/mono/meta/annotations.parquet")

Data fields

Two tables describe every episode. Both are keyed by episode_index, the same id used in the LeRobot data and the videos.

annotations.parquet (mono/meta/)

episode_index: episode id, the same across every file
description: what the contributor does in the episode, in one sentence
task_instruction: step-level instruction for the episode, written as a sequence of actions
action_family: main type of hand action (35 families, e.g. Repair & maintain, Cut & trim, Fasten & connect)
skill_group: skill area the task belongs to (18 groups, e.g. Electronics & Diagnostics)
difficulty: easy, medium or hard
environment: setting type where the episode was recorded (11 types, e.g. Workshop & repair bench)
on_task_share: share of the episode spent actively doing the task (0 to 1)

catalog.parquet (mono/)

episode_index: episode id, the same across every file
recording_id: anonymous id of the source recording; one recording can yield several episodes
segment_index: position of the episode within its recording (0 = first)
part: [index, total] when a long task was recorded in several parts, 0-based; null when not split
task: task type the contributor was asked to record (56 task types)
category: work category of the task (30 categories)
contributor_id: anonymous contributor id, stable across episodes
recorded_date: recording date (YYYY-MM-DD)
time_of_day: morning, afternoon, evening or night, local time
device_make, device_model, os: capture phone (e.g. Apple, iPhone14,5, ios)
lens, fov_diag_deg: camera lens used (ultra_wide or wide) and its diagonal field of view in degrees
frames, duration_s: number of video frames and episode length in seconds
recording_start_s, recording_end_s: where the episode starts and ends inside its source recording, in seconds
video_method, source_fps: stream copy of the phone's 30 fps video, or 60 fps re-encoded to 30 fps
frames_repeated: frames duplicated to keep a constant 30 fps (re-encoded episodes only)
median_frame_interval_s, max_frame_interval_s: typical and largest time between consecutive frames
frame_gaps_over_1_5x: number of frame gaps longer than 1.5x the nominal interval
drift_vs_nominal_fps_s: difference in seconds between the real duration and frames / 30
imu_samples_json: number of native sensor samples per stream (accel, gyro, mag, motion, heading, baro)
hands_share: share of frames with at least one of the wearer's hands in view
hands_share_both: share of frames with both hands in view
video_path, video_bytes: path of the episode video in the repo and its size in bytes
mcap_tar, mcap_member, mcap_offset, mcap_bytes: where the episode's native sensor file sits: tar archive, file name, byte offset and size (lets you read one episode without extracting the archive)

How the data was curated

Contributors recorded a named task with a head-mounted monocular camera, during their own work, in their own workplace or home.
A dense vision-language pass segmented every recording in time and kept only the stretches where the wearer's hands perform the task, so 96.9% of kept time is on-task.
Human review decisions, where available, override the automated ones; frame timing, repeated frames and frame-rate drift are logged per episode in the catalog.
Privacy filtering (below) was applied to every episode before release.
Hours were rebalanced across tasks, so no single task type dominates the release.

Privacy

The dataset contains egocentric footage recorded by contributors who agreed to have their recordings used to train and evaluate AI and robotics systems. Before release, we removed personal and sensitive content from the footage.

What was removed before release:

Stretches where a child, another person's face or private text (documents, screens, cards, licence plates) was detected, cut out with a margin; recordings where faces fill a large share of the footage.
Episodes in which the video annotation detected a minor.
Care tasks performed on another person.
Audio, location, device identifiers and contributor identity.

Citation

@dataset{hubego100k2026,
  author    = {Hub Data, Inc.},
  title     = {HubEgo-100K},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/Hubdata/HubEgo-100K}
}

License and attribution

CC BY 4.0 (LICENSE.md): free to use, share and adapt for any purpose, including commercially, with credit.

Credit: "HubEgo-100K, Hub Data, Inc., https://huggingface.co/datasets/Hubdata/HubEgo-100K, CC BY 4.0".

Contact, including removal and privacy requests: legal@hub.xyz

Downloads last month: 174

Total file size:

44.8 TB

Space using Hubdata/HubEgo-100K 1

Collection including Hubdata/HubEgo-100K

HubEgo

Collection

100,000 hours of egocentric videos of skilled manual work for robot learning, recorded in real workplaces. RGB + IMU, LeRobot + MCAP, CC BY 4.0. • 1 item • Updated about 13 hours ago