export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

export default function init_DexData() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

const hoi_model = new HumanObjectInteraction({ mode: "ego centric" });

let features = await DexData.extract(frame);

// Training manipulation policies with DexData

await hoi_model.process(ego_centric_video);

let target_motion = Dexym.retargeting(source, skeleton);

if (confidence > 0.95) execute_lifting();

return DexData.lifting(features);

PhysicalAI.init_environment();

DexData.stream().pipe(Dexym);

const robot_state = new EmbodiedAI({ platform: "Robowheel" });

Robowheel.navigate(target_pos);

}

Embodied AI Data Engine

Powering the next
generation of robots.

Dexym provides the high-fidelity egocentric data and simulation environments needed to train truly capable autonomous agents.

Book Demo Explore Technology

Data Collection at Scale, Without Lab-Only Constraints

150K+

High-Quality Trajectories

±0.5cm

Trajectory Reconstruction Precision

98%

Transfer Success Rate

Product Samples

Data products designed for embodied AI training.

Full-stack Embodied AI data solutions, accelerating model iteration and deployment

Catering table setting 1 carrying plates

Sample data from ego category.

View more details

Download Manual (EN)

Core Technology

Build high-quality data pipelines from visual perception to physical operations.

Based on video dimension elevation and cross-domain reconstruction, Dexym connects internet video, distributed real-world capture, and high-fidelity simulation to create a continuous, model-ready data stream.

Cross-Domain Retargeting

Our dynamic structural adaptation algorithm enables precise retargeting across different embodiments, reducing imitation error by over 50% and improving task success rates by 40%, while significantly lowering the cost of transferring human behavior to robot action.

Dynamics Compensation

To address the dynamics gap between human motion and robot execution, such as manipulator vibration, we use virtual-environment compensation to enable seamless cross-embodiment transfer. In simulation, this improves success rates to 98%, a 40% gain over baseline.

Millimeter-Scale Trajectory Extraction

DexData addresses the loss of depth information and object occlusion in monocular video, reducing trajectory reconstruction error from the conventional ±5 cm range to ±0.5 cm — enough to meet industrial-grade precision requirements.

Physics-Aware Constraints

DexData incorporates physical parameters such as friction, inertia, and gravity to overcome the lack of realistic constraints in simulation, helping ensure that generated actions remain executable in the real world.

Research & Open Source

Work that extends the Dexym data engine.

HORA

HORA is an industry-first multimodal embodied AI training dataset extracted from real-world human video. Built to address the scarcity and cost of robot training data, HORA replaces traditional manual teleoperation collection with Dexym’s proprietary video-to-data pipeline, converting large volumes of human operation video into robot-learnable training data. The dataset contains more than 150,000 high-quality trajectories and introduces key innovations in both structure and modality.

Details

RoboWheel

RoboWheel is a robotics data engine built for cross-embodiment, multimodal, and high-fidelity physical interaction data. It provides a full pipeline from human operation video to robot-usable data, while opening a critical path toward scalable, physically grounded HOI data for robot foundation models.

Details

Powering the next generation of robots.

Data Collection at Scale, Without Lab-Only Constraints

Data products designed for embodied AI training.

Catering table setting 1 carrying plates

Build high-quality data pipelines from visual perception to physical operations.

Cross-Domain Retargeting

Dynamics Compensation

Millimeter-Scale Trajectory Extraction

Physics-Aware Constraints

Work that extends the Dexym data engine.

HORA

RoboWheel

Powering the next
generation of robots.