Untether your humanoid from the lab. Last-meter indoor capture from a real-world rider network. egocentric · multimodal · time-synchronized · real-world

This is the first sample release from VROONG Untether — a data-partnership program that turns South Korea's largest last-mile rider network into a continuous collection channel for general-purpose indoor navigation and built-environment interaction data.

A 110.7-second indoor capture: a single human wearer (helmet-mounted RGB-D + stereo IR + smartphone-side GPS / IMU / barometer / audio) walks a floor-3 corridor, descends three floors via stairs, crosses a lobby, passes a security gate, exits through the main door, walks briefly outdoors, re-enters, calls and rides the elevator from floor 1 to floor 3, and walks back along the floor-3 corridor.

This release is a single 110-second evaluation sample. Production-scale capture — multiple riders, multiple buildings, multiple metro regions, full label vocabulary, tens of thousands of episodes — is delivered through a paid data partnership. The sample exists so embodied AI / humanoid teams can verify schema fit, modality coverage, and label quality before committing to a partnership. See "Production data partnership" below for scope, volume, and engagement model.

📄 Companion documents (in this repo):

data-partnership-slides.pdf — strategic prospectus (10 slides). Why last-meter, what makes the data differentiated, dual-device sensor module, label schema, pilot proposal.
data-collection-apps-overview.pdf — technical deep-dive on the dual-device Android capture stack (Untether Helmet + Untether Companion), data manifest, sync model, per-event sensor snapshots from this very dataset.

Revision history

2026-05-13 (rev 2) — Schema cleanup pass after a third-party-style cold review. Breaking-but-additive changes:
- observation.state (legacy 11-dim packed vector) split into three named features: observation.head_orientation (4), observation.head_imu (6), observation.head_altitude_relative_m (1). Mixed units no longer collapsed into a single tensor.
- label.altitude_phase re-derived with a 5-sec polyfit window and explicit thresholds; new label.altitude_phase_confidence (float [0,1]) ships alongside. The v1 label classified more transients but was noisier on flat walking; v2 is smoother and confidence-bearing. See metadata.altitude_phase_derivation in info.json.
- phone.gps.host_time_ns + phone.gps.is_fresh_fix added so consumers can distinguish a new 1 Hz GPS fix from a forward-filled repeat at the 5.32 Hz frame cadence.
- meta.destination, meta.context, meta.rider in meta/episodes/... are now native parquet structs, not JSON strings. events.parquet gains six typed attribute columns (attr_direction, attr_door_size, ...) in addition to the original attributes JSON string.
- raw.tar.zst rebuilt: stripped duplicates of data/, meta/, videos/, README.md, and .DS_Store files — was 898 MB, now ~890 MB but bundle contents no longer disagree with the live README.
- info.json corrected: label.altitude_phase vocab observed in this sample now correctly listed as 6 values (was incorrectly stated as 3).
- raw/helmet/calibration.json now includes irLeftToIrRight (nominal 95 mm baseline from the Orbbec Gemini 335 series datasheet).
- raw/helmet/manifest.json updated lerobotCodebaseVersion v2.1 → v3.0 and documents the 30→5.32 fps subsampling.
2026-04-29 (rev 1) — Initial release, LeRobot v2.1 → v3.0 migrated.

Why this data

Today's humanoid robots learn almost everything they know inside controlled rooms — instrumented test bays, mocap cages, simulated apartments. The hardest distribution gap an embodied AI team faces is the one between those rooms and the buildings real people live and work in. The 1–3 minute window between curb and apartment door is where the embodied skills actually live: doors (push/pull/sliding/automatic), elevator call buttons + in-cabin floor matrices, narrow corridors with 90° turns, stair descent/ascent with handrail, lobby crossings under crowd, lighting transitions outdoor → lobby → corridor → cabin, both-handed parcel carry.

VROONG operates a fleet that enters every building type a humanoid agent would care about — high-rises, walk-ups, offices, retail arcades, hospitals, depots — across every major Korean metro, every day:

20,000+   active riders
300,000+  deliveries / day
ALL       Korean metro regions, nationwide

Variability accumulates as a side effect of normal operations.

Framing note. Data and dataset refer to general-purpose indoor navigation and built-environment interaction data. The delivery fleet is a collection mechanism, not a target domain.

What you get in this sample

Site:                      HY Building, 577 Gangnam-daero, Seocho-gu, Seoul
Recorded:                  2026-04-29 15:11:13.784 KST (== 06:11:13.784 UTC)
Duration:                  110.72 seconds
Total frames:              589 RGB-aligned timesteps at 5.32 fps (uniform 187.97 ms cadence)
Sensor streams:            helmet RGB+depth+stereo-IR + phone IMU+GPS+baro+audio
Sub-tasks (LeRobot):       17 distinct tasks across 1 episode
Format:                    LeRobot v3.0 (primary) + raw full-fidelity (in raw.tar.zst)
Label schema:              VROONG General Delivery v1.0
Total size:                ~64 MB (LeRobot tree) + ~890 MB (raw.tar.zst, cleaned in rev 2)

The LeRobot v3.0 tree (meta/, data/, videos/) renders natively in the Hugging Face preview. The raw.tar.zst bundle contains the full-fidelity sources (depth Z16/Y16, stereo IR Y8, source RGB JPEGs, calibration JSON, phone audio Opus, raw IMU/baro/GPS arrays + JSONL audit trail). Production captures will span the full label vocabulary across multiple buildings — this sample exercises a subset of one building.

Repository contents

.
├── README.md                                       this file
├── data-partnership-slides.pdf                     strategic prospectus
├── data-collection-apps-overview.pdf               capture-stack technical overview
├── meta/
│   ├── info.json                                   LeRobot v3.0 dataset descriptor (+ metadata.label_vocabularies, .event_attribute_schemas, .altitude_phase_derivation)
│   ├── tasks.parquet                               17 sub-tasks
│   ├── episodes/chunk-000/file-000.parquet         episode meta + embedded stats + destination (native structs)
│   ├── events.parquet                              9 sparse events (with typed attr_* columns)
│   └── stats.json                                  global aggregate stats + label distributions
├── data/
│   └── chunk-000/file-000.parquet                  per-timestep table (25 cols, 589 rows)
├── videos/
│   └── observation.images.helmet_rgb/chunk-000/file-000.mp4
│                                                   H.264 yuv420p tv-range, 1280×720, 5.32 fps
└── raw.tar.zst                                     ~890 MB · zstd-19 · contains:
    └── raw/
        ├── helmet/
        │   ├── calibration.json                    depth + RGB intrinsics, depth↔RGB extrinsic, IR↔IR baseline
        │   ├── manifest.json
        │   ├── rgb/<sdk_idx>.jpg                   MJPEG 1280×720  (filenames are SDK frame indices, see below)
        │   ├── depth/<sdk_idx>.raw                 Y16 little-endian, mm
        │   ├── ir_left/<sdk_idx>.raw               mono8 (Y8), 1280×720
        │   ├── ir_right/<sdk_idx>.raw              mono8 (Y8), 1280×720
        │   └── timestamps_{rgb,depth,ir_left,ir_right}.npy
        │                                           shape (N, 3) int64 [sdk_idx, sensor_us, host_ns]
        ├── body/
        │   ├── meta.json                           phone session metadata
        │   ├── audio.opus                          Opus mono 32 kbps, trimmed to window
        │   ├── imu_{accel,gyro,mag}.npz            per-sensor arrays + host_ns + mono_ns
        │   ├── baro.npz                            barometer (hPa + relative altitude m)
        │   ├── gps.npz                             GPS (lat, lon, accuracy)
        │   └── raw_jsonl/                          original JSONL streams (audit trail + README.txt)
        ├── sync.json                               wall-clock anchor sync params
        ├── frame_drop_stats.json                   per-stream frame-rate diagnostics
        └── depth_validity_stats.json               depth-mask coverage stats

Filename convention for raw helmet files. Filenames are zero-padded SDK frame indices (e.g. 000013801.raw), not parquet-row indices. To go from parquet row N to the corresponding raw file, read the SDK index from the timestamps array: sdk_idx = np.load("raw/helmet/timestamps_depth.npy")[N, 0] then load f"raw/helmet/depth/{sdk_idx:09d}.raw". See the Quickstart below.

What's in the LeRobot tree vs the raw bundle. The LeRobot v3.0 tree carries RGB as encoded H.264 video plus all phone IMU/baro/GPS streams resampled to the per-RGB-frame cadence by forward-fill (see Cadence & resampling below). Depth, stereo IR, source RGB JPEGs, calibration, raw phone-side traces, and audio live only in raw.tar.zst. Most evaluation work wants the raw bundle.

To extract:

zstd -d raw.tar.zst -c | tar -xf -
# produces ./raw/{helmet,body,sync.json,...}

Quickstart

LeRobot v3.0 native loader (lerobot ≥ 0.4.0, tested with 0.4.4)

from lerobot.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset(repo_id="vroong/untether-walk-20260429-seoul-hy-sample",
                    root="path/to/this/repo")
print(list(ds.features.keys()))
sample = ds[0]
print(sample["observation.head_orientation"].shape)   # torch.Size([4])
print(sample["observation.head_imu"].shape)            # torch.Size([6])

Or load the parquet directly

import pandas as pd
df = pd.read_parquet("data/chunk-000/file-000.parquet")
print(df.columns.tolist())
# episode_index, frame_index, index, task_index, timestamp, host_time_ns, next.done,
# observation.head_orientation, observation.head_imu, observation.head_altitude_relative_m,
# phone.imu.{accel,gyro,mag}, phone.baro.{hpa,altitude_relative_m},
# phone.gps.{lat,lon,accuracy_m,host_time_ns,is_fresh_fix},
# label.locomotion, label.zone, label.floor_index,
# label.altitude_phase, label.altitude_phase_confidence

Observation features

Feature	Shape	Dtype	Notes
`observation.head_orientation`	(4,)	float32	Unit quaternion (w,x,y,z), Madgwick-integrated from phone IMU
`observation.head_imu`	(6,)	float32	accel(3) m/s² + gyro(3) rad/s — phone IMU forwarded to helmet frame
`observation.head_altitude_relative_m`	()	float32	Barometer, relative to session start

The legacy observation.state (11-dim packed vector with mixed units) was removed in rev 2. If you depend on it, concat the three above features in order.

Decode the helmet RGB video standalone

import cv2
cap = cv2.VideoCapture("videos/observation.images.helmet_rgb/chunk-000/file-000.mp4")

Decode raw depth / IR (after extracting `raw.tar.zst`)

import numpy as np
ts = np.load("raw/helmet/timestamps_depth.npy")    # shape (589, 3) int64
sdk_idx = ts[100, 0]                                # parquet row 100 → SDK index
depth = np.fromfile(f"raw/helmet/depth/{sdk_idx:09d}.raw",
                    dtype="<u2").reshape(720, 1280)   # depth Y16 little-endian, mm
ir = np.fromfile(f"raw/helmet/ir_left/{sdk_idx:09d}.raw",
                 dtype="u1").reshape(720, 1280)       # mono8

Recompute stereo disparity from raw IR pair

import cv2, numpy as np
ir_l = np.fromfile(f"raw/helmet/ir_left/{sdk_idx:09d}.raw",  "u1").reshape(720,1280)
ir_r = np.fromfile(f"raw/helmet/ir_right/{sdk_idx:09d}.raw", "u1").reshape(720,1280)
# Stereo baseline ~95 mm (Orbbec Gemini 335 series nominal; see calibration.json)
stereo = cv2.StereoBM_create(numDisparities=64, blockSize=15)
disp = stereo.compute(ir_l, ir_r)

Cadence & resampling

The capture pipeline ran 4 helmet streams at the sensor SDK's native 30 fps internally and wrote every ~6th SDK frame to disk for storage economy — giving an as-disk cadence of **5.32 fps**. After packaging:

Parquet rows are exactly uniform at 187.97 ms (≈ 5.32 fps). All inter-frame intervals are identical to ±1 µs; the parquet does not reflect raw-SDK jitter.
Raw SDK timestamps in raw/helmet/timestamps_*.npy (host_ns column) do show jitter: dt range 135–388 ms, std 25 ms. 1 / 588 SDK gaps exceed 1.5× expected (0.17% drop rate). Frame timing in the parquet is regular by construction; frame timing in the raw bundle is irregular as captured.
Phone IMU / baro / GPS are forward-filled from their native cadence (100 Hz / 10 Hz / 1 Hz) onto each RGB row's host_time_ns.
For GPS specifically: a fresh 1 Hz fix only changes every ~5 rows. Use phone.gps.is_fresh_fix (bool) to find the row where a new fix arrived, and phone.gps.host_time_ns to know the actual fix timestamp. Of 589 rows, 67 carry a fresh fix; the other 522 are forward-fills of the most recent fresh fix.

Cross-modality sync between helmet streams is exact at the host-clock level — RGB / depth / IR_L / IR_R share an identical host_ns column when packaged at the same array index (sub-millisecond hardware offsets are preserved in sensor_us).

Label Schema (VROONG General Delivery v1.0)

Continuous per-frame labels (mutually exclusive enums) + sparse events + episode-level destination metadata. Floor numbers, unit identifiers, and business names are parameters, not enum members — the schema spans any building type, any floor, any address form.

`label.locomotion` — 15 declared values

This sample exercises 4: walking, standing, stairs_descending, elevator_riding. Full vocab also includes: running, stairs_ascending, escalator_ascending, escalator_descending, moving_walkway, vehicle_riding, vehicle_stationary, crouching, kneeling, transition, other.

`label.zone` — 29 declared values

This sample uses 7: corridor_commercial, stairwell, lobby, security_gate_zone, building_entrance, outdoor_premises, elevator_car. Full vocab covers outdoor (road/premises/construction), building entry/exit, indoor common (corridor variants, stairwell, elevator areas, escalator, parking), access control (security gate, reception desk), and destination types (recipient_doorway, store_interior, restaurant_*, parcel_locker_area, etc.).

`label.floor_index` — int8

Korean buildings: B5..B1 = -5..-1, 1F..127F = 1..127. -128 = sentinel for "in transition" (between floors). This sample: 1 (331 frames), -128 (163), 3 (95).

`label.altitude_phase` — 6 values (all observed in this sample, rev 2)

Speed-categorized vertical motion phase, decoupled from specific floors:

at_level — altitude stable (|velocity| < 0.05 m/s)
ascending_slow / descending_slow — 0.10 to 0.50 m/s (stairs)
ascending_fast / descending_fast — > 0.50 m/s (elevator)
unstable — barometer noise dominates (3-sec residual std > 0.30 m)

Counts in this sample (rev 2 derivation): at_level 374, descending_slow 136, unstable 58, ascending_slow 12, ascending_fast 5, descending_fast 4.

Use the confidence column. Pair every label.altitude_phase value with label.altitude_phase_confidence (float [0,1]). Low confidence (<0.5) flags frames where the barometer signal is noise-limited; consumers should either drop these frames or use the previous high-confidence label.

`meta/events.parquet` — 9 sparse events in this sample

Type	Count	Frames	Notable attrs
`door.push_manual`	3	13–18, 230–239, 295–304	`door_size`, `door_context`, `direction`
`stairs.handrail_grasp`	1	36–161	`hand`
`gate.swing_pass`	2	200–214, 315–324	`direction`
`elevator.call_button_press`	1	388–392	`direction: up`
`elevator.floor_button_press`	1	450–454	`target_floor: 3`
`elevator.door_open`	1	520–529	`at_floor: 3`

Each event row carries both the original attributes JSON string and typed extracted columns (attr_direction, attr_door_size, attr_door_context, attr_hand, attr_target_floor, attr_at_floor) for SQL-friendly filtering without a JSON parser. The full event vocabulary defines ~75 types across 11 categories (door, gate, elevator, escalator/stairs, item, recipient, comm, locker, vehicle, posture, hazard). Per-event attribute schemas are documented in info.json:metadata.event_attribute_schemas.

Episode-level destination metadata

Each episode row carries meta.destination (building, unit, access), meta.context (weather, lighting, crowd density), meta.rider (delivery_count_today, shift_phase). In rev 2 these are native parquet structs — load with pandas/pyarrow and access fields directly (e.g. ep["meta.destination"]["building"]["name"]).

For this sample:

destination.type: office_unit
destination.building: HY Building (office)
destination.unit.floor: 3
destination.access.security_level: lobby_security, primary_method: mixed
delivery.type: sample (not a real delivery)

Sensor Time Sync

Wall-clock anchor sync between helmet (Mac) and phone (raw/sync.json):

slope_a = 1.0 (no measurable clock-drift across this 110-second window)
intercept_b = host_time_ns − phone_monotonic_ns (constant)
All sensor host_time_ns columns share a single common clock domain.
Estimated cumulative drift: < 50 ms over 5 minutes — sufficient for IL training at IMU's 50–100 Hz cadence.
An optical 7-segment marker decoder is available for sub-millisecond cross-device alignment, but requires the rider to hold the phone display in front of the helmet camera. This sample does not use it — wall-clock anchor sync is enough at this cadence.

See data-collection-apps-overview.pdf §5 for the full alignment model.

Quality Notes

Frame rate: this sample is captured at 5 fps (observed 5.32 fps median) as a storage-economy choice for a long-shift evaluation clip — not a hardware ceiling. The depth-camera SDK runs at ~30 fps internally; this session's capture stack was configured to emit every ~6th SDK frame to disk. Production captures will be 30 fps × 1280×720, matching the standard cadence of comparable egocentric datasets (Ego4D 30 fps, Project Aria 30 fps, HOI4D 60 fps RGB / 15 fps depth, EPIC-Kitchens 50–60 fps).
Depth validity: 21.5% mean invalid pixels (Y16 == 0), range [2.8%, 76.8%]. High-invalid frames coincide with bright direct-light regions (lobby ceiling lights, exterior glass).
Cumulative head rotation (start → end): ~179° — the capture forms a near-loop, with the rider returning to within a small angular delta of the starting heading.
Helmet camera angle is downward-pitched. The capture is honest helmet-cam reality: the rider's own feet, hands, and the floor pattern are consistently visible; environmental context (corridor far-end, ceiling, head-height signage) is partially out-of-frame. Upper-body manipulation is well-captured; long-range scene structure less so.
Audio: trimmed to the same 110.72 s window as video. Original full-session audio (232.94 s) is preserved upstream.
GPS: 67 valid 1-Hz samples within window; signal quality varies (indoor multipath, accuracy_m ranges 7 m to 30 m). Use phone.gps.accuracy_m to filter; use phone.gps.is_fresh_fix to distinguish new fixes from forward-filled repeats; default to barometer + helmet IMU for indoor localization.
label.altitude_phase is barometer-derived, not ground-truth. The label is a deterministic transform of a noisy 10 Hz barometer signal — see info.json:metadata.altitude_phase_derivation for the exact rule. Pair with label.altitude_phase_confidence and treat low-confidence frames as unlabeled rather than misclassified.
No demonstrator action labels: this is a passive observation dataset. Suitable for representation learning, world models, indoor SLAM, multi-modal perception pretraining. Not directly for IL policy training (no demonstrator action signal).
Two ground-truth button-press frames were manually verified during labeling: frame #390 (finger on call button, LED illuminated) and frame #452 (finger on 3 button, LED illuminated). Encoded as elevator.call_button_press (388–392) and elevator.floor_button_press (450–454, target_floor=3) in meta/events.parquet.

What this sample is not

Not a benchmark. This is one episode from one rider in one building. A natural temporal train/test split puts whole zones and locomotion classes (e.g. elevator_riding, elevator_car) only in the test split, never in training — every supervised metric you compute on the sample will be misleading. Treat the sample as a schema/quality probe, not as an evaluation set. K-fold CV on a single trajectory also leaks (adjacent frames share labels). Real benchmark numbers come from the production capture (multiple episodes, disjoint episodes per split).
Not a production-scale dataset. One episode, one building, ~111 seconds.
Not a real delivery (delivery.type = sample, no recipient handoff).
Not labeled with demonstrator actions (passive observation only).
Not anonymized for redistribution (face / license-plate masking is part of the production pipeline, not applied to this internal evaluation sample).

The full label vocabulary and pipeline-grade outputs (MCAP / Foxglove, HDF5 + Zarr, LeRobot v3) are described in the companion PDFs. Production captures will span the full label space; this sample exercises a subset.

Production data partnership

This sample is a schema-verification artifact, not the product. The product is a continuous, paid stream of egocentric multimodal capture from VROONG's working last-mile network. Scope and shape are negotiated per partner.

What scales beyond this sample

Dimension	This sample	Production partnership
Episodes	1	thousands per month, ramping with rider onboarding
Buildings	1 (HY office, Seoul)	every Korean metro · residential / office / retail / hospital / depot
Riders	1	20,000+ active riders nationwide
Label vocabulary	4 / 7 / 6 / ~6 (subset)	full schema (15 locomotion · 29 zone · 6 altitude · ~75 event types)
Capture cadence	~5 fps (storage-economy mode)	up to ~30 fps × 1280×720 × 4-stream production profile
Real deliveries	none (`delivery.type: sample`)	actual recipient handoffs with destination + access metadata
Licensing	internal evaluation only	per-partner commercial license, anonymized for redistribution

Engagement model

Evaluate this sample — verify schema fit, modality coverage, label quality against your training stack.
Alignment call — discuss the open questions in the prospectus (slide 8): schema-fit for your training loop, modality priorities, volume ramp, licensing / anonymization / consent model.
Pilot capture — a scoped first delivery (e.g. one metro region × one building class × N hours) sized to fit your team's evaluation budget.
Production partnership — continuous capture at agreed volume / cadence / modality, delivered in your preferred format (LeRobot v3 · MCAP / Foxglove · HDF5 + Zarr).

Pipeline-grade outputs

The capture pipeline produces lossless conversion to LeRobot v3 / MCAP / Foxglove / HDF5 + Zarr — whichever shape your training stack consumes. Format choice is a partnership decision, not a re-collection event.

Get in touch

Sample access — use the access-request form on this Hugging Face page; we'll respond with the unlock within a few business days.
Partnership conversation — for scoped pilots, custom modality requests, or faster turnaround, email hyungsul.kim@vroong.com (Hyungsul Kim · CEO, VROONG Inc.).

Format Migration Notes

This dataset was originally produced in LeRobot v2.1 format and migrated to v3.0 (released 2025-10-23 with lerobot v0.4.0) on 2026-04-29. Breaking changes applied:

data_path template → {chunk_index:03d}/file-{file_index:03d} form
videos/{video_key}/chunk-X/file-X.mp4 (vs v2.1 videos/chunk-X/{video_key}/...)
meta/episodes.jsonl → meta/episodes/chunk-XXX/file-XXX.parquet
meta/tasks.jsonl → meta/tasks.parquet
meta/episodes_stats.jsonl → embedded in episodes parquet
meta/stats.json reintroduced as global aggregate
per-feature fps field added to features
canonical index column added to data parquet

Conversion is reversible via lerobot/scripts/convert_dataset_v21_to_v30.py in reverse, but this dataset targets v3.0 directly.

Roadmap

Marker-decoded sub-millisecond sync (helmet must view phone display ≥ 1× per ~30 sec).
6-DoF camera pose per frame via VIO.
Hand-pose estimation overlay (helmet-camera angle permitting).
Privacy anonymization pipeline (face / license-plate blur) before redistribution.
Higher-fps capture (planned 30 fps × 1280×720 × 4-stream production profile).
Real delivery captures with actual destination addresses (sample → production).

Provenance

Helmet rig:       Calibrated depth + RGB + stereo IR module with on-board 6-axis IMU
                  (1280×720; module is intentionally swappable — see Untether prospectus)
Helmet recorder:  Untether Helmet v0.2.0
Phone:            Android phone with IMU + barometer + GPS + microphone
Phone recorder:   Untether Companion v0.3.0
Format:           LeRobot v3.0
Label schema:     VROONG General Delivery v1.0
Operator:         VROONG Inc. · April 2026

License

Internal evaluation only. Privacy review pending. Do not redistribute.

For partnership inquiries, use the access-request form on this Hugging Face page, or email hyungsul.kim@vroong.com directly.

Downloads last month: 73

Total file size:

954 MB

You need to agree to share your contact information to access this dataset

VROONG Untether — Sample Dataset · Seoul HY Building Walk (2026-04-29)