LimX Dynamics updates the FluxVLA Engine V2 technical report, adding online reinforcement learning and real-robot deployment evaluations

[Image relay test, unpublished] Reuse engineering capabilities with one click, focus on developing new capabilities! Building a wheel once is enough | A detailed look at the FluxVLA Engine technical report

This is roughly when everyone saw that GPT-6 Astra can issue cross-domain commands to robots with a single line of API.

Old O's family still has strength; it was the first to prove to the whole world that AI's general capabilities are impressive enough, and far from reaching their limit.

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

The stronger the model capabilities become, the more a usable, complete 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 integrated into the same LIBERO closed-loop evaluation, with integration results for 8 policies each 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 increases 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 LIBERO-10 and the ten RoboTwin Clean tasks 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 path to follow and a real place to land.

Farewell to "workshop-style" repeated wheel-building, build a "standard production line" for embodied R&D

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 robust and usable enough, its underlying architecture is designed around four core engineering principles.

Modular decoupling: through registries and standard interfaces, the vision-language backbone, action head, datasets, and training policies are made into standard Lego bricks, supporting free combination while also allowing native policy implementations to be retained.

Deployment-oriented system optimization: no paper talk in the lab; from the outset, inference acceleration, RTC (real-time action chunking coordination), and trajectory post-processing are welded into the runtime workflow.

Reproducible experiments: fully seal and preserve each experiment's configuration, model state, and execution trajectory, so success leaves a trace and failure has evidence to check.

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

(Many projects often "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:

April 8: FluxVLA Engine officially open-sourced

June 22: Connected the minimal inference pipeline for LimX Oli humanoid whole-body mobile manipulation

October 22: V2 report updated, adding online RL post-training and expanded simulation and real-robot evaluation

Following 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 return data."

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

How one foundation connects the full pipeline of training, evaluation, and deployment

English text is being prepared.

Today diffusion policies are hot; tomorrow it may 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 largest company 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 pipeline 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 and standardized through cleaning, then 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 own unique preprocessing and normalization rules by group. Whether for training or inference, everything goes through an independent data entry point and follows the same set of model input and action processing semantics.

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

Reducing asset depreciation and improving reuse efficiency is itself a cost-reduction solution with industry value.

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 processes through a unified interface.

How great is this design? The 14 policies training side by side in the report provide the most intuitive proof.

These 14 policies 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, also called directly via API, was added.

Under their respective configurations in the project report, 11 of the 13 local checkpoint policies achieved an average success rate above 95% on LIBERO (for example, 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 struggling to configure environments and align data formats, you can get 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 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 of real combat, that is, conduct online reinforcement learning.

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

Now it's 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 interactive 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 up 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, and in the end there was just a cold success-rate number sitting there.

The V2 report further expands the scope of simulation evaluation.

RoboTwin added 8 new policy integrations and also provides scorecards for two environment settings: Clean and Random;

RoboDojo conducted a "full-subject physical examination" of 8 policies covering 42 tasks, with up to 2,100 trials per model.

The former compares performance under the two settings to observe how well the model adapts to corresponding environmental changes; in addition to final success or failure, the latter also records task progress bars 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 fumbled at the last step of "putting it into the box."

At this point, by looking at "stage progress" together with "final success rate," you 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.

Crossing the life-and-death line from "high simulation scores" to "real-machine work"

As the saying goes, in the simulator it is fierce as a tiger, but once on the real machine it can only slowly, slowly tremble and tremble.

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

Embodied models usually predict a segment of actions at a time, and then the robot executes them 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 yet finished executing while the next prediction has already been generated, a discontinuity may occur between the two action segments. Even if the model's output actions are numerically reasonable, they still need to satisfy the robot's requirements for velocity, acceleration, and trajectory smoothness.

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

Move one: squeeze out every drop of compute with no loss, with inference speeding up by up to 9.64x

Without changing any model weights, FluxVLA Engine performed 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-and-device combinations recorded in the report, the optimized inference frequency improved by about 2.31 to 9.64 times.

On NVIDIA A100, the inference frequency of π0.5 increased from 2.20Hz to 21.2Hz, a full 9.64 times faster;

On the compute-constrained AGX Orin 64GB, GR00T increased from 3.20Hz to 7.40Hz, while π0.5 increased from 1.40Hz to 4.40Hz.

What is even more impressive is that this thing is fast without being rough—

Numerical alignment tests on 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 grief, squeezing the full potential of compute purely through engineering optimization! It costs not a single cent on new GPUs and hardly sacrifices model accuracy.

Who wouldn't call that perfect after hearing it?

Move two: add a "shock absorber" to actions to achieve a supple meshing of brain and limbs

Beyond compute improvement, action stability is equally critical.

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

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

A subsequent trajectory post-processing module then performs smoothing filtering and kinematic constraints, ensuring that the action commands sent to the motors satisfy physical boundaries and produce stable output.

Inference optimization solves the problem of action generation efficiency, while RTC and trajectory post-processing are responsible for connecting prediction and execution. These three moves cut down by more than half the engineering threshold for putting frontier algorithms on real machines, protect expensive robot hardware, and moreover give the model a human-like silky feel.

English text is being prepared.

In the real-machine deployment stage, FluxVLA Engine cleverly designed 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 control command transmission.

The two divide labor 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 chain on platforms such as ALOHA, dual-arm Franka, Rebot, and LimX Oli.

ALOHA (six tasks): π0.5 achieved an overall success rate of 72.22%;

Dual-arm Franka (five tasks): GR00T N1.7 achieved an overall success rate as high as 88.00%, and π0.5 reached 79.00%;

Rebot (four tasks): π0.5 achieved an overall success rate of 77.50%;

In addition, on the full-body high-degree-of-freedom LimX Oli humanoid robot, when facing the complex task of carrying boxes, π0.5 completed the first three stages 61.67% of the time and all four stages 33.33% of the time, clearly verifying both the end-to-end connectivity of full-body mobile manipulation and where the bottlenecks lie.

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

But for embodied R&D, getting the model to run tasks on a real machine is only the first half of landing the engineering chain.

If the corrections humans make beside it and the mistakes the robot makes 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 turned the "Human-in-the-loop execution and learning closed loop" into a standard engineering module.

It supports seamless human takeover and correction at any time 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%; after further adopting 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 a real machine, but also sets up two "evolution engines" for you.

English text is being prepared.

Only after the data flywheel truly starts spinning can the upper limit of model capability, previously stuck because embodied Infra was too fragmented and antiquated, be fully unleashed.

Final words

English text is being prepared.

This foundation was not built behind closed doors; it is the practical crystallization that LimX Dynamics accumulated through trial and error in embodied intelligence algorithms, general-purpose robot body R&D, and engineering delivery.

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

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 put it, "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 truly 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 could cross over, deliver a head-on blow, and show off a wave of dimensional strike.

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

Faced with 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, honing embodied infrastructure must also be put on the fast track.

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