export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

export default function init_synadata() {

async function process_interaction(frame) {

const engine = new EgoCentricEngine(config);

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

let features = await SynaData.extract(frame);

// Training manipulation policies with SynaData

await hoi_model.process(ego_centric_video);

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

if (confidence > 0.95) execute_lifting();

return SynaData.lifting(features);

PhysicalAI.init_environment();

SynaData.stream().pipe(SynaPath);

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

Robowheel.navigate(target_pos);

}

Converting Human Video to Physical AI Data

About SynaData

A scalable path from monocular video to model-ready training data.

SynaData is an end-to-end data pipeline for embodied AI, built to turn monocular internet video into model-ready training data.

Through scalable data capture, structured processing, and standardized delivery, we convert human behavior, robot manipulation signals, and egocentric perception into high-quality data products for training.

Core Technology

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

Based on video dimension elevation and cross-domain reconstruction, Synapath connects internet video, robot action, and physically executable data products in one pipeline.

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

SynaData 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

SynaData 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.

Data Collection at Scale, Without Lab-Only Constraints

SynaData breaks beyond the limits of lab-bound embodied AI data collection through a dual-engine approach: distributed real-world capture points and large-scale internet video conversion.

Compared with costly, low-throughput teleoperation and motion-capture pipelines, SynaData expands potential annual data supply to the billion-scale by leveraging passive capture in real operational environments and efficiently converting global video sources into training data.

We turn real-world interaction into learning signals for robots — at scale, at low cost, and with the long-tail coverage required for real deployment. This approach has already been validated through deliveries to leading humanoid robotics companies and research institutions.

10 Billion+

Potential Annual Data

±0.5cm

Trajectory Reconstruction Precision

98%

Transfer Success Rate

Research & Open Source

Work that extends the Synapath 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 Synapath’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 ↗

Product Samples

Data products designed for embodied AI training.

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

Motion capture data Locomotion

Generate human motion data from human motion videos for locomotion research and training.

Single-Arm and Bimanual Manipulation

High-quality demonstration data for single-arm and dual-arm manipulation learning, with an emphasis on coordinated bimanual behavior.

Whole-Body Humanoid Manipulation

Manipulation data for full humanoid systems, with a focus on coordinated upper-body and torso action.

Egocentric Video

First-person behavioral data for embodied AI and multimodal model training.

Human-Object Interaction

Structured data products that capture human-object interaction processes, including actions, contact relationships, and object-state changes.

Synthetic and Augmented Data

Synthetic or enhanced data designed to supplement real-world data in rare, high-risk, or hard-to-collect scenarios.

View more details

Download Manual (EN)