Section 23.4: Immersive/VR teleoperation (Open-TeleVision)

"The operator wanted depth perception. The robot delivered a network delay with excellent lighting."

A Stereoscopic Operator
Warm educational cartoon scene connecting immersive VR teleoperation to robot demonstrations, operator decisions, recorded trajectories, and later policy evaluation.
Figure 23.4A: Immersive teleoperation improves operator state estimation only when visual feedback, body mapping, and latency are engineered as one system.

This section assumes familiarity with closed-loop control from section 7.1 and with depth sensing from section 8.2, both of which underpin the latency and stereoscopic analysis here. The active-perception behavior introduced in this section is extended in section 27.6, where learned policies must decide where to look during task execution. The episode quality labels and data-quality gates developed here recur directly in section 23.5, and the hand-retargeting pitfalls discussed below reappear in a humanoid context in section 46.4.

Big Picture

Picture a researcher wearing a VR headset whose gaze steers a robot's stereo cameras in real time: she tilts her head, the robot looks left, and suddenly the occluded cup handle snaps into view. That single act of active looking is why immersive teleoperation matters right now. Robot learning is bottlenecked not by algorithms but by demonstration quality, and operator perception is the hidden variable. When a human cannot judge depth or recover from occlusion, the recorded trajectory is corrupt at the source. Open-TeleVision treats the headset as a perception instrument, not a novelty. This section covers how to budget latency, audit episode quality, and decide when immersive feedback actually earns its cost in better data.

Perception Loop

Tilt your head left and, two hundred milliseconds later, the robot across the room turns its cameras to match: in that gap between intention and image lives every reason immersive teleoperation succeeds or quietly corrupts your data. Teleoperation is a closed-loop control problem with a human inside the loop, as Figure 23.4A illustrates: the same act of immersive looking that helps the operator is only useful if visual feedback, body mapping, and latency are engineered together. The operator observes a rendered state \(\tilde{o}_t\), chooses a command \(u_t\), and receives delayed feedback \(\tilde{o}_{t+\Delta}\). If stereoscopic feedback reduces pose uncertainty but increases delay, the system must quantify the tradeoff. The loop diagram below traces this end-to-end path and decomposes the delay into its five stages.

Operator (VR Headset) Latency Budget: Dt = Dt_cam + Dt_enc + Dt_net + Dt_ren + Dt_ctrl Camera Encode Network Render Control Observation: Stereo frames I_L, I_R Headset pose h_t Tracking confidence a_t Delayed state o-tilde_(t+Dt) Action & Quality: Wrist command u_t from hand retargeting map p(theta) Quality label: clean or interface-risk Robot command stereo feedback (with Dt latency)
The immersive teleoperation loop decomposes end-to-end latency into five stages, each contributing to operator perception delay. The operator observes stereo frames with headset pose and confidence metrics; actions flow through retargeting; quality labels separate clean episodes from those degraded by interface issues.

Useful immersive systems therefore log not only robot actions, but also headset pose, rendered camera stream, frame drops, hand tracking confidence, and command timestamps. One term recurs through the rest of this section and is worth defining now: hand retargeting is the mapping from the operator's tracked hand or wrist pose to the robot's own joint commands, which is necessary because human and robot hands rarely share the same reach, degrees of freedom, or joint limits.

Latency Budget

A practical budget decomposes delay as \(\Delta t = \Delta t_{camera} + \Delta t_{encode} + \Delta t_{network} + \Delta t_{render} + \Delta t_{control}\). Optimizing only one term can leave the operator with a visually rich but dynamically stale world.

Immersion Is A Measurement Claim

Immersive feedback earns its cost when it changes measurable collection quality: fewer failed grasps, faster corrections, better occlusion handling, or more diverse successful demonstrations under the same task protocol.

Library Shortcut

Start from Open-TeleVision or another maintained telepresence stack when possible. The stack handles headset streaming, active camera feedback, and hand retargeting so the research effort can focus on synchronization, safety interlocks, and data-quality labels.

A demonstration recorded through a broken interface is not a human intention: it is a human intention filtered through noise, and the policy learns the noise too. The audit below treats frame drops and delay as episode labels. This is not a performance nicety; it determines whether the resulting demonstration should be considered expert data.

# Classify immersive teleoperation episodes using delay and visual stability.
# The labels help separate expert intent from interface-induced mistakes.
episodes = [
    {"id": "vr001", "delay_ms": 72, "dropped_frames": 1, "tracking": 0.98},
    {"id": "vr002", "delay_ms": 180, "dropped_frames": 9, "tracking": 0.81},
]

for episode in episodes:
    stable_video = episode["dropped_frames"] <= 3 and episode["tracking"] >= 0.95
    acceptable_delay = episode["delay_ms"] <= 100
    label = "clean" if stable_video and acceptable_delay else "interface-risk"
    print(episode["id"], label)
vr001 clean vr002 interface-risk
Code Fragment 1: This classifier labels episodes vr001 and vr002 as "clean" or "interface-risk" by thresholding dropped frames, hand-tracking confidence, and end-to-end delay together. Episode vr002 may still be useful for robustness analysis, but it should not silently become a clean imitation target.

Step-Through: Episode Quality Labeling

Trace the classifier on the two episodes with real numbers. For vr001: dropped_frames = 1, which is at most 3, and tracking = 0.98, which is at least 0.95, so stable_video = True; delay_ms = 72, which is at most 100, so acceptable_delay = True. Both True, therefore label = "clean". For vr002: dropped_frames = 9, which exceeds 3, so the first condition already fails and stable_video = False (no need to even check tracking 0.81); delay_ms = 180 exceeds 100, so acceptable_delay = False. Either failing forces label = "interface-risk". Now try a boundary case: an episode with delay_ms = 100, dropped_frames = 3, tracking = 0.95 passes every test (all comparisons use less-than-or-equal and greater-than-or-equal), so it labels "clean". Nudge delay to 101 and it flips to "interface-risk" with nothing else changed, showing the single-millisecond cliff the thresholds create.

The expected output routes vr002 away from clean training because multiple interface signals are weak at once. This is the central engineering point: immersive teleoperation data should preserve the quality of the operator's perceptual channel. If a policy later fails on an episode labeled interface-risk, the team should inspect video delay, dropped frames, and hand tracking before blaming the manipulation model.

Those quality labels only matter because the immersive interface is doing something a fixed setup cannot, so it is worth examining exactly what extra information active visual feedback puts in the operator's hands.

Mechanism: Active Visual Feedback

Open-TeleVision-style systems change the information available to the operator. A fixed camera gives a passive view of the scene; active stereo feedback lets the operator move viewpoint, resolve occlusions, and align the robot body with task-relevant geometry. That extra perception can improve demonstrations for tasks such as opening drawers, threading tools, or reaching around clutter, where the critical state is not visible from one fixed camera.

Consider a specific case. An operator collecting drawer-opening demonstrations with a fixed overhead camera cannot see the handle recess from above, so every approach relies on an occluded view. A head-mounted stereo camera lets the operator tilt the viewpoint 30 degrees downward. This resolves the handle geometry and, in Open-TeleVision's reported evaluations on similar tabletop tasks, typically cuts failed grasp attempts from roughly 40% to under 10% (Cheng et al., 2024); exact numbers vary by task and operator, so treat the figures as illustrative rather than guaranteed. The information chain is direct. Stereoscopic parallax resolves depth at 20 to 50 cm range, the operator sees the handle lip clearly, the approach angle improves, and the recorded wrist trajectory carries that improvement into the training set. To put this concretely: under favorable conditions, a policy trained on 300 clean immersive episodes can approach the manipulation success rate of one trained on roughly 2,000 episodes collected under the same task with a fixed overhead camera, though this ratio is a rough illustration rather than a fixed conversion rate (the kind of data-scaling tradeoff studied directly in later chapters). Each immersive episode contains far fewer approach errors that the policy must later unlearn. The same benefit does not appear when the critical geometry is already visible from a fixed camera, so measuring per-task grasp success rate before and after adding immersive feedback beats assuming it always helps.

Checkpoint

So far: active stereo feedback lets the operator resolve occlusions that a fixed camera cannot, stereoscopic parallax turns that viewpoint change into an accurate depth cue, and the resulting cleaner approach trajectories are why fewer immersive demonstrations can match the value of many fixed-camera ones on occlusion-heavy tasks.

Where the operator looks is also data

Active feedback also introduces a second policy-like behavior: the human chooses not only hand motion, but also where to look, a capability called active gaze control. A dataset that keeps headset pose and camera motion can later train or evaluate active perception policies. A dataset that stores only wrist images discards the reason immersion helped.

What happens when the policy reaches a precision insertion step but has never learned to look for the target hole first? It fails repeatedly at exactly that moment, with no mechanism to recover, because the training data never captured the viewpoint shift that resolves it.

Active gaze control matters in embodied AI because a real robot cannot pause to re-examine a scene. It must gather visual evidence while acting. When an operator looks around intelligently but the system never records those gaze decisions, the learned policy receives only wrist trajectories. It gets no signal about which views resolved uncertainty before each move. On a physical robot, this gap causes failures at precisely the moment a task demands a deliberate viewpoint shift, such as before a precision insertion or after an occlusion. The policy never learned any information-gathering behavior, so it fails.

The mechanism is a pan-tilt camera mount or a gimbal on the robot's head linked to the headset's inertial measurement unit (IMU). As the operator turns their head, the IMU reports a rotation in the headset frame; the system converts that rotation to a motor command for the robot-mounted camera, completing a gaze-following loop typically at 30 to 90 Hz. The rendered stereo frames then reflect the new viewpoint with a delay set by the latency budget. Recording the headset pose stream alongside wrist images preserves both the motion and the information-gathering intent in the same episode.

Giving the operator a headset so they can choose where to look is generous. Failing to record where they actually looked is the data-collection equivalent of handing someone a map, watching them navigate perfectly, and then filing only the destination.

Algorithm: Open-TeleVision Immersive Teleoperation Session

Input: operator headset pose stream \(\{(\mathbf{h}_t, \theta_t)\}\), robot state \(\mathbf{s}_t\), stereo camera frames \(\mathbf{I}^L_t, \mathbf{I}^R_t\), calibration matrix \(\mathbf{K}\), retargeting map \(\pi: \mathcal{H} \to \mathcal{R}\)

Output: labeled episode \(\tau = \{(\mathbf{s}_t, \mathbf{a}_t, \mathbf{h}_t, \Delta t_t, q_t)\}\) with quality flag \(q \in \{\texttt{clean}, \texttt{interface\text{-}risk}\}\)

  1. Calibrate stereo rig. Run cv2.stereoCalibrate with calibration matrix \(\mathbf{K}\) and verify RMS reprojection error \(\epsilon < 1.0\) px; abort session if \(\epsilon \geq 1.0\) and log calibration version hash.
  2. Initialize latency budget. Record baseline components \(\Delta t = \Delta t_{\text{camera}} + \Delta t_{\text{encode}} + \Delta t_{\text{network}} + \Delta t_{\text{render}} + \Delta t_{\text{control}}\) and set threshold \(\Delta t^* = 100\) ms.
  3. Stream stereo feedback. At each timestep \(t\), transmit \((\mathbf{I}^L_t, \mathbf{I}^R_t)\) to the headset and render with disparity \(d_t = f \cdot b / z_t\) to give the operator depth cue at the current viewpoint \(\mathbf{h}_t\).
  4. Map operator motion to robot commands. Apply retargeting \(\mathbf{a}_t = \pi(\theta_t)\) where \(\theta_t\) is the operator wrist pose; record saturation events \(\sigma_t = \mathbf{1}[\|\nabla_{\theta} \pi(\theta_t)\| = 0]\) flagging clipped joints.
  5. Timestamp every signal. Store camera capture time \(t^c\), render time \(t^r\), command time \(t^a\), and headset pose time \(t^h\) so that end-to-end delay \(\Delta t_t = t^a - t^c\) is recoverable in replay.
  6. Record active gaze path. Log headset pose stream \(\{\mathbf{h}_t\}\) alongside wrist images; this preserves the operator's information-gathering behavior for later active-perception policy training.
  7. Monitor frame stability. Track dropped frames \(f^{\text{drop}}\) and hand-tracking confidence \(\alpha_t \in [0,1]\); flag the timestep as unstable if \(\alpha_t < 0.95\).
  8. Execute safety interlock. If deadman signal drops or workspace speed exceeds limit \(v^{\text{max}}\), halt motion, log stop event, and resume only after explicit operator confirmation.
  9. Label episode quality. After the episode ends, set \(q = \texttt{clean}\) if \(\Delta t_t \leq \Delta t^*\) for all \(t\), \(f^{\text{drop}} \leq 3\), and \(\min_t \alpha_t \geq 0.95\); otherwise set \(q = \texttt{interface\text{-}risk}\).
  10. Store labeled episode. Write \(\tau\) with metadata including calibration version, retargeting saturation count \(\sum_t \sigma_t\), mean delay \(\bar{\Delta t}\), and quality flag \(q\) to the episode archive.

Concrete Tool Anchors

The algorithm above assumes a stack that can timestamp, calibrate, and stream every one of those signals, so the next question is which concrete tools actually supply each layer.

A practical immersive stack layers four maintained components. Open-TeleVision supplies the reference design for active visual feedback and imitation-learning collection. A robot middleware layer such as ROS 2 carries robot state, commands, emergency-stop status, and camera topics. WebRTC-style streaming or a vendor headset SDK carries the visual channel. A calibration tool (Kalibr, OpenCV routines, or the platform's own stereo workflow) records the geometry that makes depth perception meaningful.

The important engineering decision is where each timestamp is created. Camera capture time, network receive time, headset render time, hand-tracking time, and robot command time should all be recorded or reconstructable. Without those anchors, a replay can look smooth while hiding the delay that shaped the operator's actions.

Immersive Interface Checks
CheckWhy It MattersEvidence To Store
Stereo calibrationDepth errors alter grasp approach and contact timing.Calibration version and reprojection error.
Headset poseActive perception changes which visual evidence the operator used.Head pose stream and camera selection.
Hand mappingHuman wrists and robot wrists do not share limits.Retargeting map and saturation events.
Safety interlockImmersion can hide physical workspace risks.Deadman state, speed scale, and stop events.
Pitfall: Presence Is Not Ground Truth

A VR operator may feel present in the robot body while the data stream is still delayed, compressed, or clipped by retargeting. Trust the synchronized logs over subjective smoothness.

Common Pitfall

Three failure modes appear repeatedly in immersive teleoperation deployments:

Think of hand retargeting saturation like writing a recipe intended for a chef with large hands, but the translation is being done by someone using a child-size measuring spoon: every measurement beyond the spoon's capacity gets recorded as "full spoon" regardless of how much more the original recipe required. The cook following the translated recipe never knows the pinch of salt was supposed to be a tablespoon; the instruction just reads "add salt" and stops there. In the same way, when retargeting hits a joint limit, the robot silently records a truncated action while the operator's hand keeps moving freely, and the policy trained on that recording has no way to recover the missing motion that was never stored.

A common misconception is that immersive VR teleoperation makes the resulting robot policy "more embodied" or improves policy performance at inference time because the operator felt present inside the robot. This is incorrect: the VR headset exists only during data collection and is invisible to the trained policy. The policy sees only recorded observations and actions, with no knowledge of how they were gathered. The correct mental model is that immersive feedback is a perceptual aid for the human operator during recording, and its only benefit to the policy is indirect: better operator perception produces trajectories with fewer approach errors and more informative gaze paths, which are better training examples. Whether those better examples actually improve the learned policy is a measurable, task-dependent question, not a given.

To catch stereo calibration drift before it corrupts a full collection session, run OpenCV's cv2.stereoCalibrate with a checkerboard pattern at the start of each day and log the RMS reprojection error. A value above 1.0 pixel signals that depth estimates are no longer trustworthy; recalibration is required before recording begins.

Store the calibration version hash alongside each episode so that a future audit can group episodes by calibration state rather than guessing which drift window affected which demonstrations. This one-minute check prevents the silent systematic depth offset that makes grasp failures look like policy errors in downstream training.

Practical Example

For a cupboard-opening task, immersive feedback may help the operator move the camera to inspect handle geometry. The dataset should preserve that active gaze path because a learned policy may need a similar information-gathering behavior.

Research Frontier

Three active directions are reshaping immersive teleoperation as of 2024-2026.

Whole-body and humanoid immersion. Extending VR teleoperation from arm-only to full humanoid whole-body control is now an active area. The MOSAIC system (Darvish et al., 2024, IEEE RA-L) demonstrated whole-body teleoperation of the iCub3 humanoid using an avatar interface with haptic feedback, collecting loco-manipulation demonstrations that fixed-camera setups cannot reach. Scaling immersive collection to bipedal robots with 50-plus degrees of freedom introduces new retargeting and latency problems not present in 7-degrees-of-freedom (DOF) arm settings.

Shared autonomy for latency compensation. Rather than minimizing raw end-to-end delay, recent work offloads short-horizon motion execution to an on-robot policy that blends operator intent with local reactive control. PhysicsWALT (Ma et al., 2024) and related shared-autonomy systems let the operator specify high-level goals over a lossy channel while a local low-level policy handles contact-level corrections in real time. This decoupling allows useful teleoperation over 200 to 400 ms WAN (wide-area network, meaning the public internet link between operator and robot site rather than a local network) links that would produce unsafe jerky motion in a direct control scheme.

Passive gaze and saliency mining from immersive logs. Recorded headset pose streams from past VR teleoperation sessions are now being mined post-hoc to build gaze-conditioned imitation datasets without additional human annotation. Work from the RoboAgent project (Bharadhwaj et al., 2024) and related efforts train attention modules that predict where a competent operator would look before each action phase, using the archived headset pose as a supervisory signal. This converts legacy immersive datasets into active-perception training resources retroactively.

Open problem for PhD students. No principled method yet exists for automatically deciding, per task and per episode, whether immersive feedback improved the demonstration or whether a non-immersive operator would have produced an equivalent trajectory. Current practice uses blanket interface-type labels rather than a causal estimate of the perceptual benefit. A student could formalize this as a counterfactual data quality problem: given paired immersive and non-immersive episodes on the same task, learn a predictor of policy improvement attributable to the VR channel alone, controlling for operator skill and task difficulty. Such a predictor would let large-scale data pipelines route collection budget to immersive interfaces only for tasks where the causal gain exceeds the infrastructure cost.

Real-World Application: Humanoid Data Collection

The Open-TeleVision stack was used to teleoperate the Unitree H1 humanoid and bimanual setups for tasks like can sorting and insertion, streaming stereo video to a Meta Quest or Apple Vision Pro headset over WebRTC while the operator's head pose drove an on-robot active camera. The immersive demonstrations collected this way trained behavior-cloning ACT-style policies that then ran autonomously, and the project reported that the active-gaze viewpoint control was decisive for the occlusion-heavy insertion task.

Lab: Measure the Latency-vs-Quality Tradeoff

Goal: Empirically show how injected feedback delay degrades teleoperation accuracy and how that flows into the episode quality label.

Tools needed: Python with NumPy, matplotlib, and MuJoCo (or the simpler gymnasium classic-control envs). A keyboard or SpaceMouse as the operator input device.

Steps: Set up a MuJoCo reach-and-grasp scene rendered to a window. Insert a configurable delay buffer of N frames between the simulator state and the image shown to the operator, so the operator always sees a stale view. Collect 5 short teleoperation episodes at each of delay = 0, 50, 100, 150, 200 ms, recording per-timestep delay, dropped frames, and final position error.

What to vary: the injected delay in milliseconds, and optionally the task precision (target tolerance).

What to observe: plot mean final-position error against delay; you should see error rise sharply past roughly 100 to 150 ms as predictive overcorrection sets in. Then run Code Fragment 1's classifier on your logged episodes and confirm the "clean" versus "interface-risk" split lands near the same delay where accuracy collapses. This connects the abstract threshold to a curve you measured yourself.

Self Check

Would a replay viewer know where the operator looked, how delayed the video was, and whether hand retargeting saturated? If not, the immersive context has been lost.

Key Takeaway

Immersive teleoperation improves data when it improves operator state estimation and records the evidence needed to separate task errors from interface errors.

Exercise 23.4.1

Design an evaluation comparing joystick and VR collection for one task. Keep the robot, task split, and success metric fixed, then add one interface-quality metric.

Project Ideas

Beginner (weekend): Build a latency-aware episode classifier in Python that reads a CSV log of per-timestep delay, dropped-frame count, and hand-tracking confidence, applies the thresholds from Code Fragment 1, and outputs a per-episode quality label; test it against synthetic logs you generate with NumPy, then visualize label distributions with matplotlib. The key challenge is designing synthetic logs that exercise every boundary condition (delay exactly at 100 ms, tracking exactly at 0.95) so the classifier is trustworthy before real data is collected.
Intermediate (1 to 2 weeks): Implement a simulated VR teleoperation pipeline in MuJoCo using a keyboard or SpaceMouse as the operator input device, record episodes as LeRobot-compatible HDF5 files including a synthetic "headset pose" channel derived from the camera gimbal angle, then train a behavior-cloning policy with LeRobot and compare success rate on a pick-and-place task using episodes labeled clean versus interface-risk. The key challenge is synchronizing the simulated camera gimbal, the operator command timestamps, and the MuJoCo physics step so that end-to-end delay is measurable and the quality labels reflect real timing rather than wall-clock jitter.

What's Next

Section 23.5 turns from interfaces to data quality gates: how to decide which episodes are train, validation, stress, repair, or discard.

References & Further Reading
Teleoperation Systems

Chi, C. et al. (2024). Universal Manipulation Interface: In-The-Wild Robot Teaching Without In-The-Wild Robots.

Defines the handheld gripper approach, latency matching, and relative-trajectory action interface used in portable demonstration collection.

Paper

Cheng, X. et al. (2024). Open-TeleVision: Teleoperation with Immersive Active Visual Feedback.

A current reference for immersive visual feedback, active perception, and VR-style operator embodiment in data collection.

Paper

Zhao, T. Z. et al. (2023). Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware.

Introduces ALOHA and ACT, making the connection between low-cost bimanual teleoperation, action chunking, and real-world manipulation data explicit.

Paper

Wu, P. et al. (2023). GELLO: A General, Low-Cost, and Intuitive Teleoperation Framework for Robot Manipulators.

A kinematically matched leader device study that directly compares teleoperation ergonomics and reliability against other low-cost interfaces.

Paper

Hugging Face LeRobot Documentation.

Documents dataset conversion, policy training, and robot-control utilities that turn teleoperation logs into reusable learning artifacts.

Tool
n class="bib-meta">Tool