💻 computer science

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

This paper introduces RIO, an open-source Python framework designed to overcome fragmented robot infrastructure by providing flexible, lightweight components for control and data handling across diverse hardware platforms, thereby enabling efficient cross-embodiment training and deployment of state-of-the-art Vision-Language-Action models.

Original authors: Pablo Ortega-Kral, Eliot Xing, Arthur Bucker, Vernon Luk, Junseo Kim, Owen Kwon, Angchen Xie, Nikhil Sobanbabu, Yifu Yuan, Megan Lee, Deepam Ameria, Bhaswanth Ayapilla, Jaycie Bussell, Guanya Shi, Jon

Published 2026-05-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Pablo Ortega-Kral, Eliot Xing, Arthur Bucker, Vernon Luk, Junseo Kim, Owen Kwon, Angchen Xie, Nikhil Sobanbabu, Yifu Yuan, Megan Lee, Deepam Ameria, Bhaswanth Ayapilla, Jaycie Bussell, Guanya Shi, Jonathan Francis, Jean Oh

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot to do chores, like folding a shirt or scrubbing a bowl. In the world of robotics, this is currently like trying to teach a child to speak every different language in the world, but with a catch: every time you switch to a different robot (a different "body" or "embodiment"), you have to completely relearn how to talk to it.

If you have a robot arm from one company and a camera from another, the code that makes them work together is often a mess of custom instructions. If you want to switch to a different robot arm, you can't just swap the part; you often have to rewrite the entire "brain" of the robot from scratch. This makes sharing progress between scientists incredibly difficult and slow.

Enter RIO (Robot I/O).

Think of RIO as a universal translator and a modular "plug-and-play" system for robots. It is a lightweight software toolkit that lets researchers mix and match different robot parts without rewriting the code every time.

Here is how it works, using some simple analogies:

1. The "Lego" Approach (Flexibility)

Imagine you have a box of Lego bricks. Some are robot arms, some are grippers (hands), some are cameras, and some are teleoperation controllers (the things humans use to move the robot).

Without RIO: You have to glue the bricks together with super-strong, permanent glue. If you want to change the arm, you have to break the whole thing apart and start over.
With RIO: The bricks have standard connectors. You can snap a "Franka arm" onto a "Robotiq gripper" or a "VR headset" onto a "humanoid robot" just by changing a configuration file. The core logic (the "brain" telling the robot what to do) stays exactly the same; only the "body" changes.

2. The "Universal Power Strip" (Middleware)

Robots need to talk to each other at lightning speed. Usually, different parts speak different "languages" (protocols).

RIO's Solution: It acts like a smart power strip or a universal adapter. It sits between the robot's hardware and the software. Whether you are using a high-speed shared memory connection (like two people whispering directly in the same room) or a network connection (like talking over the internet), RIO handles the translation automatically. This means you can swap the communication method without changing the robot's code.

3. The "Teleoperation" Remote Control

To teach a robot, humans often "teleoperate" it—meaning they wear a controller and move the robot with their own hands.

RIO supports a huge variety of these controllers: from simple keyboards and gamepads to high-tech VR headsets (like Apple Vision Pro) and specialized robotic arms that mimic human movement.
The paper shows that you can use the same software to control a single robot arm, a two-armed robot, or even a full-sized humanoid robot walking around, just by swapping the controller and the robot body.

4. The "Smart Delivery Driver" (Policy Inference)

Once the robot is trained, it needs to make decisions (like "pick up the cup") and move. This is called "inference."

RIO is designed to be fast. It separates the "thinking" (running the AI model) from the "doing" (sending commands to the motors).
The paper compares RIO to another popular system called LeRobot. They found that RIO is much faster at getting a command from the camera to the robot's hand.
- LeRobot: Took about 581 milliseconds (a long time in robot speed).
- RIO: Took only 130 milliseconds.
- Analogy: If LeRobot is like sending a letter by mail, RIO is like sending a text message. This speed is crucial for dynamic tasks, like flipping a tortilla or throwing a ball, where a split-second delay causes failure.

What Did They Actually Do?

The authors didn't just build the tool; they tested it in the real world. They used RIO to:

Collect data by humans controlling robots to perform household tasks (folding shirts, scrubbing bowls, picking up boxes).
Train advanced AI models (like π0.5 and GR00T) on this data.
Deploy these trained models onto three very different types of robots:
1. Single-arm robots (like a standard factory arm).
2. Bimanual robots (robots with two arms).
3. Humanoids (robots that look and walk like humans).

They successfully made these robots fold clothes, pick up objects, and even walk, proving that the same software stack can drive completely different hardware.

The Bottom Line

The paper argues that the biggest bottleneck in robot learning isn't just having more data or better AI models; it's the infrastructure. Scientists are currently wasting too much time building custom "wiring" for every new robot.

RIO is a free, open-source tool that provides the "wiring" once and for all. It allows the robotics community to stop reinventing the wheel and start focusing on teaching robots to do more complex, useful things, regardless of what the robot looks like.

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

Problem Statement

Despite recent advancements in Vision-Language-Action (VLA) models and the aggregation of large-scale, multi-embodiment datasets (e.g., Open X-Embodiment), the deployment of generalist robot policies remains hindered by fragmented infrastructure. Current robotics code is typically highly specific to a user's exact hardware setup, creating significant overhead when attempting to reuse, share, or adapt artifacts across different platforms.

The core issue is a lack of flexible, reusable, and performant full-stack robot infrastructure. Researchers often face the burden of rewriting entire control stacks when switching between robot morphologies (e.g., from a single-arm to a humanoid) or hardware configurations (e.g., different grippers or cameras). This fragmentation prevents the cumulative progress seen in other areas of machine learning, where high-level abstractions allow for rapid iteration on diverse hardware. Consequently, reproducing results often requires replicating hardware setups one-to-one, or undertaking substantial engineering effort to adapt learned policies to new platforms.

Methodology: The RIO Framework

To address these challenges, the authors present RIO (Robot I/O), a lightweight, open-source Python framework designed to provide flexible, real-time I/O for cross-embodiment robot learning. RIO is not a monolithic solution but a set of reusable building blocks that allow users to compose control stacks tailored to their specific configurations.

Design Philosophy

RIO is built on five tenets:

Flexible: Agnostic to components; users can choose and switch between options at every layer (robots, sensors, teleop, middleware, policies) with minimal reconfiguration.
Reusable: Composed of lightweight building blocks that can be quickly combined.
Accessible: Quick to install, Python-based, and controlled via a single configuration file and CLI.
Performant: Capable of high-frequency real-time control with asynchronous policy inference.
Consistent: Ensures scalable and reproducible data collection and learning.

System Architecture

The framework utilizes a Node-based architecture where every component (teleoperation interfaces, sensors, robots, policies) is implemented as a Node inheriting from a common template.

Nodes and Middlewares: Nodes dynamically inherit from a specified Middleware (e.g., Shared Memory, Zenoh, ZeroRpc, Threads, Portal) which handles message passing. Nodes support three execution patterns: publish-only, request-only, or combined. This abstraction allows the same logic to run on different transport layers (e.g., local shared memory for debugging vs. network-based for distributed robots).
Robot Stations: The instantiation of all nodes for a specific environment is aggregated into a single "station" configuration file (a composable dataclass). This defines the hardware topology (e.g., {arm, gripper, wrist_camera}). The main control loop interacts only with high-level APIs, decoupling application logic from hardware specifics.
Teleoperation and Data Collection: RIO supports diverse teleoperation methods, including relative end-effector control (Spacemouse, Gamepad), absolute joint mapping (Leader-Follower/ALOHA), and VR-based retargeting for humanoids. Data is collected in a standardized RLDS-style format with consistent units (meters/radians) and compressed using RoboDM for efficient storage.
Policy Inference: A high-level API allows for the seamless swapping of policies (VLAs, Diffusion Policies, RL). A policy wrapper node handles asynchronous inference, converting standardized observations to policy-specific formats and smoothing actions before sending commands to hardware.

Key Contributions

RIO Framework: Introduction of a flexible, real-time Robot I/O framework providing reusable infrastructure for data collection and policy deployment across diverse embodiments. It enables combinatorial configuration of robots, sensors, teleop devices, and policies.
Validation Across Morphologies: Demonstration of RIO's capability to support VLA deployment workflows across three distinct morphologies (single-arm, bimanual, humanoid) and four hardware platforms with varying grippers and cameras.
Real-World Deployment: Successful fine-tuning and deployment of state-of-the-art VLAs (specifically $\pi0.5$ and GR00T) and other policies (Diffusion Policy, PPO) on household tasks (pick-and-place, folding, bowl scrubbing) and locomotion tasks. This includes a cross-embodiment policy trained on mixed data from two different robot morphologies.

Results and Evaluation

The authors evaluated RIO on a desktop equipped with an NVIDIA RTX 4090, focusing on performance, latency, and success rates across diverse tasks.

Policy Performance:
- Single-Arm (xArm7): $\pi0.5$ achieved >90% success on folding and pick-and-place tasks. Diffusion Policy achieved 66.7% success on dynamic tortilla flipping and 100% on ball throwing.
- Bimanual (SO-100): $\pi0.5$ achieved $\ge$ 60% success on cloth folding and bowl scrubbing.
- Humanoid (Unitree G1, Booster T1): GR00T N1.5 achieved 95% success on box picking. RL-PPO policies successfully controlled locomotion on both platforms.
Latency and Performance:
- Middleware Latency: Shared Memory and Zenoh achieved sub-millisecond round-trip latency (~0.4–0.5 ms), while Thread and ZeroRpc remained close at ~1 ms.
- End-to-End Latency: RIO achieved an observation-to-action latency of 130.3 ms compared to 581.2 ms for LeRobot under identical conditions. This efficiency is attributed to RIO's streamlined architecture and direct middleware-based asynchronous inference, avoiding the overhead of dedicated policy servers.
- Resource Utilization: Asynchronous inference maintained high GPU utilization (up to ~80%) throughout execution, demonstrating efficient compute saturation.

Significance and Claims

The paper posits that the lack of flexible, reusable infrastructure is a critical barrier to cumulative progress in robotics. By providing a "bring-your-own-training-stack" approach, RIO lowers the barrier for practitioners to deploy, benchmark, and iterate on modern robot learning approaches across diverse hardware.

The authors claim that RIO successfully abstracts user logic, allowing it to be written once and reused on any robot station. Swapping hardware or policies becomes a configuration change rather than a code rewrite. While the current work focuses on single-embodiment fine-tuning and acknowledges that cross-embodiment generalization remains an open research problem, the framework is designed to facilitate the collection of high-quality, standardized cross-embodiment data, which is a prerequisite for future advances in generalist robot policies. The authors open-source the framework to accelerate the pace of robot learning on real-world hardware.