INFRA FOR EMBODIED AI · LAY THE RAIL BETWEEN ACTION MODELS AND PHYSICAL ROBOTS

Open-RAIL: A Real-time Asynchronous Inference Linker for VLA/WAM Models and Robots

Asynchronous Inference · Motion Smoothing & Speed Scaling · Closed-Loop Evolution

Open‑RAIL is a plug‑and‑play open‑source asynchronous inference middleware for diverse VLA/WAM models and heterogeneous robots. Using two‑stage trajectory smoothing and fusing, it resolves inference‑control mismatch and motion jitter to boost execution speed, motion smoothness and task success rates while preserving original action policies. It supports runtime real‑robot data recording and human‑in‑the‑loop intervention for closed‑loop reinforcement learning.

Key Features

  • Asynchronous Pipeline — decouples 5‑10 Hz VLA inference from 200‑500 Hz motor control, removes inference‑control waiting latency.
  • Two‑stage Trajectory Smoothing — achieves near C² continuity and motion jitter drastically suppressed with acceleration std reduces ~100× ( 10+ → 0.1 rad/s²).
  • Drop‑in Compatibility — supports more than 20 VLA/WAM models & 4 heterogeneous robots; new model adaptation needs only 50‑100 lines of code without retraining.
  • Cloud‑Edge‑End Deployment — Server‑Client architecture supports robot‑local, edge and cloud execution over wired/Wi‑Fi/5G with respective latency of end‑side 3‑5 ms, edge 35‑45 ms, cloud 80‑120 ms, requiring zero upper‑level code modification.
  • Enhanced Execution Throughput — achieves up to 2.09× speedup against raw policy output, outperforming tele‑operation speed with no need for recollecting training data.
  • Universal Task Success Boost — lifts model success rate up to 0.95, with absolute gain Δ from +0.10 to +0.725 (evaluated on π₀.₅ and GR00T‑N1.5).
  • Closed‑loop Evolution — auto LeRobot‑formatted real‑robot episode recording plus time‑aligned human‑in‑the‑loop tele‑correction to enable continuous iterative improvement.
GitHub Gitee AI.Huanxin Technical Paper Quick Start

China Mobile Embodied Intelligence Industry Innovation Center Presented by Embodied Model Team (TAO Team)

RAIL ARCHITECTURE

Open‑RAIL: The Infrastructure Bridging Diverse VLA/WAM Brains and Heterogeneous Robot Bodies

Open-RAIL Architecture Overview (click to enlarge)

Open-RAIL RAIL Architecture

RAIL Server

Task Scheduling · Model Inference

RAIL Client

Perception Collection · Realtime Data Manager · Motion Smoothing · Robot Execution · Human-in-the-loop Tele-operation

Web Panel

Execution Monitoring · Parameter Tuning · Camera & Trajectory Visualization · Evaluation & Data Recording · Robot Manual Control

OPEN-RAIL adopts a ZMQ-powered distributed pipeline: the RAIL Server performs task scheduling and VLA model inference to produce action chunks; the RAIL Client handles perception collection, time synchronization, trajectory smoothing and robot execution with human-in-the-loop tele-operation; the Web Panel supports runtime monitoring, parameter tuning, visualization, data recording, evaluation and manual robot control. Additional modules enable tactile sensing and cloud-edge collaborative closed-loop embodied AI operation.

CORE CAPABILITIES

Three Core Capabilities: Stable ｜ Compatible ｜ Evolvable

Capability 1

Stable

Asynchronous inference pipeline + Intra-Chunk Smoother & Inter-Chunk Fuser

A three-thread asynchronous pipeline (observation 30 Hz, inference 5-10 Hz, control frequency 200–1K Hz) decouples robot execution from VLA model inference. The control thread reads pre-filled action buffers, reducing idle-wait latency from full inference time to near-zero. Two-stage trajectory post-processing composed of Intra-Chunk Smoother and Inter-Chunk Fuser suppresses in-chunk jitter and cross-chunk discontinuities, dropping joint acceleration std-dev from 10+ down to 0.1 rad/s², meanwhile achieving up to 2.09× task-execution speedup versus raw VLA baseline.

>200 Hz
Control frequency
10+ → 0.1
Joint accel. std-dev (rad/s²)
~0 ms
Idle wait latency
2.09×
Max task-execution speedup
▸ Expand technical details
  • •Asynchronous pipeline: Three independent threads (observation / inference / control) communicate via queues. The control thread runs at configurable 200–1K Hz and consumes pre-filled action buffers and never blocks for model inference. Idle waiting latency is decoupled from inference latency (near zero), absorbing the large frequency gap between low-rate VLA inference and high-frequency robot motor control.
  • •Intra-Chunk Smoother — eliminates jitter inside individual action chunks. Supported modes: raw baseline, CubicSpline interpolation for joint trajectories + zero-order-hold for grippers, least-squares polynomial fitting (configurable polynomial degree, default 4). Polynomial fitting derives velocity and acceleration from trajectory derivatives; gripper commands adopt local threshold filtering. Output yields continuously-differentiable trajectories to suppress intra-chunk oscillation.
  • •Inter-Chunk Fuser — eliminates abrupt jumps between successive action chunks. Supported modes: search-action motion resync, PD-tracking smooth-velocity with velocity-acceleration clamping, default quintic min-jerk blending with adaptive segment length, direct sync pass-through. It enforces smooth state transition across chunk boundaries and avoids discontinuity spikes.
  • •Overall effect: Joint acceleration standard deviation drops two orders of magnitude (10+ → 0.1 rad/s²), mitigating mechanical shock to robot hardware. The framework enables faster-than-teleoperation task execution with up to 2.09× speedup compared against unprocessed raw VLA outputs.
Three-thread asynchronous pipeline Time 0 ∞ Observation Thread 30 Hz Obs. Buffer Latency (Model Inference) Latency (Model Inference) Latency (Model Inference) Inference Thread 5–10 Hz VLA Out Buffer Action Chunk i Action Chunk i+1 Control Thread 200–1000 Hz CMD Buffer Action Chunk i Action Chunk i+1 Latency (Post Process) Latency (Post Process) Latency (Post Process)

Capability 2

Compatible

Swap models, bodies, or deployments without rewriting upper logic

RobotBase unified hardware interface, standardized inference interface, and Server-Client distributed architecture collapse robot swaps, VLA-model swaps, and deployment swaps into low-level configuration.

4+
Heterogeneous humanoid robots adapted
20+
Mainstream VLA models supported
<100
Lines of code to integrate a new model
▸ Expand technical details
  • •Swap robots: RobotBase unified hardware interface, action_layout unified action mapping; already adapted Unitree G1, AgiBot G1, China Mobile Lingxi, Zhejiang humanoid.
  • •Swap VLA models: standardized input/output inference interface; already supports 10 models including GR00T, TAO, RDT, DreamZero, PI, ACT; integrating a new model needs only 50–100 lines of business code.
  • •Swap deployments: Server-Client end-edge-cloud distributed architecture; Server can run on local body / edge / cloud, Client on the robot; switch deployment by changing only the comms address with zero upper-logic changes and auto-reconnect heartbeat.
ACT GR00T SmolVLA π0.5 ··· RAIL-Server Unified Model Interface Inference Thread Pool VLA calling · parallel inference · sorting Action Chunks Observations ZMQ Communication RAIL-Client Ctrl. Thread frequency scaling interrupt handling Post-Process intra-chunk smoothing inter-chunk fusing Obs. Thread img compression visualization Unified Robot Interface Unitree G1 AgiBot G1 Lingxi ZJ Humanoid

Capability 3

Evolve

Running is data, intervention is teaching — the train-collect-evaluate flywheel

Automatic real-robot recording, online scoring, and human teleop correction form the train-collect-evaluate loop: inference execution → runtime collection → task evaluation → model retraining.

LeRobot
Standard episode format data recording
Score
Success rate and task progress recording
Teleop
Human-in-the-loop intervention and correction
▸ Expand technical details
  • •Collect by running: real-robot runs auto-record images, joints, model outputs, and control commands into standard Parquet Episode data with incremental appends.
  • •Evaluate by executing: sub_task online scoring written synchronously, exportable as JSON / CSV and linked to the Episode.
  • •Teach by intervention: VR teleop human-correction hybrid mode; when the model errs, a human intervenes and the human trajectory is time-aligned with the original inference trajectory to produce high-quality training samples.
  • •Train-collect-evaluate flywheel: inference execution → runtime data collection → task evaluation feedback → model retraining; one pipeline pushes models to the robot and returns real-robot data back for training.
Train-Collect Self-evolving flywheel Infer & Exec Deploy Collect Collect Evaluate Evaluate Retrain Retrain

SUPPORTED MODELS & ROBOTS

Drop-in compatibility with mainstream VLA models and humanoids

Swap a model, a robot body, or a deployment target without rewriting upper-layer logic — Open-RAIL adapts through low-level configuration.

Supported VLA Models

10 supported · 10 release soon

GR00T N1

NVIDIA GR00T humanoid foundation

GR00T N1.5

NVIDIA GR00T humanoid foundation

GR00T N1.6

NVIDIA GR00T humanoid foundation

π0

Physical Intelligence VLA

π0.5

Physical Intelligence VLA

TAO

China Mobile TAO Team VLA base model

GO1

Generalist VLA policy

SmoLVLA

SmoLVLA VLA policy

ACT

Action Chunking Transformer

RDT

Robotics Diffusion Transformer

DM0.5

Release soon

Diffusion policy

Wall-oss

Release soon

Wall-OSS open model

T-Rex

Release soon

Visual-prompt VLA

DeCAL

Release soon

DeCAL adaptation

DreamZero

Release soon

Zero-shot visuomotor policy

GigaWorld-Policy-0.5

Release soon

GigaWorld world-model policy

LingBot-VA

Release soon

LingBot VLA model

GR00T N1.7

Release soon

NVIDIA GR00T humanoid foundation

GR00T N1.7 EEF

Release soon

GR00T N1.7 end-effector variant

XVLA EEF

Release soon

XVLA end-effector variant

Supported Robots

4 heterogeneous humanoids
Unitree G1

Unitree G1

Dual-arm bipedal humanoid

Hand
AgiBot G1

AgiBot G1

Dual-arm wheeled humanoid

GripperHand
China Mobile Lingxi

China Mobile Lingxi

Dual-arm wheeled humanoid

GripperHand
NAVIAI-WA2

NAVIAI-WA2

Dual-arm wheeled humanoid

Hand

OPEN COMMUNITY

Open and Collaborative Open-Source Community

Open-sourcing the proven model-to-robot engineering pipeline so developers focus on model innovation, robot bodies, and scenarios instead of rebuilding deployment plumbing.

Model Template

Observation input, inference interface, action output specs; 20 VLA models adapted.

Robot Template

Body parameters, action layout, comms adaptation templates; 4 heterogeneous robots referenced.

Evaluation Template

Scoring rules, metric logging, analysis export scripts.

Deployment Template

End-edge-cloud distributed deployment examples.

Open-source entry

GitHub Gitee AI.Huanxin Technical Paper

Resources: full docs · hands-on video tutorials · API manual · troubleshooting guide

Model teams

Skip real-robot deployment dev, focus on algorithm innovation

Robot teams

Reuse execution, smoothing, and data-collection base, focus on body control

Application teams

Lower scenario-deployment barrier, accelerate from sim demo to physical robots

GET STARTED

Get Started: Run Open-RAIL in Three Steps

1

Set Up

Set up the environment and verify the pipeline with the Mock backend before connecting a real robot.

2

Connect

Configure the VLA model and robot backend, then connect the inference server to the robot client.

3

Run & Iterate

Run inference, monitor execution in the Web UI, collect data, and iterate on models and configurations.

Documentation

Getting StartedArchitectureConfigurationTroubleshooting

Developer resources: hands-on video library ｜ full technical docs ｜ developer community

Get Started

Tutorials Video

Get Started with Open-RAIL

Robot Tea House — 17-step Chinese tea ceremony

Open-RAIL orchestrates a full tea-serving routine on a humanoid robot.

Robot Tea House — 17-step Chinese tea ceremony

Set a YouTube link in site.tutorials