EgoSteer/EgoSteer-RealWorld

EgoSteer Real-World Bimanual Teleoperation Dataset

EgoSteer-RealWorld is the real-robot dataset collected and used in EgoSteer: A Full-Stack System Towards Steerable Dexterous Manipulation from Egocentric Videos. It contains 54,454 teleoperated episodes (192 hours, 20.75 M frames) of bimanual dexterous manipulation across 193 tasks, recorded on a RealMan dual-arm robot with two Ruiyan dexterous hands and two RGB-D cameras (head and chest), with free-form English language instructions for every episode. In the EgoSteer system, this dataset grounds the manipulation priors that EgoSteer-3B-Base learned from 9.6K hours of egocentric human videos onto the RealMan embodiment, producing EgoSteer-3B-RealMan. The dataset is released in LeRobot v3 format.

At a glance

Episodes	54,454 (train 54,261 / val 193)
Tasks	193 (56 common + 137 long-tail, seven manipulation categories)
Frames	20,750,677 per stream at 30 Hz (192.1 h)
Episode length	median 321 frames (10.7 s); min 43, max 3,076
Cameras	head RGB-D and chest RGB-D, 640×480
Proprioception	74-dim observation.state and action (arm joints, hand joints, wrist poses, fingertip positions)
Language	1–12 English instructions per episode (typically 2–3)
Size	3.2 TB (depth 2.65 TB, RGB 510 GB, parquet 17 GB)
Format	LeRobot v3 (codebase_version: v3.0), robot_type: egosteer_realman_bimanual

Robot and sensors

Overview of the Robot Stack (paper Figure 3). It unifiedly supports teleoperation, policy inference and human-in-the-loop correction; the bottom-left shows the RealMan embodiment on which this dataset was collected.

The RealMan embodiment consists of two 7-DoF RealMan RM75-6F arms (arm1 = left, arm2 = right) and two 6-DoF Ruiyan RY-H2 dexterous hands (hand1 = left, hand2 = right). It carries one head-mounted and one chest-mounted Intel RealSense D455 camera, giving two egocentric viewpoints; the head camera frame is the world frame of the dataset, and the chest camera is described relative to it.

For teleoperation, a pair of PsiBot SynGlove-Air gloves and Vive Trackers capture the operator's wrist poses and hand joint angles, which drive the arms through inverse kinematics (mink) and the hands through joint mapping. The tracker, arm solvers and arm controllers run at 100 Hz, the glove, hand solvers and hand controllers at 80 Hz, and the cameras at 30 Hz. Data are recorded at these native rates and resampled to 30 Hz in this release (see Time alignment). The complete stack, which also serves policy inference and human-in-the-loop correction with the same control nodes, is open source in robot-stack.

All joint names match the MuJoCo models shipped in robot-stack (assets/robot_mjcf, assets/ruiyan_hand_mjcf) character for character, so mj_name2id can index them directly. joint_linkN means "the joint that drives linkN".

Data collection

Within the kinematic limits of the RealMan embodiment we designed 193 semantically distinct tabletop manipulation tasks and collected roughly 300 randomized demonstrations (about one hour) for most of them. The tasks fall into two groups:

• Common tasks (56): everyday manipulations that are readily achievable with the current hardware and sensors, with high teleoperation success rates.
• Long-tail tasks (137): infrequent and physically challenging manipulations, such as contact-sensitive operations without tactile feedback, included to cover the dexterous manipulation space as completely as possible.

By motion characteristics and physical interaction, the tasks span seven categories:

Category	Description
PnP-Easy	Single-step tabletop pick-and-place with easily graspable objects and open placement space
PnP-Medium	Non-planar or 3D pick-and-place involving containers, demanding higher precision and spatial perception (e.g. put tennis ball into ball holder)
PnP-Hard	Multi-step or high-precision pick-and-place sequences (e.g. stack paper cups)
Non-prehensile	Pushing, pulling, pressing and other actions without finger grasping
Reorient	Rotation and reorientation (e.g. pour water, flip paper cups)
Bimanual	Tasks requiring tight synchronization and spatial coordination of both arms and hands (e.g. plug cable into charger)
Contact-rich	Frequent and complex physical contact requiring physical understanding (e.g. wipe whiteboard)

Representative task examples across the seven manipulation categories.

The task names are listed in meta/tasks.parquet and act as categories (task_index on every frame); the language supervision comes from the per-episode instructions described in the next section.

All 193 tasks with episode counts

Task	Episodes
Grasp an Object	2,209
Place the Phone on the Phone Stand	678
Put the Eyeglasses in the Case	567
Stand the Shuttlecock Upright	528
Take an Object out of the Drawer	508
Ink the Stamp	502
Open the Box	490
Stand the Spray Bottle Upright	480
Open or Close the Water Gun	471
Place the Bread on the Tray	457
Place the Liner on the Tray	430
Press the Summoning Bell	430
Flip the Paper Cup Over	429
Put the Flowers into the Vase	426
Stack the Paper Cups	412
Stick the Playing Card on the Whiteboard	411
Put the Toothpaste into the Toothpaste Box	409
Shake the Water Bottle	396
Shuffle the Cards	392
Press the Specified Keys on the Keyboard	380
Place the Toy Chick on the Base	379
Shake the Dice Cup	379
Seal the Test Tube with a Stopper	377
Stack the Paper Cups into a Pyramid	373
Divide the Cards into Three Stacks	372
Flip the Phone Over	369
Wipe the Whiteboard with the Magnetic Eraser	356
Iron Clothes	345
Move a Chinese Chess Piece	334
Place the Mouse on the Mouse Pad	332
Pull Out the Tape Measure	329
Put the Hat on the Mannequin	329
Roll the Die	329
Separate the Stacked Tableware	329
Take the Jelly from a Person’s Hand	329
Close the Laptop	328
Insert a Straw into the Cup	327
Separate the Paper Cups	327
Swap the Positions of Two Objects	327
Put the Tea Bag into the Teapot	326
Lay the Towel on the Rack	324
Put Items into the Paper Box	324
Put the Shoes into the Shoebox	324
Take the Clothes out of the Bag	324
Close the Toothpaste Cap	323
Place the Stapler on the Book	323
Put the Markers into the Pen Holder	323
Weigh the Object	323
Build a Wall	322
Lay Out the Placemat	322
Open the Folding Fan	322
Remove the Tape from the Object	322
Stamp the Paper	322
Pour the Contents out of the Box	321
Use a Lint Roller on Clothes	321
Close the Trash Can	320
Flip an Object Over	320
Pour Water into the Cup	320
Scoop Water with a Metal Spoon	320
Arrange Magnets of the Same Color in a Row on the Whiteboard	318
Push the Block with a Marker	318
Put the Orange into the Basket	318
Sweep the Trash	317
Brush Shoes with a Shoe Brush	316
Open the Drawer	316
Separate Two Building Blocks	316
Take off the Hat	316
Fold the Towel	315
Take the Eyeglasses out of the Case	315
Pull the Object to Move It	312
Stir the Sand	311
Attach the Magnetic Eraser to the Whiteboard	310
Play Whac-A-Mole with a Hammer	309
Open the Lunch Box	308
Place the Screwdrivers on the Rack	308
Take Markers from the Pen Holder	308
Turn On the Fan	308
Put the Book into the Backpack	306
Stand the Screw Upright	305
Unplug the Charger from the Power Strip	301
Fill the Paper Cup with Candies	300
Fold Clothes	299
Open the Trash Can	299
Close the Lunch Box	298
Cover an Object with a Paper Cup	298
Put the Coins into the Piggy Bank	297
Stack the Toy Cups from Smallest to Largest	297
Deal the Cards	289
Lift the Teapot and Pour Water	286
Place the Paper Cup on the Coaster	286
Remove the Marker Cap	286
Play the Drum with a Drumstick	284
Open the Stationery Pouch	283
Shake the Die with a Paper Cup	283
Pick Up Paper Clips with a Magnet	280
Close the Book	279
Pick Up the Magnet	278
Nudge the Die	277
Place the Tableware on the Tray	277
Straighten the Rope	277
Place the Object in the Specified Position	276
Press the Power Strip Switch	274
Squeeze the Squeaky Chicken	274
Build a Block Pyramid	272
Wind the Rope	270
Lift the Trash Bag with One Hand	269
Push the Ball into the Box	267
Close the Laptop Stand	266
Assemble the Building Blocks	259
Open the Laptop	259
Pull Out a Tissue	256
Put the Trash into the Trash Can	253
Stack the Chinese Chess Pieces	253
Place the Bookmark in the Book	250
Put the Lid on the Teapot	249
Scoop Rice into the Cup with a Spoon	248
Take the Objects out of the Container	247
Stack the Tableware	239
Open the Book	230
Open the Ring Binder	230
Place an Object in a Person’s Hand	230
Put the Tennis Balls into the Tennis Tube	230
Stir the Coffee with a Spoon	230
Place the Strainer in the Cup	229
Stick a Sticky Note onto an Object	229
Take the Books out of the Backpack	229
Transfer the Object between Hands	229
Wear the ID Badge	229
Turn On the Desk Lamp	228
Hang an Object on a Hook	227
Push the Object onto the Specified Color Region	227
Sprinkle Seasoning	227
Stretch the Play Dough	227
Wipe the Spill with a Cloth	227
Stack the Blocks by Size	226
Assemble a Tangram	225
Put the Toothpaste and Toothbrush into the Cup	225
Swing the Toy Bear’s Arm	225
Place the Shoes on the Shoe Rack	224
Turn Off the Desk Lamp	224
Untie the Bow	223
Sweep the Trash into the Dustpan	222
Strike the Sponge with a Hammer	213
Write on the Whiteboard with a Marker	213
Bag the Groceries	211
Wave the Clapper	211
Stack the Metal Bowls	210
Press or Squeeze the Object	209
Cross the Drumsticks in the Air	208
Fold the Eyeglasses	206
Squeeze the Squishy Toy	206
Wipe the Plate with a Scouring Sponge	206
Arrange the Blocks by Size	205
Shake the Small Bell	204
Flatten the Towel	202
Pet the Plush Toy	199
Open the Toothpaste Cap	198
Plug the Charger into the Power Strip	196
Shake the Test Tube	196
Peel off the Sticky Note	195
Push the Object	193
Point at an Object	185
Lift the Teapot	184
Rotate the Bracelet	181
Lift the Trash Bag with Both Hands	180
Put the Paper Clips Back into the Box	179
Separate the Paper Cups with Both Hands	178
Take the Lid Off the Teapot	177
Take the Shoes out of the Shoebox	163
Strike Metal Bowls Together in the Air	156
Make Various Hand Gestures	155
Arrange the Three Bottles in a Row	154
Take the Toilet Paper off the Holder	151
Rotate the Cube	146
Spin the Globe	137
Fold Paper Boxes	134
Take the Tea Bag out of the Tea Box	134
Flip Calendar Pages	132
Place the Toilet Paper on the Holder	130
Remove the Cap from the Plastic Bottle	128
Connect the Data Cable to the Charger	127
Put an Object into the Drawer	126
Separate the Stack of Blocks	122
Crush Nutrient Soil with a Wooden Stick	120
Put the Items into the Container	109
Pick Up the End of the Mouse Cable	108
Toss a Ring over the Object	101
Move the Plush Toy	80
Separate the Charger and Data Cable	74
Sort the Items	60
Put on the Glove	49
Lay Bricks	30
Hit the Ball into the Goal	25

Every trajectory was collected under strict requirements on randomness, diversity and quality. The tabletop is cluttered and unstructured rather than pre-arranged: tablecloths, object instances and initial configurations are randomized and no trajectory is scripted, so a task cannot be identified from the visual input alone and the policy has to align the language instruction with the physical action. Operators were instructed to teleoperate in a natural, human-like manner, so demonstrations of the same task differ substantially in their execution.

Dataset statistics: word clouds and top-30 frequencies of nouns and verbs in the language annotations, task duration by the seven categories, and per-task duration for the 56 common and 137 long-tail tasks.

Language annotations

Each episode carries multi-level language annotations in the episode-level instructions column. They were produced in three steps:

1. Model annotation. Qwen3-VL-Flash watched the synchronized head and chest videos of the episode together with the task name and wrote three English descriptions at increasing granularity: a short verb–noun gist (L1), a description of the action and the manipulated objects naming the acting hand (L2), and a step-by-step sequence of the key functional actions (L3). The prompt is given below.
2. Human verification. Annotators checked and corrected every description while working in Chinese, using the videos as reference.
3. Back-translation. The verified Chinese text was translated back into English, which is what the dataset ships.

Because the wording passed through a vision-language model, human reviewers and two translations, individual instructions can be imprecise: the model may misread a scene, reviewers differ in expertise and attention, and translation can introduce ambiguity or shift a term (for example, Chinese chess pieces named by their characters). Instructions are consistent with the task and the video at the level of intent, but should not be taken as verbatim ground truth for every detail.

Head and chest views of one trajectory with its three-level language annotations.

Language labeling prompt (Qwen3-VL-Flash)

**CRITICAL VISUAL CONTEXT & PRIOR (READ CAREFULLY):**
You are observing two synchronized egocentric videos (Head View: top, Chest View: bottom) of an agent performing a manipulation task. This output will be used as language instructions for robotic training.
1. **The Agent's Hand:** The moving entity is the agent's bare end-effector. It generally has a grey base and black fingers.
2. **COLORED TIPS WARNING:** The tips/pads of the fingers often have GREEN, ORANGE, or RED tape/markers on them. THESE ARE PART OF THE FINGERS. They are NOT separate tools.
3. **EMPTY-HANDED PRIOR:** The agent is operating empty-handed. NEVER describe the agent as holding or using a 'green-tipped tool', 'hot knife', 'pliers', or any handheld instrument.
4. **ABSOLUTE GROUND TRUTH (TASK ALIGNMENT):** The specific task is **[{task_name}]**. This task name is your absolute ground truth for interpreting WHAT is being manipulated (Objects) and HOW it is being manipulated (Verbs). You MUST use the exact nouns implied by the task name.
5. **GRAMMAR:** Your description must be in **simple present tense**. Write in fluent English, avoid awkward phrasing.

**OBJECTIVE:**
Describe the agent's actions (focusing strictly on hand-object interactions) in **simple present tense** by integrating information from both views into a single, unified description at three levels of detail. **Since this is for robot training, you MUST completely ignore all task-irrelevant items.**

**CONSTRAINTS:**
1. **Unified Description:** Provide ONE consolidated set of descriptions.
2. **Levels of Detail:**
   - **Level 1 (Gist):** A concise summary of the main action. Should always be a verb+noun phrase (i.e Ring a bell) (<20 words).
   - **Level 2 (Descriptive):** Main action + features and spatial layout of the **ACTIVELY MANIPULATED OBJECTS ONLY** (<40 words). **DO NOT list or describe any stationary background clutter.** In your description, list which hand is performing the action.
   - **Level 3 (Sequential):** The step-by-step temporal flow of key functional actions (<70 words). Include essential phases (reach -> manipulate -> release) but OMIT trivial micro-adjustments or hovering. List which hand is performing each action.
3. **Zero Subjects (Strict):** **Start every single sentence directly with a verb** (e.g., 'Reach for...', 'Grasp...'). DO NOT use subjects (e.g., 'The person', 'The robot', 'The hand', 'It').
4. **Strict Focus on Interaction (NO CLUTTER):** Focus ONLY on the objects being actively touched, moved, or interacted with (and their immediate targets/receptacles). **Completely IGNORE all irrelevant background items** (e.g., wipes, boxes, tubes, stands that are not part of the task). Never write phrases like 'other items remain unchanged' or 'in the background'.
5. **Vocabulary Restrictions:**
   - DO NOT output words like 'robot', 'mechanical arm', 'gripper', 'human', or 'finger'.
   - DO NOT output colors of the agent's hand/tips.
6. **Task Vocabulary (Verbs & Nouns):** Your choice of verbs AND target nouns must strictly align with the task **[{task_name}]**.
7. **Action Logic & Validation:** Focus on the actual state changes of the objects. Verify actual contact using both views.
8. **Object Disambiguation:** Use spatial descriptors (e.g., 'the topmost card') ONLY for task-relevant items to distinguish them from each other.
9. **Tense:** Use **Simple Present** tense (e.g., 'reach', 'grasp', 'slide').
10. **Spatial Description:** Use the camera frame as the reference.
   - Use **'upper', 'middle', 'lower'** to describe distance of objects on table. For example, 'the upper left of the table' refers to the far side of the table, and 'the lower left' refers to the near side.
   - Use 'left' 'right' to describe horizontal relationships
   - Use 'on', 'on top of', 'above', 'below' etc. to describe vertical relationships.

**OUTPUT FORMAT:**
1. [Level 1 Description]
2. [Level 2 Description]
3. [Level 3 Description]

**EXAMPLE (If Task Name is 'Draw_cards'):**
1. Draw playing cards.
2. Slide the top cards from a central deck with left hand to draw them to the lower part of the table.
3. Reach toward the central deck with left hand, press down on the topmost card, and slide it backward. Return to the deck, press on the next card, and slide it backward to complete the draw.

Splits

The val split contains exactly one episode per task, drawn at random: 193 episodes; all other 54,261 episodes are train. Validation episodes are stored at the end of the episode index range so that the standard LeRobot splits field can express them (val: 54261:54454); the split column in meta/episodes carries the same information.

Dataset structure

EgoSteer-RealWorld/
├── meta/
│   ├── info.json                              # features, fps, totals, splits
│   ├── stats.json                             # global per-feature statistics
│   ├── tasks.parquet                          # task_index <-> task name (193 rows)
│   └── episodes/chunk-000/file-00[0-5].parquet   # one row per episode: length, task, instructions, calibration, stats
├── data/chunk-00[01]/file-XXX.parquet         # frame-level state/action/indices, 1,769 files
├── videos/
│   ├── observation.images.head/chunk-00[01]/file-XXX.mp4          # RGB, h264, 1,769 files
│   ├── observation.images.chest/...                               # RGB, h264, 1,769 files
│   ├── observation.images.head_depth/chunk-00[0-9]/file-XXX.mp4   # depth, HEVC 12-bit lossless, 9,342 files
│   └── observation.images.chest_depth/...                         # depth, 9,342 files
└── assets/                                    # figures used in this card

Each parquet file and each video file contains a set of complete episodes: no episode is split across two files. In addition, every video keyframe is placed at the start of an episode, so reading one episode means seeking to its start timestamp (videos/<key>/from_timestamp in meta/episodes) and decoding up to its end timestamp, without decoding the episodes stored before it in the same file.

Frame-level features

Feature	dtype	shape	Description
observation.images.head	video	(480, 640, 3)	Head camera RGB. The head camera frame is the world frame.
observation.images.chest	video	(480, 640, 3)	Chest camera RGB.
observation.images.head_depth	video	(480, 640, 1)	Head camera depth (is_depth_map: true, see Depth).
observation.images.chest_depth	video	(480, 640, 1)	Chest camera depth.
observation.state	float32	(74,)	Measured robot state, layout below.
action	float32	(74,)	Commanded targets at the same instant, same layout.
timestamp	float32	(1,)	Seconds since the start of the episode, frame_index / 30.
frame_index, episode_index, index, task_index	int64	(1,)	Standard LeRobot indices.

State and action layout (74 dims)

observation.state and action share one layout: the state holds the measured values, the action the commanded targets at the same instant.

Slice	Content	Unit	Names
[0:7]	Left arm joint angles	rad	arm1_joint_link1 … 7
[7:14]	Right arm joint angles	rad	arm2_joint_link1 … 7
[14:20]	Left hand: thumb rotation, thumb bend, index, middle, ring, pinky	normalized	hand1_joint_link_1_1, _1_2, _2_1, _3_1, _4_1, _5_1
[20:26]	Right hand, same order	normalized	hand2_joint_link_*
[26:35]	Left wrist pose in the world (head camera) frame: position xyz, rotation as 6D	m, –	left_wrist_x/y/z, left_wrist_rot6d_0 … 5
[35:44]	Right wrist pose, same layout	m, –	right_wrist_*
[44:59]	Left fingertip positions in the world frame: thumb, index, middle, ring, pinky × xyz	m	left_tip_<finger>_x/y/z
[59:74]	Right fingertip positions, same layout	m	right_tip_<finger>_x/y/z

Notes:

• Wrist poses and fingertip positions ([26:74]) are computed by forward kinematics from the joint values, the robot model and the per-episode hand-eye calibration. This is the unified human-to-robot action representation used by EgoSteer: wrist translation, 6D wrist rotation and fingertip keypoints of both hands in the camera frame. As described in the paper (Appendix B), the wrist frame is shifted axially forward so that the wrist-to-fingertip scale matches human proportions.
• 6D rotation is the first two columns of the rotation matrix, flattened column-major: [R00, R10, R20, R01, R11, R21].
• Hand channels are normalized driver values of the RY-H2 hand rather than joint angles: the thumb-rotation channel spans [0, 0.6], the other five [0, 1].

Episode-level metadata

meta/episodes/*.parquet has one row per episode with the standard LeRobot columns (episode_index, length, tasks, dataset_from_index, dataset_to_index, data/video file indices and timestamps, per-episode stats/*) plus:

Column	Type	Description
split	str	"train" or "val"
instructions	list[str]	English instructions for this episode (1–12, typically 2–3)
calibration/head_intrinsics, calibration/chest_intrinsics	float64 (9,)	Camera intrinsics K (3×3, row-major, for 640×480)
calibration/head_cam_to_left_base, calibration/head_cam_to_right_base, calibration/chest_cam_to_left_base, calibration/chest_cam_to_right_base	float64 (16,)	Hand-eye calibration matrices (4×4, row-major), as produced by the calibration tool
calibration/head_world2cam	float64 (16,)	Identity (the world frame is the head camera frame)
calibration/chest_world2cam	float64 (16,)	Transform from the world (head camera) frame to the chest camera frame

Time alignment

All eleven raw streams (two RGB, two depth, arm and hand states and commands) were recorded with their own timestamps at their native rates. Each episode is resampled onto a uniform 30 Hz grid that starts when every stream is available and ends when the first stream stops. Every stream is sampled by nearest neighbour to the grid time, with no interpolation and no zero-order hold. This is exactly what the EgoSteer inference stack does at run time, so the train and deployment time offsets between images and joints follow the same distribution.

Video encoding

Stream	Codec	Notes
RGB	h264 (libx264), crf 18, g 15, yuv420p	Encoded once from the camera JPEGs; 37–38 dB PSNR against the source frames
Depth	HEVC Main 12, gray12le, x265 lossless=1	LeRobot's standard depth pipeline (DepthEncoderConfig, default parameters)

Depth

Depth is stored with LeRobot's built-in depth video pipeline: metric depth is log-quantized to 12 bits over [0.01, 10.0] m (shift 3.5) and the quantized values are encoded losslessly. Within the working range of 0.5–2 m the quantization step is 1.3–1.8 mm, below the sensor noise. The quantization parameters are stored in meta/info.json, and LeRobotDataset dequantizes automatically; choose the unit with depth_output_unit="mm" or "m". A value of 0 means invalid / no return.

Coordinate frames and calibration

• World frame ≡ head camera frame (calibration/head_world2cam is the identity). All wrist poses and fingertip positions are expressed in it.
• A_to_B matrices map points from frame A to frame B: p_base = cam_to_base @ p_cam. The hand-eye matrices come from an eye-to-hand calibration (OpenCV calibrateHandEye, PARK) and are published unchanged.
• chest_world2cam = inv(chest_cam_to_left_base) @ head_cam_to_left_base (derived through the left arm).
• Lengths are in metres, angles in radians, matrices row-major, points are column vectors.

Loading the dataset

from lerobot.datasets.lerobot_dataset import LeRobotDataset

# The full dataset is 3.2 TB. LeRobot downloads it into ~/.cache/huggingface/lerobot by default.
ds = LeRobotDataset("EgoSteer/EgoSteer-RealWorld", depth_output_unit="mm")

frame = ds[0]
frame["observation.images.head"]         # float32 [3, 480, 640] in [0, 1]
frame["observation.images.head_depth"]   # float32 [1, 480, 640], millimetres, 0 = invalid
frame["observation.state"]               # float32 [74]
frame["action"]                          # float32 [74]
frame["task"]                            # task name

ep = ds.meta.episodes[frame["episode_index"].item()]
ep["instructions"]                       # list of English instructions for this episode
ep["calibration/head_intrinsics"]        # 9 floats, K row-major

# Only the validation episodes (one per task):
val = LeRobotDataset("EgoSteer/EgoSteer-RealWorld", episodes=list(range(54261, 54454)))

Tips:

• Random single-frame access decodes four videos; the depth streams only have a keyframe at the start of each episode, so random access costs about a second per frame. Iterating an episode in order, or decoding episodes with PyAV directly from meta/episodes (videos/<key>/from_timestamp … to_timestamp), is fast.
• To inspect the dataset before downloading the videos, fetch only the metadata and parquet files: hf download EgoSteer/EgoSteer-RealWorld --repo-type dataset --include "meta/*" "data/*" (17 GB).
• Depth quantization and every encoding parameter are recorded under features.*.info in meta/info.json.

Training EgoSteer on this dataset

The EgoSteer training code reads WebDataset shards. Convert the release with the script shipped there, then fine-tune from EgoSteer-3B-Base:

python scripts/lerobot_to_wds.py --root /path/EgoSteer-RealWorld --out /path/EgoSteer-RealWorld.wds
python scripts/verify_wds.py    --wds  /path/EgoSteer-RealWorld.wds --root /path/EgoSteer-RealWorld

See data/data.md in that repository for the shard layout and the fine-tuning guide.

License

Released under the Apache License 2.0, the same license as the EgoSteer code and models.

Citation

@misc{zhong2026egosteerfullstacksteerabledexterous,
  title={EgoSteer: A Full-Stack System Towards Steerable Dexterous Manipulation from Egocentric Videos},
  author={Yifan Zhong and Zhang Chen and Tianrui Guan and Fanlian Zeng and Yuyao Ye and Tianjia He and Ka Nam Lui and Jiayi Li and Tingrui Zhang and Ruilin Yan and Xinhao Ji and Guangyu Zhao and Wenjie Lou and Jiayuan Zhang and Yuanpei Chen and Yaodong Yang},
  year={2026},
  eprint={2607.09701},
  archivePrefix={arXiv},
  primaryClass={cs.RO},
  url={https://arxiv.org/abs/2607.09701},
}