LimX Dynamics Releases FluxVLA Engine V2 Technical Report, Adding Online Reinforcement Learning and Real-Robot Deployment Validation

When will be the ChatGPT moment for embodied intelligence?

Probably when everyone sees GPT-6 Astra issue commands to robots across domains with a single line of API.

Old O's family still has the strength; they beat everyone to prove to the world that AI's general capabilities are stunning enough, and far from reaching their limit.

Bad news: the engineering foundation (Infra) that translates commands into physical actions is still a bumpy dirt road...

The stronger the model capabilities, the more a usable, well-developed embodied Infra is needed to catch every leap of frontier algorithms.

Recently, LimX Dynamics updated the second version of the technical report for its open-source engineering foundation FluxVLA Engine.

Compared with the first version released in September, V2 further adds online reinforcement learning post-training experiments and expands the coverage of simulation evaluation and real-robot deployment.

The report shows that, on the simulation side, 14 policies are connected to the same LIBERO closed-loop evaluation, with 8 policies each connected on RoboCasa GR-1, RoboTwin, and RoboDojo.

On the inference side, actual tests of 8 model-device combinations show that the optimized model inference path frequency increased to 2.31–9.64 times.

And on multiple real hardware platforms such as ALOHA, Rebot, dual-arm Franka, and LimX Dynamics' self-developed full-size humanoid robot LimX Oli, the report also fully verifies the deployment pipeline from model checkpoint directly to closed-loop execution on real robots.

Online reinforcement learning is also a focus of this update.

Taking SmolVLA as an example, in two paired experiments, after online reinforcement learning, its success rates on the ten tasks of LIBERO-10 and RoboTwin Clean increased by 10.0 and 15.4 percentage points, respectively.

Since being open-sourced on April 8 this year, FluxVLA Engine has continuously expanded model support, evaluation recipes, and real-robot deployment capabilities.

In LimX Dynamics' own words, FluxVLA Engine is about making underlying engineering capabilities truly reusable, freeing valuable R&D manpower from endless "configuring environments and modifying interfaces," and giving advanced models a real road to travel and real ground to land on.

Why is embodied intelligence R&D so expensive and people-intensive?

A major reason is the lack of unified standard components in the industry. For most teams, every new experiment is a one-off engineering effort.

FluxVLA Engine's primary goal is to upgrade this workshop-style repeated construction into a standardized industrial assembly line—LimX Dynamics founder and CEO Zhang Wei compares FluxVLA Engine to a production line for models.

To make this production line sturdy and usable enough, its underlying architecture was designed around four core engineering principles.

Encouragingly, since being open-sourced in April this year, FluxVLA Engine has been evolving at high frequency and continuously operated.

(Many projects tend to "peak at open source and then stop updating," you know how it is)

Looking at its nearly forced-march iteration calendar over the past six months, you can feel this vitality:

Treading these dense footprints, the capability boundary of this foundation has grown solidly from the initial "can train, can evaluate" to today's "can run on real robots, can flow data back."

With FluxVLA Engine, an R&D team is like having a reinforcement engineering army behind it that continuously upgrades infrastructure and broadens boundaries.

English text is being prepared.

Today diffusion policies are hot; tomorrow it might be flow matching or world action models. If I may say so, if every time a technical route changes, all past engineering accumulation has to be torn down and rebuilt, even the biggest companies would at best lose a layer of skin.

To stay away from this tragic fate of "change the model and start over," the only solution is to decouple the underlying engineering infrastructure from the upper-layer algorithms.

In other words, the industry needs an engineering foundation that "responds to all changes by remaining unchanged."

FluxVLA Engine is exactly such an open-source engineering foundation. It connects the full chain of "training, evaluation, and deployment," ensuring that existing engineering accumulation does not go back to zero.

As for how it does this, we can look at three key facets.

The first is data and models.

To let models with different styles and characteristics share the same pipeline, the first step is to standardize the underlying "provisions" and interfaces.

At the data level, raw trajectories from different robots and different simulation environments are first explicitly converted, standardized, and cleaned, and organized into a structure compatible with the LeRobot specification (including Parquet files, videos, and accompanying metadata).

At the same time, conventions such as camera order, action representation, and normalization statistics are also aligned and matched.

After processing, this batch of data can be mixed-trained in the same pipeline, and also supports retaining each group's unique preprocessing and normalization rules by group. Whether training or inference, it goes through independent data entry points and follows the same set of model input and action processing semantics.

Core assets like data have the highest cost in embodied intelligence R&D.

Reducing asset depreciation and improving reuse efficiency is itself an industry-valuable cost-reduction solution.

The same logic is also reflected at the model level.

The platform has now deeply integrated mainstream VLM, VLA, and WAM architectures such as Qwen-VL, GR00T, the π series, and DreamZero.

Different models can fully retain their own native skeletons while smoothly plugging into the training, evaluation, and deployment pipelines through a unified interface.

How satisfying is this design? The "14 strategies training together on the same stage" in the report provides the most intuitive proof.

These 14 strategies cover almost all current mainstream schools:

compact VLA, flow matching policies, modular VLM + action head, world action models, and even GPT-6 Astra, which requires no local weights at all and is called directly via API.

Recently, MiniMax-M3.1-Flash, which is also called directly via API, was added.

Under their respective configurations in the project report, 11 of the 13 local checkpoint strategies achieved an average success rate above 95% on LIBERO (e.g., DiT4DiT reached 98.65%, and π0.5 reached 97.95%).

Can you feel the benefits it brings?

When a new model is released, while others are still staying up late painfully configuring environments and aligning data formats, you can achieve twice the result with half the effort and move further ahead.

The second facet is online reinforcement learning (Online RL).

A model fed only through imitation learning (SFT) is like a student who only memorizes the question bank and easily gets confused when encountering unexpected situations it has never seen.

To make a model truly smart, it must go into the environment and learn through trial and error at the frontier, that is, conduct online reinforcement learning.

However, because online reinforcement learning requires connecting environment interaction, policy updates, and distributed training, engineering complexity instantly explodes exponentially, deterring many excellent teams.

Now it is better: FluxVLA Engine has helped everyone crack this hard nut—

By integrating RLinf, FluxVLA Engine allows compatible flow matching policies to move in directly and enter the online interaction training process, eliminating the pain of re-adapting models and data pipelines.

In paired simulation experiments, each task in each benchmark starts from the same SmolVLA SFT checkpoint and undergoes task-specific PPO post-training.

After 40 outer iterations, the average success rate on LIBERO-10 tasks increased from 66.2% to 76.2%; the ten RoboTwin Clean tasks increased from 45.9% to 61.3%, improvements of 10.0 and 15.4 percentage points, respectively.

As can be seen, the platform has substantively opened an engineering shortcut from the "imitation learning starting point" to "online interaction score improvement." Even small-parameter models can squeeze out astonishing potential through closed-loop trial and error.

The third facet is microscope-style evaluation.

In the past, this evaluation mechanism was particularly unfriendly. You could not see clearly how the model actually ran; in the end, only a cold success-rate number was presented.

The V2 report further expands the scope of simulation evaluation.

The former, by comparing performance under two settings, allows observation of the model's adaptation to corresponding environmental changes; the latter, in addition to final success or failure, also records the task progress bar in real time and draws a "capability radar chart" across five dimensions: generalization, memory, precision, long-horizon tasks, and open instructions.

This fine-grained evaluation is simply good news for R&D personnel~

For example, if a clothes-folding or block-grasping task fails, it may actually have perfectly completed the first three stages and only trembled at the final step of "putting it into the box."

At this point, by looking at "stage progress" together with "final success rate," one can quickly discover whether the model has poor eyesight (visual perception), insufficient brains (long-horizon planning), or uncoordinated hands and feet (fine control).

It is often said that evaluation without attribution is blind-box alchemy.

This traceable and localizable evaluation system is essentially helping teams save money.

As the saying goes, it is fierce as a tiger in the simulator, but once on the real robot it can only go slowly, slowly, twitch, twitch, twitch.

(Don't ask me where the saying comes from.)

Embodied models usually predict a segment of actions at a time, which the robot then executes step by step. In this process, model inference may take a relatively long time, while the robot control loop is still running continuously.

If the previous action segment has not finished executing and the next prediction has already been generated, discontinuity may appear between the two action segments. Even if the model's output actions are numerically reasonable, they still need to meet the robot's requirements for speed, acceleration, and trajectory smoothness.

To cure the "stuttering" and "twitching" of real-robot deployment, FluxVLA Engine has released a hardcore systems engineering combination punch.

Without changing any model weights, FluxVLA Engine carried out deep low-level inference reconstruction for models such as GR00T and π0.5, cutting redundant computation and kernel scheduling overhead to the extreme.

Among the 8 model-device combinations recorded in the report, the optimized inference frequency increased by about 2.31 to 9.64 times.

What is even more impressive is that this thing is fast but not rough—

Numerical alignment tests for the GR00T action head show that, compared with the original version, the accelerated action output has a cosine similarity exceeding 0.99999, with a maximum absolute error of only about 0.02.

Good heavens, squeezing out the potential of computing power purely through engineering optimization! It costs not a single cent on new GPUs and hardly sacrifices model precision.

Who wouldn't say "Perfect" after hearing this?

Beyond computing power improvement, action stability is equally critical.

FluxVLA Engine introduces a real-time action chunking coordination (RTC) mechanism.

Simply put, it uses the tail end of the previous action segment that has not yet finished executing to constrain the beginning of the next newly predicted action segment, meshing the two segments smoothly together like a zipper and eliminating abrupt changes.

Subsequently, a trajectory post-processing module performs smoothing filtering and kinematic constraints, ensuring that the motion commands sent to the motors satisfy physical boundaries and produce stable output.

Inference optimization addresses the efficiency of action generation, while RTC and trajectory post-processing are responsible for connecting prediction and execution. With these three measures combined, the engineering threshold for deploying cutting-edge algorithms on real robots is cut down by more than half, protecting expensive robot hardware and, moreover, giving the model a human-like smoothness.

In the real-robot deployment stage, FluxVLA Engine cleverly designs a two-layer decoupled interface: the Runner that manages the brain and the Operator that manages the body.

Specifically, the runner is responsible for model inference, action scheduling, and state management during execution, while the operator is responsible for sensor data collection, robot communication, and transmission of control commands.

The two divide the work and cooperate, connecting the model's action prediction with the robot body's actual execution.

With this universal socket, different robot bodies only need to adapt their respective operator interfaces to plug into the same deployment pipeline, greatly reducing migration costs.

The V2 report demonstrates the application of this deployment pipeline on platforms such as ALOHA, dual-arm Franka, Rebot, and LimX Oli.

In addition, on the LimX Oli humanoid robot with full-body high degrees of freedom, when facing complex box-handling tasks, π0.5 achieved a 61.67% completion rate for the first three stages and a 33.33% completion rate for all four stages, clearly verifying the end-to-end connectivity of the full-body mobile manipulation pipeline and where the bottlenecks lie.

(Note: The above are all measured results of the project report under specific configurations, intended to verify the cross-platform deployment pipeline rather than a controlled architecture comparison.)

However, for embodied R&D, getting the model to run tasks on real robots is only the first half of landing the engineering pipeline.

If the corrective actions humans provide nearby and the mistakes robots make in the real world cannot become nutrients fed back into the model, then embodied intelligence will never get its data flywheel spinning.

To this end, FluxVLA Engine directly turns the "Human-in-the-loop execution and learning closed loop" into a standard engineering module.

It supports seamless human takeover for correction while the robot works autonomously, and automatically completes correction data collection and reward annotation.

The accompanying ARM research demonstrates the application of such methods—

In the ALOHA eight-stage towel-folding task, the behavior cloning baseline achieved a success rate of 62.1%; after adopting the SARM reward modeling scheme, the success rate rose to 78.5%; with further adoption of ARM advantage-weighted behavior cloning, the success rate reached 99.4%.

At the same time, task throughput per hour also increased from 18 episodes to 32 episodes.

At this point, the full picture of FluxVLA Engine's evolution becomes completely clear:

It not only helps you get the model onto real robots, but also sets up two "evolution engines" for you.

One spars with itself through online reinforcement learning in the simulator, and the other accumulates real-world experience through human-in-the-loop throughput in the real world.

Only after the data flywheel truly starts spinning can the upper limit of model capability, previously stuck due to embodied Infra being too fragmented and outdated, be fully unleashed.

English text is being prepared.

This foundation was not built behind closed doors, but is the practical crystallization that LimX Dynamics accumulated through hard-won experience in embodied intelligence algorithms, general robot body R&D, and engineering delivery.

At the end of the report, LimX Dynamics also teased a much larger follow-up ecosystem blueprint:

FluxBisim, FluxDAgger, and FluxThemis have already been released and put into use, while FluxMimir and FluxHermes are on the way. They will respectively guard the five core gateways of data, simulation, interaction, evaluation, and deployment.

As Zhang Wei said, "FluxVLA is equivalent to a model production line."

On this production line, vertical application teams that understand scenarios and have data can focus 100% of their energy on core business and algorithm innovation; while the dirty, tiring, and error-prone underlying infrastructure work is continuously opened up and optimized by LimX Dynamics through a standardized open-source foundation.

From a higher industry perspective, the competitive logic of embodied intelligence is undergoing profound reconstruction.

At the very least, the embodied intelligence field has indeed been taught a harsh lesson by GPT-6 Astra.

For a long time everyone assumed that large language models and robots in the physical world were actually two tracks with only some intersection. No one expected it to cross over, deliver a head-on blow, and show off a wave of dimensional reduction.

Traditional embodied models are facing the same risk of disruption as fields such as translation and 3D. So don't laugh—in this field, you are certainly anxious too.

Facing this situation, where is the way out?

Focusing on deepening underlying models is certainly a required course, but here I beg everyone, don't just stare at the models!

While continuing to polish models, polishing embodied infrastructure must also be put on the fast track.

Only when embodied underlying engineering capabilities are highly reusable like water, electricity, and coal can every trial and error in the industry avoid becoming a sunk cost, and can precious R&D resources be freed from endless "reinventing the wheel" and devoted to exploring truly unknown new capabilities.