APXInf Goes Open Source, Embodied Intelligence Fills the Gaps at the Edge

Wuwen Xinqiong, together with Tsinghua University and Shanghai Jiao Tong University, officially open-sourced APXInf, an edge-side inference engine for embodied intelligence, on September 15, 2026. Its goal is to address the most practical barriers faced when bringing embodied models from the cloud onto robots: latency, stability, and deployment costs.

According to official disclosures, when running the PI 0.5 FP8 model on the Jetson Thor, APXInf reduced end-to-end inference latency from 278 ms to below 26 ms—a reduction of more than 10×. For a chatbot, waiting a few hundred milliseconds usually just means that the response is “a little slow.” For a robot, that interval could mean a failed grasp, a jerky trajectory, or even a collision with an obstacle.

This is also what currently makes APXInf particularly noteworthy: rather than focusing on training yet another larger embodied model, it attempts to deploy existing models on robots in a truly practical way, creating a shorter and more stable closed loop between perception, decision-making, and motion control.

The Real Bottleneck in Embodied Intelligence Is Not Just Model Size

Over the past year, embodied-intelligence models have advanced rapidly. Models can understand images and language, plan actions based on instructions such as “put the cup on the table into the box,” and acquire more complex manipulation capabilities through imitation learning and reinforcement learning.

However, getting a model to run successfully in the cloud does not mean that a robot can execute it reliably.

Robots need to continuously perform several tasks in a loop: read camera and sensor data, understand the current environment, predict the next action, and send control signals to the robotic arm or mobile base. This loop is not a one-off question-and-answer interaction, but a continuously running real-time control system. Any delay in any part of the process will affect the next action decision.

A latency of 278 ms may not seem particularly long, but if a robot must execute a series of actions and every decision adds nearly one-third of a second of waiting, the result becomes an obvious “half-beat delay.” In tasks such as grasping, obstacle avoidance, and target tracking, the environment is also changing. The frame received by the model may already depict the scene from several hundred milliseconds earlier rather than the current scene.

This is where the value of edge-side inference becomes clear: running the model as close as possible to the sensors and actuators reduces the additional latency caused by uploading data to the cloud, queuing, network transmission, and remote responses. It gives up some of the flexibility of cloud computing in exchange for lower latency, stronger real-time performance, and the ability to continue operating in weak-network or even offline environments.

What APXInf Does

Based on publicly available information, APXInf is not a new embodied foundation model, but an inference engine and toolchain designed for edge deployment. Its focus includes model integration, inference optimization, hardware adaptation, and long-term runtime stability.

APXInf currently supports two embodied models, PI 0.5 and WALL-OSS, and covers multiple stages from development and validation to deployment on the robot itself. Developers can first test models on desktop-class GPUs and then migrate them to the NVIDIA Jetson platforms commonly used in robots.

Supported hardware includes:

• NVIDIA RTX 4090: suitable for model development, performance validation, and offline debugging;
• Jetson Orin: an embedded computing platform currently used by many robots and edge devices;
• Jetson Thor: a robotic platform designed for higher computing demands, suitable for running more complex embodied models.

For development teams, hardware coverage is more important than a single benchmark number. Embodied systems are often not developed on a single server, but instead go through an entire pipeline: “workstation training and validation—edge-device adaptation—on-site operation on the robot.” If every change of hardware requires the inference interface, operators, and runtime configuration to be modified again, the model deployment cycle will quickly become longer.

APXInf attempts to consolidate this work into a unified runtime. Its value does not lie in automatically giving all models the same performance, but in reducing the engineering friction between models and robots.

What Does Under 26 ms Mean?

It should first be noted that 26 ms is an official test result from publicly available materials. Actual performance still depends on factors such as the model version, precision, input resolution, control frequency, hardware power mode, and whether preprocessing and postprocessing are included. Therefore, it should not be simply interpreted as a fixed latency that can be achieved in every scenario.

However, from the perspective of control systems, this number still has clear significance.

If end-to-end inference can be stably kept within the tens-of-milliseconds range, robots have the opportunity to obtain environmental information and update their actions at a higher frequency. Compared with making one decision every 278 ms, a latency of under 26 ms can significantly reduce waiting in the action pipeline, making robotic-arm trajectories smoother and visual feedback more timely.

It can be compared to a driving system:

• Cloud inference is more like entrusting driving decisions to a remote command center: it has substantial computing power, but every decision must pass through a communications link;
• Edge-side inference is more like placing key decisions inside the vehicle: its capabilities may not be unlimited, but braking, obstacle avoidance, and steering do not need to wait for a remote response.

For robots, real-time performance is not an experience metric but a functional one. A chatbot model that responds a little slowly can still work normally; a robot whose actions are half a beat too slow may be unable to complete the task at all.

A Link to RLinf, Open-Sourced Last Year

APXInf also forms part of the same ecosystem as RLinf, an embodied-intelligence training framework previously open-sourced by Wuwen Xinqiong.

This means that developers can potentially use RLinf during training and APXInf during deployment, reducing repeated adaptation between the training framework, model formats, and edge-side runtime. For teams that need to train their own embodied models, this “training–optimization–deployment” integration is more attractive than offering an inference library alone.

Embodied models differ from traditional language models. Their output is not a piece of text, but a series of continuous actions. Performing well in a simulated environment during training does not mean that the system will remain reliable after deployment on a real robot. Real-world environments include camera noise, changes in lighting, mechanical errors, network fluctuations, and computing limitations across different hardware.

Therefore, an edge-side inference engine is not merely an accessory to a training framework. It needs to handle model precision conversion, operator support, memory usage, data movement, and runtime scheduling, while also taking into account stability during long-term robot operation. For industrial and service robots, achieving high speed in a single benchmark run is not enough. Continuous operation for hours, days, or even longer without crashing is much closer to actual requirements.

The Significance of Open Source: Turning Deployment Experience into Public Infrastructure

What embodied intelligence currently lacks is not model demonstrations, but reproducible engineering paths.

Many teams can complete a successful grasp in the laboratory, yet find it difficult to deploy the system across different hardware, environments, and robots. The reason is often not that the model is entirely unusable, but that there is a great deal of fragmented work in between: inference-backend adaptation, precision calibration, input and output format conversion, GPU memory management, thread scheduling, and exception recovery.

After APXInf is open-sourced, developers will at least have access to a reference implementation that is closer to real-world deployment. It turns edge-side inference from something that “every team builds independently” into a foundational component that can be iterated on collectively. For universities and research institutions, this can help shorten the distance between a research-paper model and a physical device. For robotics companies, it may reduce the engineering cost of early-stage validation.

Of course, open source does not mean that deployment will become simple. The challenges in robotic systems are usually distributed across the entire pipeline, and an inference engine can solve only part of them. Sensor synchronization, controller design, action safety boundaries, data collection, and on-site debugging still require substantial effort. Whether APXInf can maintain stability across more models, robot forms, and tasks will need to be validated through actual community use.

This Is Not Simply a Performance Competition

Current industry attention toward embodied models tends to focus on parameter size, task success rates, and benchmark rankings. But robots will ultimately enter factories, warehouses, laboratories, and homes. Whether a product can be deployed is often determined by another set of metrics: Is its response timely? Is the system stable? Are hardware costs controllable? Is the model easy to migrate?

By bringing edge-side inference to the forefront, APXInf indicates that competition in embodied intelligence is gradually shifting from “whose model is smarter” to “who can turn a model into reliable robotic motion.” This is also what makes it more noteworthy than yet another model release.

From an engineering perspective, latency below 26 ms is certainly important. More important, however, is whether that latency can remain stable under different workloads, power settings, and long-duration tasks. If the answer is yes, an edge-side inference engine will be more than an optimization tool—it will become part of the infrastructure for embodied intelligence.

For developers, the more practical approach at present is to first validate models and tasks on desktop GPUs such as the RTX 4090, then use APXInf to migrate them to the Jetson Orin or Jetson Thor, gradually checking latency, GPU memory, power consumption, and control frequency, rather than moving a cloud-based model to a robot unchanged.

The “last mile” of embodied intelligence has never been as simple as copying a model file onto a device. It requires the model, runtime, hardware, and control system to work together. By open-sourcing APXInf, the developers have at least brought one of the most easily underestimated issues—edge-side inference—to the center of industry discussions.

What This Means for Developers

If you are working on embodied models or robotic applications, there are three main aspects of APXInf worth watching:

1. A more complete deployment pipeline: It covers the different stages of model validation and robot-side operation, from desktop GPUs to Jetson platforms.
2. Latency optimization that is more closely aligned with real-world control: The officially reported test results for the PI 0.5 FP8 model directly address a core issue in real-time robotic control.
3. A connected training and inference ecosystem: Combined with RLinf, APXInf gives developers the opportunity to complete training, debugging, and deployment within the same ecosystem.

However, before using it in a production environment, developers should independently verify the following metrics:

• Whether end-to-end latency includes preprocessing, model inference, and postprocessing;
• Performance changes under different input resolutions and control frequencies;
• GPU memory usage and temperature during long-term operation;
• Whether task success rates decline after model quantization;
• Recovery mechanisms for network interruptions, sensor failures, and inference errors.

Whether APXInf can become a general-purpose edge-side runtime for embodied intelligence will require more community projects and real-robot applications to answer. But at least for now, it sends a clear signal: the next stage of embodied intelligence is not only about training more capable models, but also about enabling those models to operate fast enough and reliably enough on robots.