🤖 machine learning

Efficient Vision-Language-Action Management and Serving for Robot Factories

The paper introduces Robion, a novel serving and management system for multi-robot, multi-model Vision-Language-Action (VLA) workloads on edge servers that employs intra-GPU stage disaggregation and intelligent traffic control to maximize robot load while strictly adhering to millisecond-scale safety Service-Level Objectives (SLOs).

Original authors: Dionysios Adamopoulos, Nattapol Chanpaisit, Basel Fakhri, Christina Giannoula

Published 2026-09-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dionysios Adamopoulos, Nattapol Chanpaisit, Basel Fakhri, Christina Giannoula

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a factory floor where machines do not just follow rigid, pre-programmed commands, but instead see the world, understand instructions given in plain language, and decide how to move their own arms to pick up a part or assemble a component. This is the promise of physical artificial intelligence, a field where robots are equipped with "vision-language-action" models. These systems act as the robot's brain, taking in a camera image and a text prompt like "pick up the red box," and then calculating the precise physical movements needed to complete the task. For these robots to work safely and effectively, they must react in the blink of an eye. If the brain takes too long to think, the robot might jerk its arm, drop an object, or even halt an entire assembly line, causing costly delays or safety hazards.

The challenge lies in the fact that the computers powerful enough to run these thinking models are too heavy, expensive, and power-hungry to be strapped directly onto the robot itself. Instead, engineers have proposed sending the robot's thoughts to a nearby local server, a kind of digital brain center, which does the heavy lifting and sends the answers back. However, this setup creates a new problem: how do you manage a single server that must serve dozens of robots at once, ensuring that every single request gets an answer fast enough to keep the factory running smoothly? A new system called Robion has been designed to solve exactly this puzzle, allowing a single server to handle many different robot tasks simultaneously without missing a beat.

The researchers behind Robion discovered that the way these robot brains work is fundamentally different from the large language models used for chatbots or the massive image generators used for art. While those systems often run for hundreds of milliseconds or even seconds, the robot's thinking process happens in mere milliseconds. It is a two-step process: first, the system looks at the image and reads the instruction to understand the situation; second, it calculates the specific physical movements required to act. Because these steps are so fast and have different needs—one requires heavy calculation while the other requires rapid memory access—trying to run them as a single, continuous pipeline on a server is inefficient. It is like trying to run a marathon and a sprint at the same time; the slow, heavy runner slows down the fast, light one.

To fix this, the team built Robion to split these two steps apart and run them side-by-side on the same computer chip, but in a carefully controlled way. They created two separate lanes of traffic on the server's processor. One lane handles the heavy thinking, while the other handles the quick movement calculations. Crucially, they designed a traffic controller that ensures the heavy lane never completely blocks the light lane. They do this by reserving a specific amount of computing power for the quick lane, guaranteeing that it always has space to run, even while the heavy thinking is happening. This allows the server to process multiple robot requests at the exact same time, overlapping the thinking of one robot with the movement calculation of another.

Furthermore, the researchers realized that a single server could handle many different types of robots, each with its own specific job and its own version of the brain. Some robots might be packing boxes, while others are assembling car parts. Robion allows these different robot brains to live on the same server, sharing the same computing lanes. The system acts as a smart dispatcher, constantly checking which robot is closest to missing its safety deadline. If a robot is about to run out of time to finish its task, the system immediately prioritizes its request, ensuring that the most urgent jobs get done first. This prevents the factory from grinding to a halt because one robot is waiting too long for an answer.

The team tested this system in a simulated factory environment with up to four powerful graphics cards, which are the engines that drive these AI models. They compared Robion against existing methods that either run the robot brain as a single, unbroken chain of events or split the steps across different computers. The results showed that Robion could support significantly more robots than the other methods while still meeting the strict timing requirements. In one large-scale test, a single server running Robion successfully managed eight different robot models, serving up to 64 robots simultaneously with a success rate of 98 percent. This means that for nearly every single request, the robot received its answer in time to keep moving safely.

The study also explored whether it was better to put the different parts of the robot brain on separate computers or keep them together. They found that splitting the thinking and movement stages across different computers actually made things slower and less efficient because the data had to travel back and forth, wasting precious time. By keeping everything on one powerful server and managing the internal traffic carefully, Robion achieved much better performance. The researchers also looked at the cost, noting that using a single powerful server to run many robots is far cheaper than trying to put expensive, high-performance computers on every single robot. This approach could make advanced, autonomous factories a practical reality for major companies, allowing them to deploy fleets of intelligent robots that work together efficiently without overwhelming their computing resources.

Ultimately, Robion demonstrates that the key to running a factory of intelligent robots is not just having powerful computers, but having a system that can manage them with extreme precision. By understanding the unique, split-second nature of robot decision-making and designing a server that respects those tight deadlines, the researchers have created a blueprint for how to scale up physical artificial intelligence. The system ensures that as factories grow larger and more complex, the robots can continue to see, think, and act in real time, keeping the production lines moving smoothly and safely.

Technical Summary: Efficient Vision-Language-Action Management and Serving for Robot Factories

Problem Statement

Vision-Language-Action (VLA) models are becoming the foundation for physical AI in robot factories, enabling robots to perceive environments, reason about tasks, and execute manipulation actions. However, VLA inference is inherently latency-critical; missing strict Service-Level Objectives (SLOs) can lead to task failures, unsafe navigation, or assembly line halts.

Deploying VLA models presents a fundamental conflict:

Latency Requirements: Meeting safety and task deadlines requires high-end GPUs (e.g., RTX 6000 Pro, H100), which offer significantly lower inference latency than embedded on-robot GPUs (e.g., Jetson AGX Thor).
Hardware Constraints: High-end GPUs cannot be integrated directly onto robots due to weight, cost, power, and thermal limitations. On-robot inference with embedded GPUs also drastically reduces battery life (up to 45%).
Current Solutions: The prevailing approach is offloading inference to local edge servers. However, existing serving systems are ill-suited for this scenario:
- Throughput vs. Latency: Existing multi-stage serving systems (e.g., vLLM-Omni) are optimized for throughput and large-scale models with stages running for hundreds of milliseconds. They rely on inter-process communication and buffer inspection, which incurs overheads that dominate the millisecond-scale execution time of VLA stages.
- Resource Underutilization: VLA architectures consist of two distinct stages: a compute-intensive Vision-Language Model (VLM) and a memory-intensive Action Diffusion Transformer (ADiT). Disaggregating these stages onto separate GPUs leaves significant compute resources underutilized, particularly for the memory-bound ADiT stage.
- Single-Model Focus: Current systems generally do not support the concurrent execution of multiple VLA models (including fine-tuned variants) on a single GPU while adhering to per-request SLOs.

Methodology: Robion

The authors propose Robion, the first VLA serving and management system designed for multi-robot, multi-model requests on multi-GPU edge servers that strictly adheres to SLOs. Robion consists of a Serving Engine and a Management Engine.

1. Robion Serving Engine

The serving engine focuses on maximizing GPU utilization and minimizing latency through three core techniques:

Fixed-Batch Intra-GPU Stage Disaggregation:
- Instead of separating stages across different GPUs or processes, Robion disaggregates the VLM and ADiT stages within a single GPU using two asynchronous CUDA streams.
- It employs fixed-size batching rather than continuous batching. Requests are admitted only at the start of a stage execution. This eliminates the per-diffusion-step buffer inspection overhead found in systems like vLLM-Omni, which is prohibitively expensive for VLA's millisecond-scale steps.
- CUDA Graphs are used to eliminate CPU launch overheads for repeated kernel executions.
Guarded & Dynamic Spatial SM Partitioning on Locksteps:
- To ensure the memory-intensive ADiT stage does not starve while the compute-intensive VLM stage saturates the GPU's Streaming Multiprocessors (SMs), Robion enforces lockstep execution. In each lockstep, exactly one VLM batch and one ADiT batch run concurrently.
- Dynamic SM Restriction: The system restricts the number of SMs the VLM stream can occupy, guaranteeing that sufficient SMs remain available for the ADiT stream.
- Profiling-Assisted Selection: Since the optimal SM split depends on the specific batch sizes of the co-running stages, Robion performs offline profiling during initialization. It exhaustively searches SM restrictions for all power-of-2 batch size combinations and stores the optimal configuration in a lookup table. At runtime, the system applies the pre-computed restriction without preemption, ensuring no execution progress is lost.
SLO-Aware Dual-Stream Multi-Model Serving:
- Robion supports model co-location, sharing the same VLM and ADiT streams across multiple VLA models (including fine-tuned variants) on a single GPU.
- It implements an Earliest-SLO-First (ESF) scheduling policy. At the start of each lockstep, the system calculates the remaining time until the SLO deadline for the head request of each model's queue and prioritizes the request with the least remaining time. This ensures strict adherence to SLOs across heterogeneous robot populations.

2. Robion Management Engine

The management engine handles the placement of models and the distribution of robot traffic across a multi-GPU server.

Flexible Model Placement: Programmers can configure how models are placed: co-locating different architectures on one GPU, replicating models across GPUs, or partitioning GPUs into disjoint groups dedicated to specific model architectures.
Adaptive Traffic Controller:
- The system formulates robot-to-GPU assignment as an integer programming problem.
- Objective: Maximize per-model batching (by concentrating requests for a specific model onto a single GPU) while respecting the maximum robot load each GPU can sustain without violating SLOs.
- Constraints: The total robots assigned to a model must match the factory's demand, and the sum of normalized loads on any GPU must not exceed 1.0.
- This approach avoids the pitfalls of "even splitting" (which reduces batching efficiency) and "single-model-per-GPU" (which can lead to overload if one model has a high robot count).

Key Results

The authors evaluated Robion on four VLA models ( $\pi_0$ , SmolVLA, GR00T N1.5, Xiaomi-Robotics-0) across two hardware platforms (4x RTX 6000 Pro and 4x H100) and compared it against a Monolithic baseline and vLLM-Omni.

Single-Model Performance:
- Robion serves 6.7× more robot load than vLLM-Omni and 1.5× more than the Monolithic system while maintaining 98% SLO attainment.
- A single high-end GPU running Robion can serve an average of 20 robots with 98% SLO attainment, outperforming on-robot inference on embedded GPUs and offering significant cost reductions (approx. 6.8×) compared to equipping every robot with a high-end SoC.
- The "Guarded SM Partitioning" technique alone improved SLO attainment significantly over simple stage disaggregation, proving the necessity of dynamic SM restriction.
Multi-Model Co-Location:
- When co-locating multiple models (including variants and different architectures) on a single GPU, Robion achieved 2.1× lower SLO miss ratios compared to the Monolithic approach.
- vLLM-Omni remained fully saturated (100% miss ratio) in these multi-model scenarios.
- The ESF queue selection policy proved robust, outperforming Round-Robin and Largest-Queue-First policies, especially when models had varying SLO deadlines.
Multi-GPU Scaling:
- In a large-scale experiment serving 8 different models on a 4-GPU server, Robion successfully served up to 64 robots within 98% SLO attainment.
- Robion's intra-GPU disaggregation significantly outperformed inter-GPU disaggregation schemes (which dedicate separate GPUs to VLM or ADiT), as the latter leads to severe underutilization of the memory-bound ADiT stage.
Cloud vs. Edge:
- The study confirms that edge deployment (local servers with WiFi 7) is superior to cloud deployment due to network latency, which significantly degrades SLO attainment in cloud scenarios.

Significance and Claims

The paper claims to be the first work to:

Investigate the specific design considerations for efficient VLA serving in robot factories, highlighting the mismatch between existing multi-stage serving systems and the millisecond-scale, latency-critical nature of VLA inference.
Propose Robion, a system that enables SLO-aware, multi-model serving on multi-GPU edge servers.

The authors emphasize that Robion bridges the gap between the high computational demands of VLA models and the strict constraints of robot factories. By enabling high-end GPUs to serve many robots concurrently with strict latency guarantees, Robion makes the deployment of local edge servers for robot factories a practical and cost-effective reality. The system demonstrates that with proper stage disaggregation, dynamic resource partitioning, and intelligent traffic control, a single edge server can replace the need for high-end compute on every individual robot, significantly lowering the barrier to entry for large-scale physical AI deployments.