Lite VLA: Efficient Vision-Language-Action Systems

• Lite VLA refers to resource-efficient vision-language-action systems that maintain core multimodal perception and control while reducing computational and memory demands.
• The approach leverages techniques like quantization, distillation, modular retrofitting, and token sparsification to optimize performance on edge devices.
• Deployments such as the CPU-bound TurtleBot 4 system demonstrate on-device action control under strict hardware constraints for autonomous tasks.

Searching arXiv for papers on Lite VLA and closely related efficient VLA deployment work. Lite VLA denotes a line of work on resource-efficient Vision-Language-Action systems that preserves multimodal perception, language conditioning, and action generation while reducing the computational, memory, and deployment burdens that characterize large VLA models. In the most specific sense, the term names the CPU-bound mobile-robot system “Lite VLA: Efficient Vision-Language-Action Control on CPU-Bound Edge Robots” (Williams et al., 7 Nov 2025), which demonstrates fully on-device multimodal control on a Raspberry Pi 4–powered TurtleBot 4. In a broader research sense, “Lite VLA” also refers to a family of techniques for compression, modularization, distillation, quantization, sparse token processing, and deployment-oriented system design that make VLA-style behavior feasible on constrained hardware, embedded robots, or latency-sensitive driving stacks (Gu et al., 9 Apr 2026, Jülg et al., 16 Jan 2026, Argus et al., 2 Jul 2025, Williams et al., 3 Mar 2026, Luo et al., 20 Feb 2026, Zhang et al., 21 Jan 2026, Wang et al., 26 Mar 2026).

1. Definition and scope

Lite VLA is defined by an efficiency objective rather than by a single architecture. Across the literature, the common aim is to retain the functional core of VLA systems—joint visual grounding, language-conditioned reasoning, and action selection—while avoiding the deployment profile of multi-billion-parameter models such as PaLM-E, RT-2, and OpenVLA when those models are too large, too compute-heavy, or too dependent on GPUs or cloud inference for practical edge use (Williams et al., 7 Nov 2025, Williams et al., 3 Mar 2026).

The mobile-robot system explicitly titled “Lite VLA” is a CPU-only, on-device VLA system for mobile robots that runs locally inside a ROS 2 control loop on a Raspberry Pi 4–powered TurtleBot 4 (Williams et al., 7 Nov 2025). Its central idea is to adapt a compact vision-LLM so that RGB camera frames are mapped to robot motion commands without cloud connectivity. The paper frames the problem not merely as model miniaturization, but as enabling local intelligence that can perceive the environment, interpret it semantically, decide on an action, and execute it without network dependence (Williams et al., 7 Nov 2025).

Related work expands this scope. “Orion-Lite” studies whether the reasoning utility of a 7B-parameter VLA driving teacher can be compressed into a compact vision-only planner (Gu et al., 9 Apr 2026). “cVLA” targets efficient robotic manipulation by predicting trajectory keyposes in camera/image space rather than dense low-level controls (Argus et al., 2 Jul 2025). “LiteVLA-Edge” focuses on fully on-device multimodal control on Jetson Orin-class hardware through post-training 4-bit GGUF quantization and GPU-accelerated llama.cpp inference (Williams et al., 3 Mar 2026). “VLAgents” treats efficiency as a policy-server and communication problem, arguing that lightweight VLA deployment requires a standardized inference layer with low communication overhead (Jülg et al., 16 Jan 2026). “SimVLA” presents a deliberately minimal baseline that decouples perception from control and uses a lightweight action head (Luo et al., 20 Feb 2026). “CompliantVLA-adaptor” shows a lightweight, plug-and-play safety layer for existing VLA models rather than a new end-to-end VLA backbone (Zhang et al., 21 Jan 2026). “ETA-VLA” addresses token bloat and quadratic self-attention in autonomous driving VLA pipelines by combining temporal compression with intra-LLM token sparsification (Wang et al., 26 Mar 2026).

This suggests that Lite VLA is best understood as a deployment-oriented research program organized around compactness, modularity, and selective computation rather than around a single canonical model.

2. Architectural patterns in lightweight VLA systems

A recurring design pattern is replacement of heavyweight multimodal reasoning modules with smaller or more specialized components. In Orion-Lite, ORION’s map-free VLA pipeline uses multi-view camera frames processed by an EVA-02-L vision encoder, a QT-Former for scene/history embeddings, and a Vicuna-v1.5 LLM that produces latent planning tokens for a VAE-based generative planner. Orion-Lite freezes the vision encoder and QT-Former, discards text prompts entirely, and replaces the 7B LLM with a lightweight 6-layer transformer decoder that cross-attends over compressed visual/context tokens and produces a latent planning representation aligned to the teacher’s output space (Gu et al., 9 Apr 2026). The result is a vision-only student that imitates latent reasoning rather than executing explicit LLM inference during deployment.

A second pattern is simplification of the action representation. cVLA fine-tunes PaliGemma2 to predict trajectory keyposes in camera/image space using a one-step next-token prediction formulation rather than long-horizon autoregressive low-level control (Argus et al., 2 Jul 2025). Its prompt structure is

$$\texttt{<live img(s)> + <robot state> + <task description>} \rightarrow \texttt{<estimated trajectory>}$$

and the output consists of two waypoint-like end-effector keyposes, later converted into executable motion by a classical planner and inverse kinematics (Argus et al., 2 Jul 2025). This reduces both training cost and embodiment dependence because the model predicts where to act in the camera view rather than robot-specific control deltas.

A third pattern is strict decoupling of perception and control. SimVLA adopts a standard VLM backbone purely as a perception-language encoder and a lightweight action head as the sole continuous-control generator (Luo et al., 20 Feb 2026). The observation is

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$

and the policy predicts an action chunk

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$

The fused multimodal tokens

$Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$

are passed to a vanilla Transformer encoder action head with pure self-attention, no cross-attention, no memory module, and no modality-specific routing (Luo et al., 20 Feb 2026). The paper’s claim is that a minimal “VLM encoder + action head” design can be highly competitive if the training recipe is standardized carefully.

A fourth pattern is modular retrofitting rather than end-to-end redesign. CompliantVLA-adaptor leaves the underlying VLA action generator intact and inserts a VLM-guided variable impedance controller between the VLA output and the low-level controller (Zhang et al., 21 Jan 2026). The base VLA remains

$$\pi_\text{VLA} : \mathcal{S} \times \mathcal{T} \rightarrow \mathcal{A},$$

while the adaptor computes impedance parameters through

$$\text{VLM}(\mathcal{S} \times \mathcal{T} \times \mathcal{F}) \rightarrow (\mathcal{K}, \mathcal{D}).$$

This makes safety and compliance a plug-in property rather than a retrained backbone capability (Zhang et al., 21 Jan 2026).

The CPU-bound LiteVLA mobile-robot system adopts yet another simplification: the robot captures an RGB frame, feeds it to a compact VLM/VLA model, receives a structured action string such as forward_0.2_3.0s or turn_left_0.1_2.5s, parses that string into geometry_msgs/Twist, and publishes it to the mobile base (Williams et al., 7 Nov 2025). The action abstraction is therefore a short-duration motor primitive rather than continuous torque or joint-space control.

3. Efficiency mechanisms

The Lite VLA literature relies on multiple orthogonal mechanisms for reducing inference cost.

One mechanism is quantization. LiteVLA-Edge fine-tunes in FP32 with LoRA and then applies post-training 4-bit GGUF quantization, specifically Q4_K_M, before inference through llama.cpp with CUDA backend and full GPU offload of all 42 transformer layers (Williams et al., 3 Mar 2026). The CPU-bound LiteVLA system uses GGUF/NF4 quantized model formats and reports approximately 75% lower memory usage from quantization, while also noting that fully NF4-quantized LiteVLA can produce unstable or hallucinated outputs, so a hybrid precision scheme that keeps the projection head in FP32 is more stable (Williams et al., 7 Nov 2025). This suggests that aggressive quantization is a central deployment tool but can interfere with action fidelity if sensitive components are compressed indiscriminately.

Another mechanism is distillation. Orion-Lite uses latent feature distillation from ORION’s latent planning tokens $T_p$ to the student output $T_{student}$ with an $\mathcal{L}_1$ objective,

$$\mathcal{L}_{mimic} = \frac{1}{B \cdot C_p} \sum_{b=1}^{B} \left\| T_{student}^{(b)} - T_{p}^{(b)} \right\|_1,$$

combined with ground-truth trajectory supervision

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$0

where $O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$1, and

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$2

The student is therefore not merely compressed; it is trained to reproduce teacher latent reasoning while staying anchored to true trajectories (Gu et al., 9 Apr 2026).

A third mechanism is token compression and sparsification. ETA-VLA compresses historical multi-view image features before the LLM through a Temporal Fusion Module and prunes tokens inside selected LLM layers through an Intra-LLM Sparse Aggregator (Wang et al., 26 Mar 2026). Temporal fusion uses learnable time embeddings and weighted aggregation,

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$3

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$4

ILSA performs text-guided scoring, RoPE-free semantic scoring,

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$5

and diversity-preserving recycling so that pruned tokens retain multi-view coverage (Wang et al., 26 Mar 2026).

A fourth mechanism is compact action generation. SimVLA models the policy through flow matching rather than discrete action tokenization. With normalized action chunk $O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$6, noise $O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$7, and interpolation

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$8

the loss is

$O_t = [I_t^1, \dots, I_t^n, l_t, S_t],$9

Inference then integrates the learned vector field using a small number of Euler steps (Luo et al., 20 Feb 2026). This is efficient in a different sense from quantization or pruning: it avoids long autoregressive action decoding.

A fifth mechanism is communication-aware infrastructure. VLAgents abstracts VLA inferencing behind a Gymnasium-style protocol, $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$8 with structured observation and action types and a transport layer that uses zero-copy shared memory on the same host and JPEG-compressed TCP/RPyC transport across machines (Jülg et al., 16 Jan 2026). Here efficiency is realized at the systems boundary rather than solely inside the model.

4. The CPU-bound LiteVLA system for mobile robots

The system specifically titled “Lite VLA” (Williams et al., 7 Nov 2025) is a CPU-only, on-device VLA architecture designed for low-power mobile robots. It targets scenarios in which field robots require local intelligence for disaster response, underground environments, GPS-denied settings, defense operations, and low-cost educational platforms, and where cloud connectivity or GPU inference is unavailable (Williams et al., 7 Nov 2025).

Its hardware platform is a TurtleBot 4 running on a Raspberry Pi 4 with 4 GB RAM and a quad-core ARM Cortex-A72 CPU at 1.5 GHz, with no GPU or NPU acceleration (Williams et al., 7 Nov 2025). The model backbone is SmolVLM, described as a compact multimodal transformer family spanning roughly 256M to 2.2B parameters, with the smallest variant reported to fit in less than 1 GB of memory during inference (Williams et al., 7 Nov 2025). The image pipeline resizes frames to 224 × 224, normalizes them using

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$0

and applies augmentation such as random horizontal flips (Williams et al., 7 Nov 2025). SmolVLM uses pixel-shuffle tokenization to reduce the number of visual tokens while preserving spatial information (Williams et al., 7 Nov 2025).

Model adaptation uses LoRA with rank $$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$1, scaling $$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$2, and dropout $$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$3, inserted into query, key, value, output, and gating modules (Williams et al., 7 Nov 2025). The training objective is given as

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$4

The training data come from teleoperation trajectories

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$5

with synchronized timestamps,

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$6

The paper reports 15,083 image-action pairs in the main dataset, more than 60,000 frames collected in total, about 13,000 images used in initial experiments, and an 85:15 training/validation split (Williams et al., 7 Nov 2025).

A notable systems decision is asynchronous action chunking. The VLA reasoning loop is much slower than normal robot control, so the model outputs higher-level motion chunks, and the low-level ROS 2 controller continues executing the current chunk while the next inference runs (Williams et al., 7 Nov 2025). This is the paper’s solution to the mismatch between CPU-only multimodal inference and mobile-base control requirements.

5. Training objectives and data regimes

Lite VLA systems are unusually heterogeneous in their supervision strategies. The CPU-bound mobile LiteVLA uses teleoperation RGB-action pairs and fine-tunes a compact multimodal model to predict structured action commands (Williams et al., 7 Nov 2025). cVLA frames manipulation as next-token prediction over discretized pose tokens, with the implied objective

$$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$7

where $$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$8 contains image inputs, robot state, and task text, and $$A_t = [a_t, a_{t+1}, \dots, a_{t+H-1}] \in \mathbb{R}^{H \times d_a}.$$9 denotes pose/action tokens (Argus et al., 2 Jul 2025). The two-waypoint design is later expanded to a demonstration-conditioned setting of the form

$Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$0

and in the appendix,

$Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$1

with 16k iterations of fine-tuning for the demonstration-conditioned extension (Argus et al., 2 Jul 2025).

Orion-Lite is trained through the sum of latent distillation and trajectory-level ground-truth supervision, and its ablations show that training with only GT gives 73.9 DS, mimic-only gives 76.0 DS, and the combined objective yields 80.6 DS (Gu et al., 9 Apr 2026). This is significant because it indicates that the compressed student benefits from both imitation of the teacher’s latent planning space and direct physical supervision.

SimVLA standardizes what it calls “silent” but decisive training details: normalized continuous action space, shuffled data, learning-rate multipliers for the VLM backbone, and horizon length as a major hyperparameter (Luo et al., 20 Feb 2026). For LIBERO, the appendix reports AdamW, betas $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$2, no weight decay, learning rate $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$3, VLM LR multiplier $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$4, batch size $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$5, and training steps around 150K (Luo et al., 20 Feb 2026). The paper argues that poor shuffling, missing normalization, or inappropriate VLM learning-rate multipliers can cause near-collapse or drastic performance loss (Luo et al., 20 Feb 2026).

This suggests that Lite VLA research does not only reduce model size; it also restructures supervision so that smaller models can learn action-relevant abstractions more directly and with fewer parameters.

6. Empirical performance and deployment trade-offs

The main mobile LiteVLA paper emphasizes feasibility under extreme hardware constraints more than benchmark success rate. It reports on-device inference latency of approximately ~11.11 s per query for the SmolVLM-256 baseline, equivalent to 0.09 Hz, ~18 min for FP32 LiteVLA, ~2 min for hybrid precision LiteVLA, and ~1.5 min for fully NF4-quantized LiteVLA (Williams et al., 7 Nov 2025). Quantization yields approximately ~75% lower memory usage, and the hybrid precision version gives up to 9× faster inference than the FP32 LiteVLA baseline, while hybrid precision preserves stable action predictions better than full NF4 quantization (Williams et al., 7 Nov 2025). The paper is explicit that this is not tight real-time control in the classical sense; rather, asynchronous action chunking makes the control pipeline usable despite slow reasoning (Williams et al., 7 Nov 2025).

Other Lite VLA works report stronger performance under less restrictive hardware assumptions.

System	Main efficiency result	Main task result
Orion-Lite (Gu et al., 9 Apr 2026)	reasoning module about 150× faster; overall system about 3× faster; GPU memory from 31 GB to 8 GB	Driving Score 80.6; Success Rate 55.5
VLAgents (Jülg et al., 16 Jan 2026)	about 3× faster than other policy servers; up to 220 Hz in network deployment; 0.3 ms delay in simulation	communication benchmark isolates transport overhead
LiteVLA-Edge (Williams et al., 3 Mar 2026)	mean end-to-end latency 150.5 ms; approximately 6.6 Hz; fully offline on-device	timing feasibility for reactive language-conditioned control
SimVLA (Luo et al., 20 Feb 2026)	0.5B parameters; peak VRAM 9.3 GB	LIBERO average 98.6
ETA-VLA (Wang et al., 26 Mar 2026)	about 32% overall FLOP saving; 85% visual tokens pruned; 61% inference FLOPs reduced	EPDMS 85.0 on Navtest

Orion-Lite reports a Driving Score of 80.6 and Success Rate of 55.5 on Bench2Drive, compared with ORION’s 77.7 DS and 54.6 SR, and improves the mean multi-ability score to 60.5 from the teacher’s 54.7 (Gu et al., 9 Apr 2026). The student reasoning module is about 150× faster than the teacher’s LLM, the overall system is about 3× faster end-to-end, and GPU memory drops from 31 GB to 8 GB (Gu et al., 9 Apr 2026).

VLAgents benchmarks mean round-trip time with two $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$6 RGB cameras and no model inference, isolating communication overhead. It reports best performance in both local and network settings, up to 220 Hz inference speed in the network deployment, only 0.3 ms delay for simulated evaluations, and performance about 3× faster than other commonly used policy servers (Jülg et al., 16 Jan 2026).

LiteVLA-Edge reports a mean end-to-end latency of 150.5 ms, approximately 6.6 Hz, more precisely 6.64 Hz, with minimum latency 150.4 ms, maximum latency 151.0 ms, and standard deviation about 0.13 ms, also described as $Z_t = E_p(I_t^1, \dots, I_t^n, l_t)$7 ms (Williams et al., 3 Mar 2026). Its results are framed as a systems and deployment contribution rather than a new policy-learning objective (Williams et al., 3 Mar 2026).

SimVLA reports 0.5B parameters and peak VRAM of 9.3 GB, outperforming or matching much larger systems on several benchmarks, including LIBERO average 98.6, WidowX average 95.8%, and Google Robot 76.1% average (Luo et al., 20 Feb 2026). ETA-VLA reports EPDMS 85.0 on Navtest and 48.0 on Navhard while pruning 85% of visual tokens and reducing inference FLOPs by 61%, retaining 94% of original accuracy in the abstract’s summary (Wang et al., 26 Mar 2026).

A plausible implication is that “Lite VLA” spans two distinct performance regimes. In one regime, exemplified by the Raspberry Pi 4 mobile system, feasibility on extremely constrained hardware is the principal achievement (Williams et al., 7 Nov 2025). In the other regime, exemplified by Orion-Lite, SimVLA, and ETA-VLA, efficiency improvements are large enough that compact or sparse systems can meet or exceed strong baselines on standard benchmarks (Gu et al., 9 Apr 2026, Luo et al., 20 Feb 2026, Wang et al., 26 Mar 2026).

7. Limitations, misconceptions, and research directions

A common misconception is that Lite VLA necessarily means a weaker or purely stripped-down model. Several papers contradict that interpretation. Orion-Lite surpasses its 7B VLA teacher on Bench2Drive closed-loop evaluation (Gu et al., 9 Apr 2026). SimVLA, despite having only 0.5B parameters, outperforms multi-billion-parameter models on standard simulation benchmarks and reaches on-par real-robot performance compared to pi0.5 (Luo et al., 20 Feb 2026). ETA-VLA slightly improves EPDMS at an intermediate pruning setting while reducing GFLOPs (Wang et al., 26 Mar 2026). In these cases, efficiency is not merely a deployment concession; it can also expose better inductive structure or training discipline.

A second misconception is that Lite VLA is only a matter of model compression. The literature shows at least four distinct loci of efficiency: model architecture, inference-time sparsification, systems middleware, and low-level control integration. VLAgents improves VLA deployment without changing model weights at all (Jülg et al., 16 Jan 2026). CompliantVLA-adaptor adds safe contact handling without retraining the base VLA (Zhang et al., 21 Jan 2026). LiteVLA-Edge combines post-training quantization, llama.cpp, and ROS 2 integration into a reproducible embedded deployment path rather than proposing a new policy objective (Williams et al., 3 Mar 2026).

The limitations are equally consistent. The CPU-bound LiteVLA system is explicit about very high latency, thermal throttling, memory bandwidth constraints, and unstable action predictions under aggressive quantization (Williams et al., 7 Nov 2025). LiteVLA-Edge notes that current results are focused on latency and deployability rather than broad task benchmark superiority, and that task-level evaluation is still needed (Williams et al., 3 Mar 2026). CompliantVLA-adaptor notes that VLM latency is too high for high-frequency control, API usage is expensive and not eco-friendly, and real-world success remains limited by the underlying VLA maturity (Zhang et al., 21 Jan 2026). ETA-VLA shows that stronger pruning eventually harms planning quality, with 85% pruning at layer 4 lowering EPDMS from 84.8 to 80.5 in the ablation table (Wang et al., 26 Mar 2026).

Several future directions recur across the literature. One is better compression of latent reasoning, as in Orion-Lite’s result that much of the teacher’s useful signal can be distilled into a lightweight vision-only decoder (Gu et al., 9 Apr 2026). Another is embodiment-agnostic action representation, as in cVLA’s camera-space waypoints (Argus et al., 2 Jul 2025). A third is tighter embedded deployment pipelines, including post-training quantization and portable runtimes such as llama.cpp (Williams et al., 3 Mar 2026). A fourth is selective-computation VLA, where temporal fusion, token scoring, and sparsification determine where compute is actually spent (Wang et al., 26 Mar 2026). A fifth is safe modular augmentation, exemplified by variable impedance adaptors layered on top of existing position-outputting VLA backbones (Zhang et al., 21 Jan 2026).

Taken together, Lite VLA designates a shift in VLA research from scaling alone toward compute allocation, deployment realism, and modular control. The field’s central question is no longer only whether vision-language-action models can solve robotic or driving tasks, but how much of that capability can be preserved—or in some cases improved—when the model must run locally, sparsely, or within strict communication and control constraints.