Open-RAIL Evaluation: China Mobile's Open-Source General-Purpose Engineering Foundation for Embodied Intelligence, Bridging the "Last Mile" for VLA/WAM Model Deployment

1. What is Open-RAIL

Open-RAIL is a general-purpose engineering foundation for embodied intelligence that China Mobile has open-sourced globally. It is positioned as the industry's first universal "nervous system" connecting VLA/WAM models with robotic hardware. This project establishes a complete closed-loop at the framework level, spanning "inference – execution – data feedback – model iteration," and enhances action smoothness by two orders of magnitude through a three-thread asynchronous pipeline architecture. It enables zero-code changes for deployment across edge, terminal, and cloud environments, reduces the onboarding time for new robots from weeks to hours, and requires only 50–100 lines of code to integrate new models. Currently, Open-RAIL has been adapted to four heterogeneous robots, supports ten mainstream VLA/WAM models, and its deployment case, the "Mobile Star Chef" robot, is now operating regularly in Hangzhou's campus.

Image source: Official article
Image source: official article

Technical positioning and domain: Open-RAIL belongs to the engineering infrastructure layer in the field of embodied intelligence, primarily addressing systemic engineering challenges in the process of transitioning VLA (Vision-Language-Action) / WAM (World-Action Model) models from simulation validation to real-world robotic deployment. Its core value lies in resolving the 30–50 times frequency gap between model inference and robotic control at the framework level, rather than relying on model optimization or hardware upgrades.

Development background: This project was led by China Mobile's Research Institute, leveraging its long-term expertise in communication infrastructure and cloud computing. The motivation for its development stems from a common pain point in the embodied intelligence industry – while model-side progress is rapid, engineering aspects such as robot body adaptation, real-time inference deployment, and data feedback lack standardized solutions, resulting in many laboratory achievements being unable to quickly translate into practical productivity.

Core value: Open-RAIL provides a general-purpose engineering foundation, not a single algorithm or dataset. It defines model integration standards, hardware abstraction specifications, edge-terminal-cloud deployment protocols, and data feedback formats, making it unnecessary to rebuild everything from scratch when switching models or robots. This platform-oriented approach significantly reduces the trial-and-error costs and integration complexity in embodied intelligence application development.

Technical features: Its differentiated capabilities are mainly reflected in four aspects: a three-thread parallel pipeline inference architecture, a two-tier online action smoothing strategy (without modifying model weights), a Server-Client edge-terminal-cloud decoupled design (zero-code deployment mode switching), and an embedded data collection and evaluation mechanism within every inference execution.

2. Key Features

• Parallel Pipeline Architecture for Inference-Execution-Control: To address the 30–50 times discrepancy between inference latency of VLA/WAM models and robot control cycles, Open-RAIL separates observation, inference, and control into three independent threads on the robot side. The observation thread continuously collects environmental and joint status data, the inference thread continuously computes action blocks, and the control thread continuously sends commands to the lower-level controller. These threads operate independently without waiting for each other, eliminating action stutter caused by serial waiting at the architectural level.

• Two-Level Online Action Smoothing Strategy: Direct execution of discrete action points generated by the model can cause high-frequency acceleration and deceleration shocks. Open-RAIL implements two levels of smoothing—within-block and between-block—at the framework level, all computed in real-time online, without the need to modify model weights or perform post-training. In practice, the standard deviation of joint acceleration drops from over 10 rad/s² to 0.1 rad/s², significantly reducing the hardware's exposure to high-frequency impact loads.

• Server-Client Decoupled Deployment for Edge-Cloud Integration: Inference is uniformly abstracted to the Server side, while the robot itself (Client) is only responsible for action execution and status reporting. The Server can be deployed on the robot's embedded computing power, edge nodes, or cloud data centers, with identical code across all deployment types. Only the connection address needs to be modified to seamlessly switch between the three deployment modes. This design removes the constraint of robot hardware computing power on model scale selection.

• Lightweight Hardware Abstraction Layer and Unified Access Agreement: Open-RAIL standardizes control commands, status reading, and action execution into a Hardware Abstraction Layer (HAL). New robots only need to implement low-level compatibility and complete registration, allowing full reuse of upper-layer logic. Similarly, the model side defines a unified inference interface; new models can be integrated by implementing the standard interface, typically requiring only 50–100 lines of code.

• Data Closed-Loop Mechanism with Real-Time Collection: Data collection is embedded within each inference execution process, automatically archiving multi-perspective images, joint status, and inference results into a LeRobot-style Parquet standard format ready for immediate use. At the same time, it automatically generates reproducible evaluation logs (JSON/CSV) containing timing metrics, achieving "inference equals data collection, operation equals evaluation."

• Hybrid Mode of Inference and Teleoperation: When the model deviates, human operators can intervene at any time to correct the trajectory. The corrected trajectory is strictly time-stamped and saved in parallel with the original trajectory. Each manual correction is treated as a high-quality directed teaching sample, directly used for the next round of model training, forming a continuously evolving data flywheel.

3. How to Use

1. Environment Preparation and Prerequisites: Confirm that the runtime environment is a Linux operating system with Python version ≥ 3.10. The server must be configured with an NVIDIA GPU and have CUDA and PyTorch installed; the client must install the corresponding SDK or ROS environment as required by the robot manufacturer. The server and client can communicate via the ZMQ protocol within the same local network, without requiring additional configuration for public network penetration.

2. Obtain Code and Install Dependencies: Clone the repository from Gitee, GitHub, or the Huanxin community, and execute git clone （link to be updated after official release）. Create a conda environment and run pip install -e . to complete the installation. This command will automatically register two command-line entry points: vla-server and vla-web-client.

3. Start the Server and Client: On the server, run python run_server.py --model_type <model type> --model_path <weight path> to load the selected VLA/WAM model and expose the inference endpoint via ZMQ. On the client, execute python run_web_client.py (which by default reads conf/default_conf.yaml and listens on port 9000). You can use the --conf parameter to specify a custom configuration.

4. Verify Connection and Start Simulation: Open http://localhost:9000 in your browser. If you can see the Web interface, camera feed, and robot status ready, the startup is successful. If you don't have a real robot, you can first verify the system using simulation—point the dataset_path of the Mock backend in conf/robots_conf.py to the LeRobot dataset, and use --model_type mock to run the full pipeline.

5. Real Robot Execution and Edge-Cloud Switching: Modify the robots.type field in conf/**.yaml to the target adapter (agibot_g1 / ti5_t170c / navi_wa2). After configuring the camera topic and action_layout as per the documentation, start the system using the same two commands. Switching between on-device, edge, and cloud inference requires no code changes—simply modify the server network address field in the configuration file to run inference on the device, edge, or cloud.

6. Data Collection and Evaluation: Each run automatically generates LeRobot-style Parquet training data and eval/ evaluation logs (JSON/CSV), which can be directly fed back into training with minimal setup. The "inference + remote control correction" hybrid mode is planned for open-source release in October 2026. At that time, you can further utilize manually corrected trajectories for targeted training.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendations: For enterprise users requiring rapid deployment of VLA/WAM models onto real robots and with high demands on task smoothness and deployment flexibility, Open-RAIL currently offers a differentiated advantage with its complete engineering closed-loop and ability to switch between edge, cloud, and embedded devices, making it particularly suitable for practical scenarios such as service robots and industrial inspection. For academic labs and startup teams, if the primary goal is to rapidly iterate model algorithms and leverage massive open-source datasets for training, LeRobot's data ecosystem and community resources are more appealing, and Open-RAIL can be used as a supplementary solution for subsequent real-robot deployment.

6. Editor's Summary

The emergence of Open-RAIL marks a significant milestone in the engineering process of embodied intelligence. Over the past two years, VLA/WAM models have made substantial progress in terms of capability, but there remains a vast engineering gap between "what the model can do" and "what the robot can do"—systematic solutions are lacking in areas such as inference latency, control frequency, hardware compatibility, and data feedback, resulting in many models remaining at the demo stage. Open-RAIL strategically addresses this gap by positioning itself not as a specific model, but as a "general-purpose engineering foundation," providing a reusable infrastructure solution.

From a technological innovation perspective, the three-thread parallel pipeline architecture and the two-tier online smoothing strategy demonstrate high engineering originality: the former resolves the inherent contradiction between inference and control frequency at the system level, while the latter significantly improves action quality without altering model weights. This "framework-level optimization, model-agnostic" design philosophy avoids the passive situation of being tied to model algorithm iterations, offering a longer technical lifecycle. The zero-modification switch between edge and cloud deployment, along with the data feedback loop that begins collection upon execution, enhances practical value by improving deployment flexibility and leveraging the data flywheel effect.

In terms of practical value, the routine operation of the Mobile Star Chef robot (brewing an average of 100 cups of coffee per day, with a full workflow of 90 seconds per cup) serves as the most compelling validation—it proves the stability and task completion quality of the platform in real commercial environments, rather than just in simulations. For service robot manufacturers, smart manufacturing enterprises, and embodied intelligence startups, Open-RAIL offers a clear path to significantly shorten development cycles. For academic research teams, its support for Mock simulation backends also reduces hardware barriers.

It must be acknowledged that the project still lags behind international leading initiatives in terms of hardware compatibility range, community ecosystem maturity, and documentation completeness. The "inference + remote control correction" hybrid model is also yet to be open-sourced. However, considering China Mobile's industrial resource investment and ongoing real-world validation, Open-RAIL has a solid foundation to establish itself in the field of embodied intelligence engineering platforms. Its future development directions—whether expanding hardware compatibility, enriching the model ecosystem, or deeply integrating the data feedback loop with more efficient post-training processes—are all worth continued attention from the industry.

7. Application Scenarios

• Commercial Service Robots: Taking the deployed "Mobile Star Chef" as a typical example, it completes long-sequence service tasks such as coffee making and microwave heating of meals. It produces over 100 cups of coffee per day, with a full process of 90 seconds per cup. When handling multiple orders simultaneously, the entire process is autonomously decided by the model. The decoupled edge-cloud architecture allows service robots to connect to cloud-based large models to perform complex task understanding and planning, even with limited onboard computational power.

• Industrial Patrol and Monitoring: Suitable for repetitive monitoring tasks such as equipment inspection, meter reading, and anomaly detection in scenarios like substations, server rooms, and factory areas. The edge-cloud deployment capability allows large model inference to be flexibly placed on edge nodes or in the cloud. The robot body only requires a lightweight execution unit, reducing hardware costs per device while ensuring efficient scheduling for multi-robot collaboration.

• Elderly and Healthcare Assistance: Close-range human-robot interaction scenarios such as serving tea and water, delivering items, and rehabilitation assistance. Open-RAIL's two-tier online smoothing strategy keeps the joint acceleration standard deviation within the 0.1 rad/s² range, effectively avoiding rigid movements that may cause discomfort or collision risks to humans. This is crucial for ensuring safety in human-robot coexistence environments.

• Scientific Research and Educational Experiments: Universities and startup teams can use the Mock simulation backend (by pointing dataset_path to the LeRobot dataset) to verify the performance of the VLA model without any hardware, reducing the entry barrier. Integrating a new model requires only 50–100 lines of code, allowing researchers to focus on model innovation and avoid the hassle of setting up complex engineering pipelines, thereby accelerating academic exploration and talent training in embodied intelligence.

8. FAQ

Q: What is the relationship between Open-RAIL and LeRobot? Are they competitive or complementary?
A: Their roles are not entirely overlapping. LeRobot is a data format standard and training framework, focusing on "how models are trained"; Open-RAIL is an engineering foundation, focusing on "how trained models can run stably on real robots." Open-RAIL's data collection format is compatible with the LeRobot standard, allowing training data to be seamlessly fed back into the LeRobot ecosystem for the next iteration. In practice, the relationship is more complementary.

Q: Can Open-RAIL be used without an NVIDIA GPU?
A: Server-side inference requires an NVIDIA GPU, CUDA, and PyTorch environment. If no GPU is available, you can validate the full workflow in simulation mode (--model_type mock), or consider deploying the Server side on a cloud node with a GPU. The robot itself (Client) only needs a lightweight execution unit. The decoupled edge-cloud-server design allows for this switch without any code changes.

Q: What specific steps are required to integrate a new robot with Open-RAIL?
A: Two main layers of work are required: one is the hardware layer, which involves implementing standard interface encapsulation for control command issuance, status reading, and action execution based on a lightweight hardware abstraction layer (HAL); the second is the configuration layer, which involves registering the corresponding adapter in conf/*.yaml and configuring the camera topic and action_layout. The official team claims that integration time for new robots can be reduced from weeks to hours.

Q: Which VLA/WAM models does Open-RAIL support?
A: Open-RAIL currently supports 10 mainstream models, including GR00T, π0/0.5, RDT, ACT, etc. To integrate a new model, you only need to implement a unified inference interface (typically 50–100 lines of code), allowing you to reuse all existing capabilities in the upper layer, such as control, data collection, and evaluation. For detailed compatibility lists and integration documentation, please refer to the official repository updates.

Q: How can the "inference + teleoperation correction" hybrid mode be used?
A: This mode is not yet fully open and is planned for open-source release in October 2026. At that time, human operators will be able to intervene and correct the model during inference. The system will align and save the corrected trajectory with the original trajectory using timestamps, which can then be used as high-quality directional training data. Currently, users can only manually control the system through the conventional teleoperation mode.

Q: Does Open-RAIL's operation depend on a specific robot operating system (ROS)?
A: The client requires the installation of SDK or ROS environment as specified by the robot manufacturer. Different adapters encapsulate various underlying communication protocols, but Open-RAIL's hardware abstraction layer isolates these differences from the upper logic. For simplified models without ROS, integration can be achieved by implementing the standard HAL interface.

Q: Does Open-RAIL require the server and robot to be on the same local network?
A: The current version uses the ZMQ protocol for communication, and the official recommendation is to deploy within the same local network. If the server is on the cloud, ensure that network connectivity and latency meet the control cycle requirements. For bandwidth-sensitive or high-latency scenarios, it is recommended to deploy the Server on an edge node to reduce communication latency.

Q: What format are the training data and evaluation logs generated by Open-RAIL?
A: Each run automatically generates LeRobot-style Parquet format training data, which includes fields such as multi-view images, joint states, and inference results, and can be directly fed into LeRobot or training pipelines compatible with this format. Evaluation logs are stored in the eval/ directory in JSON/CSV format and include reproducible timing metrics, making it easy to compare the performance of different models or configurations horizontally.

9. Project Links

• Project Website: https://cmcc-tao.github.io/open-rail/
• Gitee Repository: https://gitee.com/cmcc-tao/open-rail.git