Open-RAIL Operational

Open-RAIL is China Mobile's open-source general-purpose engineering foundation for embodied intelligence, and the industry's first general-purpose neural system connecting VLA/WAM models with robot hardware. At the framework level, Open-RAIL closes the loop across inference, execution, data feedback, and model iteration. Its parallel pipelines improve motion smoothness by two orders of magnitude, enable zero code changes for edge, on-device, and cloud deployment, reduce new robot integration from weeks to hours, and require only 50—100 lines of code for a new model. It currently supports 4 heterogeneous robots and 10 mainstream models. The Mobile Star Chef robot is now operating routinely in Hangzhou.

Inference and execution: Observation, inference, and control are split into three parallel pipelines with a two-level smoothing strategy, reducing the standard deviation of joint acceleration from 10+ rad/s² to 0.1 rad/s² for stable, smooth motion.
Edge, on-device, and cloud deployment: Inference runs uniformly on the Server, while the robot only handles execution. Changing one connection address enables on-demand switching between on-device, edge, and cloud deployment, so computing power no longer limits model selection.
Heterogeneous adaptation: A lightweight hardware abstraction layer and unified model integration conventions standardize control and state interfaces. Switching robots or models requires no rebuild from scratch.
Data closed loop: Data collection is embedded in every inference and execution cycle. Multi-view images, joint states, and inference results are automatically archived in a ready-to-use standard format and can be fed directly into the next training cycle.
Hybrid inference and teleoperation: When the model deviates, a human can intervene and correct it at any time. Corrected and original trajectories are stored in parallel with strictly aligned timestamps, making every human correction a high-quality targeted teaching example.
Inference, collection, and evaluation loop: Model inference, robot execution, data feedback, and model iteration are connected into a general-purpose loop, filling an industry gap and making results reproducible across more robots and models.

Follow us on WeChat and reply “开源” to join the AI open-source project community group
Parallel-pipeline inference architecture: To address the 30—50× gap between VLA/WAM model inference latency and robot control cycles, Open-RAIL splits observation, inference, and control into three parallel pipelines on the robot side. The observation thread continuously collects environmental and joint states, the inference thread continuously computes action chunks, and the control thread continuously sends commands to the lower-level controller. They do not wait for one another, eliminating motion stutter caused by serial waiting.
Two-level online action smoothing: Model outputs are discrete action points, and direct execution can cause high-frequency acceleration and deceleration shocks. Open-RAIL implements two-level smoothing within and between action chunks at the framework level. All calculations run online and in real time. Without modifying model weights or performing additional training, the standard deviation of joint acceleration can be reduced from 10+ rad/s² to 0.1 rad/s², preventing high-frequency shocks to the hardware.
Server-Client decoupling for on-device, edge, and cloud deployment: The system abstracts inference to the Server, while the robot hardware (Client) handles only action execution and state reporting. The Server can run on the robot, at the edge, or in the cloud. The code remains identical; only the connection address needs to be changed to switch between on-device, edge, and cloud deployment with zero code changes, removing the robot's embedded computing constraints on model size.
Hardware abstraction layer and unified integration conventions: Open-RAIL extracts a lightweight hardware abstraction layer (HAL) that standardizes and encapsulates control commands, state reading, and action execution. A new robot only needs to implement its low-level adapter and complete registration; all upper-layer logic is reused. The model side likewise defines a unified inference interface. A new model can be integrated by implementing the standard interface, typically requiring only 50—100 lines of code, minimizing cross-robot and cross-model adaptation costs.

Check the environment: Prepare a Linux environment with Python ≥ 3.10. The server requires an NVIDIA GPU + CUDA + PyTorch. On the client side, install the vendor SDK or ROS as required by the robot. The two sides communicate via ZMQ on the same local network.
Get the code: Clone the repository from Gitee, GitHub, or the Huanxin community (git clone https://gitee.com/cmcc-tao/open-rail.git).
Install dependencies: After creating a conda environment, run pip install -e . to automatically register the vla-server and vla-web-client command-line entry points.
Start the server: Run python run_server.py --model_type <model type> --model_path <weights path> to load the selected VLA/WAM model and expose an inference endpoint through ZMQ.
Start the Web client: Run python run_web_client.py (it reads conf/default_conf.yaml by default and listens on port 9000). Use --conf to specify a custom configuration.
Verify the connection: Open http://localhost:9000 in a browser. If the Web interface, camera feed, and robot status are ready, startup succeeded. Select a task to drive the robot.
Start with simulation (without a physical robot): In conf/robots_conf.py, point the Mock backend's dataset_path to a LeRobot dataset, then use --model_type mock to validate the full pipeline first.
Run on a physical robot: Set robots.type in conf/*.yaml to the target adapter (agibot_g1 / ti5_t170c / navi_wa2), configure the camera topics and action_layout as documented, and start using the same two commands.
Switch between on-device, edge, and cloud deployment: No code changes are needed. Change only the server network address field in the configuration to run inference on the robot, at the edge, or in the cloud.
Get data and evaluate: Each run automatically produces LeRobot-style Parquet training data and eval/ evaluation logs (JSON/CSV), ready to feed directly back into training. The “inference + teleoperation correction” hybrid mode is planned for open-source release in October.

Stable, smooth motion: Three-thread asynchronous pipelines and two-level online smoothing eliminate the 30—50× inference-control frequency gap at the framework level, reducing the standard deviation of joint acceleration from 10+ rad/s² to 0.1 rad/s² without modifying or restricting the model architecture.
Adapt once, reuse everywhere: The lightweight hardware abstraction layer and unified integration conventions reduce new robot integration from weeks to hours and require only 50—100 lines of code to integrate a new model, while fully reusing upper-layer logic.
Computing power is no longer a barrier: With the Server-Client decoupled architecture, inference runs uniformly on the Server. Changing one connection address enables zero-code switching between on-device, edge, and cloud deployment, allowing embedded devices to run large models.
Run, collect, and evaluate: Data collection and evaluation logs are embedded in every inference and execution cycle, automatically producing ready-to-use LeRobot-style data and reproducible timing metrics to close the “inference, collection, and evaluation” loop.
Human correction becomes a teaching sample: In hybrid teleoperation mode, operators can pause, intervene, correct, and resume at any time. Corrected and original trajectories are stored in parallel with strictly aligned timestamps, directly becoming high-quality targeted training data.
Validated in real-world scenarios: The Mobile Star Chef robot is operating routinely in a Hangzhou campus, producing more than 100 cups of coffee per day with a 90-second end-to-end process per cup. The model makes autonomous decisions throughout long-sequence tasks, demonstrating the value of the engineering foundation.

Project website: https://cmcc-tao.github.io/open-rail/

Commercial service robots: The deployed “Mobile Star Chef” completes long-sequence service tasks such as coffee preparation and microwave heating of meals, producing more than 100 cups of coffee per day with a 90-second end-to-end process per cup. It handles multiple orders in parallel with autonomous model-based decision-making throughout.
Industrial inspection and monitoring: In substations, computer rooms, and industrial parks, robots perform repetitive monitoring tasks such as equipment inspections, meter readings, and anomaly alerts. Edge, on-device, and cloud deployment allows large-model inference to run at the edge or in the cloud without requiring substantial computing power on the robot.
Elder care and medical assistance: In scenarios such as serving drinks, delivering items, and rehabilitation assistance, smooth execution ensures safety and gentle interaction when robots operate close to people.
Research and teaching experiments: Universities and startups can begin with the Mock simulation backend without hardware to quickly validate VLA model performance. Integrating a new model requires only 50—100 lines of code, allowing researchers to focus on model innovation instead of building engineering pipelines.