RIO: Flexible Real-Time Robot I/O for Cross-Embodiment Robot Learning

Abstract: Despite recent efforts to collect multi-task, multi-embodiment datasets, to design recipes for training Vision-Language-Action models (VLAs), and to showcase these models on different robot platforms, generalist cross-embodiment robot capabilities remains a largely elusive ideal. Progress is limited by fragmented infrastructure: most robot code is highly specific to the exact setup the user decided on, which adds major overhead when attempting to reuse, recycle, or share artifacts between users. We present RIO (Robot I/O), an open source Python framework that provides flexible, lightweight components for robot control, teleoperation, data formatting, sensor configuration, and policy deployment across diverse hardware platforms and morphologies. RIO provides abstractions that enable users to make any choice and to switch between them, with minimal reconfiguration effort. We validate RIO on VLA deployment workflows across three morphologies (single-arm, bimanual, humanoid) and four hardware platforms with varying grippers and cameras. Using teleoperated data collected with RIO, we fine-tune state-of-the-art VLAs including $π_{0.5}$ and GR00T on household tasks such as pick-and-place, folding, and bowl scrubbing. By open sourcing all our efforts, we hope the community can accelerate their pace of robot learning on real-world robot hardware. Additional details at: https://robot-i-o.github.io

• The paper introduces RIO, a middleware-agnostic framework that reduces integration overhead for deploying generalist VLA policies across diverse robots.
• It demonstrates high performance with sub-millisecond latencies and policy success rates above 90% in tasks such as manipulation and dynamic interactions.
• The system’s modular design and consistent data formatting enable flexible configuration and rapid robot onboarding, fostering scalable cross-embodiment learning.

RIO: Flexible Real-Time Robot I/O for Cross-Embodiment Robot Learning

Motivation and Context

Deploying generalist robot policies, particularly vision-language-action (VLA) models, across diverse hardware remains a significant challenge due to fragmented and highly platform-specific control infrastructure. Existing robot learning frameworks often hard-code configuration details at each layer—robot drivers, grippers, sensors, teleoperation, middleware, data formatting, and deployment logic—creating substantial overhead for reuse, adaptation, and cross-platform sharing. While industry-scale VLA research has advanced multi-embodiment learning, practical deployment for new morphologies is bottlenecked by the lack of unified, flexible, and accessible infrastructure.

RIO (Robot I/O) is introduced to address this gap by providing a lightweight, Python-based, middleware-agnostic framework for coordinating data collection, teleoperation, and real-time policy deployment across heterogeneous robot systems. The design emphasizes flexibility, reusability, accessibility, high performance, and consistency, targeting both rapid prototyping and scalable deployment for state-of-the-art policy classes.

Figure 1: High-level overview of the RIO architecture, with modular components allowing seamless swapping of robots, sensors, middleware, teleoperation interfaces, data formats, and policy backends.

Design Philosophy and System Architecture

RIO’s core design tenets are:

• Flexible assignment of robots, grippers, teleoperation interfaces, cameras, and policies with trivial configuration changes.
• Reusable componentization, allowing lightweight composition, adaptation, and extension.
• Accessible deployment via Python modules and a command-line interface driven by a single configuration file.
• Performant execution, with asynchronous node communication supporting high-frequency, real-time control across all supported hardware.
• Consistent data formatting and abstraction for portable, reproducible learning pipelines.

The framework adopts a modular node-based abstraction, where every hardware component or logical entity (robot, camera, teleoperation interface, policy) is a node implementing publish and/or request patterns. Middleware backends—including shared memory, multi-threading, network-based protocols (e.g., ZeroRpc, Zenoh), and others—can be selected or swapped at runtime, optimizing debug-ability, performance, or distributed deployment as necessary.

Figure 3: Node profiling during policy deployment, showing parallel non-blocking operation of camera, policy, and robot nodes, keeping the main loop unblocked for precise timekeeping.

A robot station aggregates any combination of nodes into an embodiment (e.g., single-arm, bimanual, or humanoid). Each station is configured through a dataclass specification, which abstracts away low-level details and ensures consistent API exposure to higher-level application logic, enabling seamless transitions between embodiments with identical user code.

Teleoperation, Data Collection, and Policy Integration

RIO provides platform-agnostic teleoperation scripts:

• End-effector teleoperation via keyboard, phone, gamepad, or Spacemouse.
• Absolute joint mapping through leader-follower setups (e.g., ALOHA, GELLO).
• VR retargeting for manipulation and locomotion in humanoids.

Interpolators and signal-processing filters (e.g., low-pass filters) are included to accommodate device heterogeneity and control frequencies.

Demonstration data is captured in a standardized, RLDS-inspired format, extended with morphological awareness to handle arbitrary robot configurations. All data is stored using RoboDM for efficient compression and exportability.

Figure 4: VLA manipulation trajectories showing successful rollouts of $\pi_{0.5}$ across multiple morphologies and tasks.

A high-level policy API abstracts the model backend—$\pi_{0.5}$, GR00T, Diffusion Policy, Reinforcement Learning methods, etc.—enabling deployment by specifying observation and action adapters only. Policies are run in asynchronous nodes that process inference requests in parallel, removing bottlenecks from the main rollout loop.

Empirical Validation and Performance Metrics

The evaluation demonstrates RIO’s applicability across a spectrum of robot types—single-arm (UFactory xArm7, SO-100), bimanual, and humanoid (Unitree G1, Booster T1)—and four hardware platforms, with minimal engineering effort for each configuration change.

Strong empirical findings include:

• High policy success rates: Above 90% for canonical VLA manipulation tasks with fine-tuned $\pi_{0.5}$ checkpoints; dynamic tasks (e.g., ball throwing, tortilla flipping) with Diffusion Policy reach 66.7–100% with 50 demonstrations.
• Efficient rollouts: Policy execution times are closely matched to or even faster than human demonstrations in multiple cases.
• Superior latency: End-to-end observation-action latency during real VLA rollouts is $130.3$ ms for RIO vs. $581.2$ ms for LeRobot under identical conditions—a marked fourfold improvement.

  Figure 2: Real-world observation-action latency during $\pi_{0.5}$ deployment, highlighting RIO’s $130.3$ ms total latency versus $581.2$ ms for LeRobot.

• Scalability: Middleware profiling shows sub-millisecond latencies in local (Zenoh, shared memory) configurations, supporting high-frequency RL or latency-critical dynamic tasks.
• Platform on-boarding: Integration of a new robot (AgileX PiPER) via LLM-based code generation pipeline required only 9.2 minutes of developer time and 420 LOC, validating the framework’s modular extensibility.

  Figure 5: Example robot stations showing integration of various arms and grippers, with multiple sensors and teleoperation devices, all controlled through consistent RIO API.

Policy deployment is validated on mixed-morphology datasets. Cross-embodiment fine-tuning of $\pi_{0.5}$ using demonstrations from both xArm7 and SO-100 is supported end-to-end by the same infrastructure—a key facilitation for future generalist robot policy research.

Implications and Future Work

Pragmatically, RIO provides a foundation to democratize generalist robot learning, lowering infrastructure barriers and catalyzing reproducible experimentation across the research community. Its architectural neutrality—at both hardware and policy backend levels—is a substantial advance over fragmented, vendor-locked solutions. It expedites the collection of large-scale, high-fidelity, cross-embodiment datasets, which is crucial for progress in VLA and multi-morphology generalization research.

Theoretically, standardized schema and abstraction layers in RIO could enable systematic studies of domain shift, embodiment-aware policy adaptation, and data mixture optimization for multi-robot learning at scale. The streamlined configuration also opens potential for automated or LLM-driven robot onboarding and rapid prototyping.

Limitations include the current focus on single-embodiment fine-tuning; robust cross-embodiment policy generalization remains an area for further investigation. Dynamic task reliability for VLAs also requires deeper exploration. Integration of additional hardware modalities—including mobile bases and multi-fingered dexterous hands—and benchmarking under larger distribution shifts represent logical next steps.

Figure 6: PiPER teleoperation demonstration, validating seamless integration and deployment of a newly onboarded robot using identical main loop and teleoperation scripts as prior supported platforms.

Conclusion

RIO presents an effective, flexible, and performant real-time robot I/O framework, validating its capability to bridge the infrastructure hurdles that impede reproducible, cross-platform robot learning. Its design facilitates both robust experimental workflows and collaborative, extensible development for generalist policy research. RIO positions itself as a vital tool for the next phase of embodied policy scaling and cross-embodiment generalization in robotics (2605.11564).