Open-RAIL - China Mobile's Open Source General Engineering Foundation for Embodied Intelligence

What is Open-RAIL

Open-RAIL is a general engineering foundation for embodied intelligence open-sourced by China Mobile to the world, and it is also the industry's first general nervous system connecting VLA/WAM models with robot bodies. At the framework level, Open-RAIL closes the loop of inference—execution—data return—model iteration. Its parallel pipeline improves motion smoothness by two orders of magnitude, enables zero-code-change deployment across device, edge, and cloud, shortens new robot integration from weeks to hours, and requires only 50–100 lines of code for a new model. It has currently been adapted to 4 heterogeneous robots and supports 10 mainstream models. The Mobile Xingchu robot has already been operating routinely in Hangzhou.

Main Features of Open-RAIL

Inference and Execution: Observation, inference, and control are split into three parallel pipelines and combined with a two-level smoothing strategy, reducing the standard deviation of joint acceleration from 10+ rad/s² to 0.1 rad/s², making motion both stable and smooth.
Device-Edge-Cloud Deployment: Inference is uniformly placed on the Server side, while the robot side is only responsible for execution. By changing one connection address, you can switch between device, edge, and cloud as needed, so computing power no longer limits model selection.
Heterogeneous Adaptation: Through a lightweight hardware abstraction layer and unified model integration conventions, control and status interfaces are standardized, so changing robots or models does not require starting over.
Data Closed Loop: Data collection is embedded into every inference execution. Multi-view images, joint states, and inference results are automatically archived in an out-of-the-box standard format and can be directly fed into the next round of training.
Hybrid Inference and Teleoperation: When the model deviates, humans can intervene at any time to correct it. The correction trajectory and the original trajectory are strictly timestamp-aligned and saved in parallel, making each manual correction a high-quality targeted teaching session.
"Push-Collect-Evaluate" Closed Loop: Model inference, robot execution, data return, and model iteration are connected into a general closed loop, filling an industry gap and allowing results to be replicated at scale to more robots and models.

Technical Principles of Open-RAIL

Parallel Pipeline Inference Architecture: In response to the 30–50x 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 environment and joint states, the inference thread continuously computes action chunks, and the control thread continuously sends commands to the lower-level controller. The three do not wait for one another, thereby eliminating motion stutter caused by serial waiting.
Two-Level Online Motion Smoothing: Models output discrete action points, and direct execution produces high-frequency acceleration and deceleration shocks. Open-RAIL implements a two-level smoothing strategy within and between chunks at the framework level, all computed online in real time, requiring no modification of model weights or post-training, and can reduce the standard deviation of joint acceleration from 10+ rad/s² to 0.1 rad/s², so the hardware no longer bears high-frequency shocks.
Server-Client Device-Edge-Cloud Decoupling: The system abstracts inference uniformly to the Server side, while the robot body (Client) is only responsible for action execution and status reporting. The Server can be deployed on the body, on edge computing, or in the cloud, with completely identical code. Only the connection address needs to be changed to achieve zero-code-change switching among the three deployment forms of device, edge, and cloud, so model scale is no longer constrained by the embedded computing power of the body.
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 the low-level adapter and complete registration, while the upper-layer logic is fully reused. On the model side, a unified inference interface is similarly defined, and a new model only needs to implement the standard interface to be integrated, usually requiring only 50–100 lines of code, minimizing the adaptation cost across embodiments and models.

Follow WeChat and reply "Open Source" to join theAI Open Source Project Communication Group

How to use Open-RAIL

Confirm the environment: Prepare a Linux environment with Python ≥ 3.10. The server side requires an NVIDIA GPU + CUDA + PyTorch, and the client side installs the vendor SDK or ROS according to the robot's requirements. The two sides only need to communicate via ZMQ within the same LAN.
Get the code: Clone the repository from Gitee, GitHub, or Huanxin Community (git clone https://gitee.com/cmcc-tao/open-rail.git）。
Install dependencies: After creating a conda environment, run pip install -e ., which will automatically register vla-server and vla-web-client as two command-line entry points.
Start the server: Run python run_server.py --model_type <模型类型> --model_path <权重路径>, load the selected VLA/WAM model, and expose the inference endpoint via ZMQ.
Start the Web client: Run python run_web_client.py(by default reads conf/default_conf.yaml, listens on port 9000). You can use --conf to specify a custom configuration.
Verify the connection: Open http://localhost:9000in a browser. If you can see the Web interface, camera feed, and robot status as ready, startup is successful. After selecting a task, you can drive the robot.
Start with simulation (no real robot): In conf/robots_conf.py , point the Mock backend's dataset_path to the LeRobot dataset, and with --model_type mock you can first validate the full pipeline.
Real robot execution: Modify conf/*.yaml in robots.type to the target adapter (agibot_g1 / ti5_t170c / navi_wa2), configure the camera topics and action_layout according to the documentation, and then start with the same two commands.
Device-edge-cloud switching: No code changes are needed. Just modify the server network address field in the configuration to run inference on the device, edge, or cloud.
Obtain data and evaluation: Each run automatically produces LeRobot-style Parquet training data and eval/ evaluation logs (JSON/CSV), ready out of the box for direct backflow into training; the "inference + teleoperation correction" hybrid mode is planned to be open-sourced in October.

Core advantages of Open-RAIL

Stable and smooth motion: A three-thread asynchronous pipeline plus two-stage online smoothing eliminates the 30–50x inference-to-control frequency gap at the framework layer. The standard deviation of joint acceleration drops from 10+ rad/s² to 0.1 rad/s², without modifying the model or limiting the model architecture.
Adapt once, reuse everywhere: A lightweight hardware abstraction layer plus unified integration conventions reduce new robot integration from weeks to hours, and new model integration requires only 50–100 lines of code, with the upper-layer logic fully reused.
Compute is no longer a barrier: Under the server-client decoupled architecture, inference is uniformly placed on the Server side. Changing only one connection address enables zero-code switching between device, edge, and cloud deployment, and even embedded devices can drive large models.
Collection and evaluation during execution: Data collection and evaluation logs are embedded into every inference execution, automatically producing out-of-the-box LeRobot-style data and reproducible latency metrics, closing the loop of "inference-collection-evaluation".
Human correction as teaching samples: In hybrid teleoperation mode, you can pause, intervene to correct, and resume at any time. Correction trajectories are strictly time-aligned with the original trajectories and saved in parallel, directly becoming high-quality targeted training data.
Validated in real-world scenarios: The mobile robot chef has been operating routinely in the Hangzhou campus, serving over a hundred cups of coffee per day with a full 90-second process per cup. The model makes autonomous decisions throughout long-sequence tasks, demonstrating the value of the foundation.

Open-RAIL project address

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

Comparison of Open-RAIL with similar competitors

Comparison dimension	Open-RAIL (China Mobile)	LeRobot（Hugging Face）
Core positioning	Ageneral engineering foundationconnecting VLA/WAM models with robot bodies, focused on the "last mile" of real-machine deployment	Anopen-source training library and data format standardfor robot learning, covering the full chain of data, training, and sharing
Covered chain	A complete closed loop of model inference → real-machine execution → data回流 → model iteration	Mainly data collection → training → evaluation; real-time deployment inference on real machines is one part of it
Real-time execution capability	Three-thread asynchronous pipeline + two-level online smoothing, joint acceleration standard deviation 10+→0.1 rad/s², specifically designed to eliminate the inference-control frequency gap	Has an asynchronous inference module (PolicyServer/RobotClient architecture), but smoothing and real-time optimization are not its core design goals
Hardware adaptation	Lightweight hardware abstraction layer, already adapted to 4 heterogeneous robots (including humanoids), reducing new model onboarding from weeks to hours	Officially supports 20+ hardware models (SO-100/101, Unitree G1, Koch, etc.), active community adaptation, leaning toward lightweight robotic arms and educational hardware
Model support	Already supports 10 mainstream VLA/WAM models (GR00T, π0/0.5, RDT, ACT, etc.), new model integration in ≤100 lines of code	Broader model ecosystem (π0, GR00T N1.7, SmolVLA, WALL-OSS, etc.), and models mostly use LeRobot as their native training/deployment format
Deployment form	Server-client separation, zero-change switching across device/edge/cloud, embedded devices can drive large models	Supports standalone and Jetson edge deployment, and also provides gRPC asynchronous inference with GPU server-robot separation
Data closed loop	Collect while running (LeRobot-style Parquet) + evaluate while running, logs automatically persisted	The data format standard setter (LeRobotDataset); dataset sharing within the ecosystem is the biggest advantage (open-source embodied AI datasets have been downloaded over 15 million times)

Open-RAIL application scenarios

Commercial service robots: such as the already deployed "mobile robot chef", completing long-sequence service tasks such as coffee making and microwave meal heating, over a hundred cups of coffee per day, 90-second full process per cup, with the model making autonomous decisions throughout multiple parallel orders.
Industrial inspection and monitoring: For repetitive duty tasks such as equipment inspections, meter readings, and anomaly alarms in substations, server rooms, and factory areas, end-edge-cloud deployment allows large model inference to run at the edge or in the cloud, while the robot itself does not need high computing power.
Elderly care and medical assistance: In scenarios such as serving tea and water, delivering items, and rehabilitation assistance, smooth execution capability ensures safety and gentleness when the robot interacts with people at close range.
Scientific research and teaching experiments: Universities and startup teams can start with zero hardware using the Mock simulation backend to quickly validate the effectiveness of VLA models; integrating a new model requires only 50–100 lines of code, allowing researchers to focus on model innovation without having to build an engineering pipeline.