VPA for robot arms

A robot-arm controller that skips word-by-word decoding: a neuro-symbolic milestone planner picks the next step and a flow-matching solver writes the whole motion toward it.

Status: Research prototype tested in simulation. The paper, code and trained weights are public; tests on a real robot arm are planned for the first half of 2027.

Why robot arms hesitate, and what VPA changes

The bottleneck in today's robot models

  • Most robot foundation models (vision-language-action models, VLAs) reuse a large language model and emit movement coordinates one token at a time, like writing a sentence word by word.
  • Every extra token is another full pass through a billion-parameter decoder, so latency grows with the length of the motion.
  • That means control loops of only a few hertz: the arm pauses mid-motion, overshoots and drops objects.

What VPA does instead

  • No token loop. VPA removes the autoregressive decoder and controls the robot in a compact latent space.
  • Milestones plus a motion solver. A neuro-symbolic planner sets the next visual milestone; a flow-matching solver computes the whole continuous motion toward it.
  • Constant cost. Each decision is a fixed K + 3 network evaluations, however long the motion chunk is.

Two stages: the planner sets the milestone, the solver moves

Stage 1: visual milestone planner

A shared vision encoder reads the camera frames and goal image, and a frozen CLIP text encoder reads the instruction. A neuro-symbolic skill selector then applies discrete, rule-like logic to decide which skill comes next, for example “reach above handle”, then “grasp handle”.

A JEPA predictor forecasts what the scene should look like when that milestone is reached. A milestone only advances once the robot's latent state crosses a threshold, which keeps small errors from piling up across task phases.

Stage 2: flow-matching motion solver

Given the predicted milestone, a flow-matching solver integrates a learned velocity field for a fixed number of steps (K) and outputs the entire continuous arm-and-gripper trajectory chunk at once, not one coordinate at a time.

Because the motion is solved as a smooth curve, the arm moves fluidly toward the milestone while the planner is already working on the next one.

VPA control loop Camera frames and the instruction are encoded, a neuro-symbolic selector picks the next skill, a JEPA predictor forecasts the next latent milestone, a flow-matching solver produces a full action chunk in K steps, and the robot executes it before the loop repeats. Stage 1: milestone planner Stage 2: motion solver Camera frames + goal image and instruction Encoders vision + frozen CLIP text Neuro-symbolic skill selector “grasp handle” JEPA predictor next latent milestone (sub-goal threshold) Flow-matching solver fixed K integration steps Full action chunk continuous arm + gripper Robot executes no pause between chunks new observation Cost per decision: K + 3 network evaluations, independent of chunk length or instruction length.

Key takeaway: latency no longer depends on token count or sentence length. Every decision costs the same fixed amount of compute, so the robot gets a fresh, smooth trajectory every 10–14 ms instead of waiting for a language model to finish “speaking”.

Measured results

Time per decision
10–14 msAbout 70–100 decisions per second. Latency benchmark on an Apple M4 chip (single-camera configuration).
LIBERO-10 success rate
40.0%Two-camera policy, 80 of 200 episodes (95% CI 33.5–46.9%). One camera: 10.5%. Preliminary: one training run per setting.
Trainable parameters
Under 20 millionCheckpoint under 75 MB. Trained in under 3 hours on a single GPU.
Network calls per decision
K + 3Five calls with the default K = 2 solver steps, whatever the length of the action chunk.
Openness
Fully publicPaper, code and weights (PyTorch and safetensors, GPL-3.0).

Sources: “Vision-Predictor-Action: Towards Efficient Embodied AI via Neuro-Symbolic JEPA Predictors” (Zenodo, arXiv:2610.15556, October 2026) and the LIBERO-10 model card. Every number can be rerun with the open-source code.

VPA in action: rollouts from the LIBERO-10 benchmark

Put both moka pots on the stove
Pick up the book and place it in the back compartment of the caddy
Put both the alphabet soup and the cream cheese box in the basket

Two-camera VPA policy in the LIBERO simulator, played at 2× speed. Left: room camera; right: wrist camera. More rollouts and per-task results on GitHub.

How customers use it

On-site software

Customers
Factories, logistics centers and drone operators
Price
20% of the labor cost the software saves
Sales path
Paid proof of concept (PoC), then an annual subscription

Technology licensing

Customers
Robot, drone and chip makers
Price
Royalty per unit shipped
Sales path
The free open release builds adoption; products sold with VPA inside need a paid license

Research and intellectual property

Commercial use inside a proprietary product needs a license from SLING AI.

Contact us about licensing