Asynchronous Robot Policies

ARP-3B (ours)

π0.5-DROID

“Put the vegetables in the bowl.” The first trial of each policy, uncut, at 4× speed. The clock shows real time. ARP finished in 67 s. π0.5-DROID had placed 1 of 5 vegetables when the episode limit was reached at 82 s. ARP's lead was largest on this task, and π0.5-DROID did better on cup stacking. All 60 trials are in the real-robot section.

TL;DR: We run the large vision-language model and the small action network of a robot policy as two separate processes. The robot reacts to every new camera frame without waiting for the large model, and the large model only needs to update now and then.

Abstract

Vision-language-action models (VLAs) control robots by running a vision-language model (VLM) and an action expert one after the other for every chunk of actions. The time from observation to action therefore grows with the size of the VLM, which matters whenever the scene changes while the robot is moving. We propose Asynchronous Robot Policies (ARP), which run the two parts as independent processes at different rates. The VLM periodically writes a fixed-size semantic memory. A lightweight vision-action expert with its own camera input reads the most recent memory and produces actions at a high rate. Because that memory is always somewhat out of date, we train the expert on memories of varying age and condition it on that age and on its own execution delay. In simulation, when the target object is moved during the reach, ARP-1B succeeds in 51.5% of episodes against 9.5% for a π0-style baseline with the same backbone. On LIBERO it keeps 79.0% success with the VLM refreshed only once every 4 seconds, where the baseline drops to 45.3%. On a Franka robot, a DROID-trained ARP-3B reaches 78, 73 and 80% task progress on three tasks, against 32, 80 and 50% for π0.5-DROID. On the broader RoboLab benchmark it remains well behind π0.5-DROID (20.0 vs 37.9%).

Big models, slow reflexes

Most general-purpose robot policies today are built on vision-language models, the kind of neural network that can describe an image or answer questions about it. A vision-language-action model (VLA), such as π0 or π0.5, adds an action expert: a smaller network that turns the VLM's understanding of the scene and the instruction into motor commands. At every step the robot takes a picture, runs the VLM, runs the action expert, and executes a short chunk of motions before repeating.

This loop works when nothing moves. A plan made half a second ago is still a good plan if the cup is where it was. It breaks down when the world changes during the motion, for example when an object gets nudged or a ball rolls. The robot keeps executing a plan based on an old picture, and the next plan has to wait for the VLM again. A larger VLM understands more, and it also makes this wait longer.

Left: a VLA runs the VLM and the action expert in sequence at one rate. Right: ARP runs the VLM at a low rate f1 and the vision-action expert at a high rate f2, reading every camera frame. — **Left:** a VLA runs the VLM and the action expert in sequence, so the delay from a new image to an action is t_VLM + t_AE. **Right:** ARP runs them in separate loops at rates f₁ and f₂. The action expert reads every new image itself, so the loop that reacts to the scene only contains the small network.

Two processes, two speeds

ARP splits the policy into two processes that never wait for each other. The large VLM, which we call the semantic expert, looks at the camera image and the instruction from time to time and writes what it has understood into a memory of fixed size. A much smaller vision-action expert runs continuously. Each time it is called, it looks at the current camera images, reads whichever memory is newest, and outputs the next actions.

The fast loop never runs the VLM, so the robot's reaction time no longer depends on how big the VLM is. On one RTX A6000 GPU, a VLM call takes 64 ms at 1B parameters and 120 ms at 8B, while the action expert takes about 61 ms at every size:

VLM size	Language model	Large model (VLM)	Action expert	Both in sequence
1B	Qwen3-0.6B	64 ms	60 ms	124 ms
2B	Qwen3-1.7B	64 ms	62 ms	126 ms
4B	Qwen3-4B	87 ms	61 ms	148 ms
8B	Qwen3-8B	120 ms	61 ms	181 ms

Simulation models, median of 100 calls, bf16, batch size 1. The last column is the delay per action chunk of a VLA built from the same two parts.

The two loops over two seconds (ARP-1B in simulation, VLM refreshed once per second). Every 4 control steps the action expert takes the newest camera frames and the newest finished memory. The age of that memory, between 4 and 20 steps here, is one of the expert's inputs.

The catch: the memory is always out of date

Running the two processes independently has a price. The memory the action expert reads was computed from an older image, sometimes a fifth of a second old and sometimes several seconds. A model that only saw fresh memories during training does not cope with that.

We deal with this in training. Each training example pairs the current camera frames of a demonstration with a memory computed from an earlier frame of the same demonstration, up to 2 s earlier, and the action expert is told how old the memory is. The table shows what this does. Every row is the same architecture trained on the same LIBERO data. Only the memory ages seen in training differ. The columns are how often the VLM refreshes the memory at test time.

Memory age seen in training	fresh	5 Hz	2.5 Hz	1 Hz	0.5 Hz	0.25 Hz
always fresh (d = 0)	81.8	63.0	23.5	4.8	2.0	–
up to 0.4 s (d ≤ 8 steps)	79.5	81.5	56.8	11.8	5.0	–
up to 2 s (d ≤ 40, default)	85.3	83.3	84.8	82.0	81.8	79.0
up to 4 s (d ≤ 80)	81.0	84.5	87.5	87.5	86.5	84.0

Success rate (%), 400 LIBERO episodes per cell. Trained only on fresh memories, the model does well with fresh memories (81.8%) and fails when the VLM refreshes at 0.5 Hz (2.0%). Trained on memories up to 2 s old, it keeps 81.8% at 0.5 Hz. Even older training memories help further at the slowest rates.

Architecture

Semantic expert. In simulation this is InternVL3.5 at 1B to 14B parameters, and on DROID it is PaliGemma-3B. It reads one image and the instruction. We take the keys and values of 8 of its layers. A LayerNorm and a linear projection map them to a memory M with a fixed number of 768-wide tokens. We then add a position embedding and an embedding of the memory's age. M has the same shape for every VLM, so nothing downstream changes when the VLM does.

Vision-action expert. A 12-block transformer (183M parameters in simulation). It encodes the current external and wrist images and cross-attends to M in every block. It predicts a 20-step action chunk by flow matching with 5 Euler steps. Adaptive RMS normalisation conditions every block on the flow time, the memory age d and the expert's own execution delay ℓ.

Training. The memory age is sampled as d ~ 0.2·δ₀ + 0.8·U{1, …, 40} control steps. The expert also learns to continue a given prefix of actions, as in real-time chunking, so consecutive chunks join smoothly.

On a real robot

We compared ARP with π0.5-DROID, a strong, openly available VLA from Physical Intelligence. The robot is a Franka FR3 arm in the DROID setup, with one camera facing the table and one on the wrist, and inference runs on one RTX A6000. Our model, ARP-3B, uses PaliGemma-3B as the large model and a vision-action expert built on DINOv3 image features. It was trained only on the public DROID dataset. π0.5-DROID was, in addition, pre-trained by its authors on a larger robot dataset that is not public. ARP ran asynchronously, and the action expert continued from the last 8 actions it had committed to.

Each policy attempted each of three tasks 10 times, with a limit of 900 control steps, about 90 s. We score the final state: the fraction of objects in the bowl, or of cups nested.

Put the vegetables in the bowl: external camera at the start — The start of each task from the external and wrist cameras, then the progress of every trial (dots) and the mean over 10 trials (line). With 10 trials per task, differences of 10 to 20 points are within noise.

Put the vegetables in the bowl: wrist camera at the start — The start of each task from the external and wrist cameras, then the progress of every trial (dots) and the mean over 10 trials (line). With 10 trials per task, differences of 10 to 20 points are within noise.

Every trial

All 60 trials, in the order they were run. Thumbnails show the last frame of each trial. The videos come from the robot's cameras at one frame per control step, close to real time. The wrist camera did not record ARP's vegetables trial 10 or π0.5's vegetables trial 9.

ARP-3B

π0.5-DROID

When the scene changes

Benchmarks like LIBERO hardly measure reaction time, because nothing moves unless the robot moves it. We built two simulated tests in which the scene changes while the robot is acting.

In LIBERO-Perturb, the object the robot is reaching for jumps 5 cm sideways when the gripper gets within 10 cm of it. It runs on 20 LIBERO tasks.
In Dyn-Bump, a ball or cylinder rolls toward the robot and is knocked onto a new course, turned by up to 100°, at a random moment 1.5 to 5 s into the episode. The robot has to catch it and lift it.

Both tests are deterministic, so every policy faces exactly the same episodes.

We compare three versions of the same 1B model:

ARP runs asynchronously.
ARP weights, synchronous uses the same trained network but calls the VLM before every action chunk, as an ordinary VLA would.
The π0-style baseline is our model with the action expert's camera input removed, so it sees the scene only through the VLM's memory, as π0 does. It shares our backbone, data and training recipe.

Success rate with 95% intervals. LIBERO-Perturb: 20 tasks, 10 trials each. Dyn-Bump: 3 tasks, 50 trials each, with a bump in every episode.

The two tests separate two effects. When the object jumps mid-reach, all three policies first reach toward where it used to be, in about 76% of episodes, because the reach is already under way. ARP then recovers in 46% of those episodes and the π0-style baseline in 7%. The synchronous version of ARP does almost as well as the asynchronous one (46.5 vs 51.5%), so in this test the gain comes from giving the action expert its own camera rather than from running asynchronously.

When the object keeps moving, asynchrony matters too. The same weights drop from 44.7% to 31.3% when the VLM is put back into the control loop. With a bump in only half of the episodes, the results are 48.0% and 36.4% over 450 episodes each, and 20.0% for the π0-style baseline over 150.

LIBERO-Perturb rollouts

ARP

ARP weights, synchronous

π0-style baseline

The first trial of each task, in real time. Each video shows the front camera on the left and the wrist camera on the right. The label gives this trial's outcome and, in brackets, the task's successes out of 10.

Results per task

Task (10 trials each)	ARP-1B async	ARP-1B sync	π0-style 1B
LIBERO-Spatial
pick up the black bowl between the plate and the ramekin and place it on the plate	3	8	0
pick up the black bowl next to the ramekin and place it on the plate	6	4	3
pick up the black bowl from table center and place it on the plate	8	6	2
pick up the black bowl on the cookie box and place it on the plate	4	3	1
pick up the black bowl in the top drawer of the wooden cabinet and place it on the plate	0	1	0
pick up the black bowl on the ramekin and place it on the plate	1	0	0
pick up the black bowl next to the cookie box and place it on the plate	6	3	1
pick up the black bowl on the stove and place it on the plate	5	5	3
pick up the black bowl next to the plate and place it on the plate	8	7	3
pick up the black bowl on the wooden cabinet and place it on the plate	5	6	4
LIBERO-Object
pick up the alphabet soup and place it in the basket	10	7	0
pick up the cream cheese and place it in the basket	10	9	0
pick up the salad dressing and place it in the basket	2	2	0
pick up the bbq sauce and place it in the basket	6	4	0
pick up the ketchup and place it in the basket	3	1	0
pick up the tomato sauce and place it in the basket	1	5	0
pick up the butter and place it in the basket	8	10	2
pick up the milk and place it in the basket	3	3	0
pick up the chocolate pudding and place it in the basket	10	8	0
pick up the orange juice and place it in the basket	4	1	0

Dyn-Bump rollouts

ARP

ARP weights, synchronous

π0-style baseline

The first trial of each task, in real time. ARP fails two of these three.

ARPsuccess

ARP weights, synchronousfailure

The red-ball episode used as an example in the paper (trial 35). The ball is knocked at 2.15 s. ARP turns, follows it and lifts it at 5.0 s. The synchronous version falls behind and times out at 15 s.

We also measured how long the arm takes to turn toward the ball's new course after a bump. Asynchronous execution turned sooner on average in all five comparisons we ran, by 135 to 261 ms. None of these differences is statistically significant at our sample sizes.

Running the large model less often

Since the action expert does the reacting, the VLM does not have to keep pace with the robot. We kept the action expert at 5 Hz and refreshed the memory less and less often, on LIBERO, with 400 episodes per point.

Success with 95% intervals. The dashed line is ARP-1B given a fresh memory before every action chunk. Between a refresh every 0.2 s and one every 4 s, ARP-1B loses 4.3 points. The π0-style baseline sees the scene only through the memory and loses 36.2.

A broad benchmark: RoboLab

RoboLab is a photorealistic simulation benchmark for robots trained on DROID. It has 120 tasks in three difficulty levels, each run in 8 randomized layouts. It tests much more than reaction, including language, distractors and multi-step tasks, and it is where ARP-3B is weakest.

Policy	Simple 512 ep.	Moderate 312 ep.	Complex 136 ep.	All tasks 960 ep.
π0.5-DROIDPhysical Intelligence; base model pre-trained on non-public data	42.4	37.5	22.1	37.9[34.9, 41.0]
LAP-3BDROID + Open X-Embodiment	20.9	18.6	8.8	18.4[16.1, 21.0]
ARP-3B, synchronousDROID only; VLM and expert called in sequence	25.8	16.4	6.6	20.0[17.6, 22.6]
ARP-3B, asynchronous (d = 8)DROID only; prefix-conditioned asynchronous execution	26.4	16.4	7.4	20.4[18.0, 23.1]

Success rate (%). π0.5-DROID is clearly the strongest. ARP-3B is slightly ahead of LAP-3B, a model of similar size that, unlike ARP, was also trained on Open X-Embodiment data. Running ARP asynchronously barely changes its overall score.

Part of π0.5's lead comes from data, so we also compared on tasks that DROID covers. To pick them:

We counted DROID episodes whose instructions mention a task's objects and goal, and kept tasks with at least 100 such episodes.
We dropped tasks with constraints DROID has no examples of: counting, ordering, comparisons, spatial relations, reorientation and sorting.
We kept the simple tier.

That leaves 18 tasks. This is a word-matching estimate of coverage, not a check that DROID contains the same manipulation.

Policy	Success, 18 DROID-covered tasks	Success, all 120 tasks
π0.5-DROID	35.4%[28.1, 43.5]	37.9%
LAP-3B	27.1%[20.5, 34.9]	18.4%
ARP-3B, synchronous	31.9%[24.9, 39.9]	20.0%
ARP-3B, asynchronous (d = 8)	37.5%[30.0, 45.6]	20.4%

On these tasks, asynchronous ARP and π0.5-DROID are within noise of each other (144 episodes each). On the 29 of these episodes that both solved, ARP was faster: 16.8 s against 20.9 s on average. Across all 81 simple-tier episodes that both solved, they take the same time (17.6 vs 17.9 s).

For the same ARP checkpoint, asynchronous execution with an 8-step action prefix gave smoother motion than synchronous execution on these tasks:

ARP-3B	Success	Time (s)	Jerk (ISJ)	SPARC
Synchronous	31.9%	19.5	456	−5.11
Asynchronous, 8-step prefix	37.5%	17.1	296	−3.90
Change on the 37 episodes both solved	+5.6, n.s.	−15%	−39%, p < 0.01	+25%, p < 0.001

Success is over all 144 episodes. The other columns are over successful episodes, since a failed episode runs to its time limit. Jerk is the integrated squared jerk of the gripper (lower is smoother). SPARC is the spectral arc length (closer to zero is smoother). Tests: exact McNemar for success, Wilcoxon signed-rank otherwise.

RoboLab rollouts

ARP-3B, asynchronous

π0.5-DROID

Layout 0 of each DROID-covered task, in real time. These 16 episodes favour ARP (8 successes against 3) more than the full results do. Two tasks are missing because every π0.5 recording of them is corrupted on disk, but their episodes are counted in the tables.

Results for all 120 tasks

Task	Instruction	Tier	π0.5	LAP-3B	ARP sync	ARP async
AnimalsInBin †	Put the lizards in the bin	simple	2	0	0	0
BBQSauceInBin	Put the red BBQ sauce bottles in the grey bin	simple	5	0	0	0
BagelsOnPlate	Put the bagels on the plate	simple	0	0	0	0
BananaInBowl	Pick up the banana and place it in the bowl	simple	8	6	8	8
BananaOnPlate	Pick up the banana and put it on the plate	simple	6	6	7	8
BananaThenRubiksCube	put the banana then the cube in the bowl	simple	5	1	2	4
BigPumpkinInBin	Put the bigger pumpkin in the bin	simple	3	0	0	0
BowlInBin †	put the bowl in the grey bin	simple	6	0	4	6
BowlStackingLeftOnRight †	Stack the left bowl on the right bowl	simple	0	0	0	2
BowlStackingRightOnLeft †	Stack the right bowl on the left bowl	simple	2	0	1	1
ButterAboveRaisin	Pick up the butter box and place it on top of the raisin box	simple	6	2	0	2
CannedFoodInBin †	Put the canned food in the grey bin	simple	2	3	7	8
ClampInRightBin	Put the spring clamp in the right bin	simple	6	0	0	0
ClutterPumpkin	Put all the pumpkins away in the bin	simple	0	0	0	0
CoffeePotInBin	Put the coffee pot in the grey bin	simple	0	0	0	0
CookingPickPastaTool †	Move the pink tool from this utensil container to the other utensil holder	simple	0	0	0	0
FoodPacking1Boxes †	Pack boxed foods into the bin	simple	1	2	1	0
FoodPacking1Cans †	Pack canned foods into the bin	simple	8	7	8	8
FoodPacking2Boxes †	Pack boxed foods into the bin	simple	1	0	0	0
FoodPacking2Cans †	Pack canned foods into the bin	simple	3	1	0	1
FruitsGreenLimesOnPlate	Put all the green fruit on the plate	simple	5	1	4	2
FruitsMovingOrangeOrLime	Move an orange or a lime to the wood bowl	simple	6	1	0	3
FruitsMoving	Move an orange to the white bowl	simple	0	0	0	0
FruitsOnion	Put the onion in the wood bowl	simple	5	3	0	0
FruitsOnionToPlate	Put the onion on the plate	simple	3	0	0	0
GrabABagel	Grab a bagel	simple	1	0	0	0
GrabAFruit †	Pick up a fruit	simple	0	2	0	7
JugsOnShelf	Put all the jugs on the shelf	simple	0	0	0	0
KeyboardOutOfBin	Take the keyboard out of the bin and put it on the table	simple	6	0	1	1
LargerObjectRaisinBoxInBin	Place the larger object in the grey bin.	simple	1	0	1	0
MouseOnKeyboard	Put the computer mouse on the keyboard	simple	8	5	2	3
MoveBananaToBagelPlate	Move the bananas to the bagel plate	simple	0	0	0	1
MustardAboveRaisin	Place the mustard on the raisin box.	simple	6	3	2	2
MustardInLeftBin	Put the mustard in the left bin	simple	7	3	7	1
MustardInRightBin	Put the mustard in the right bin	simple	7	0	3	1
OneBottleInSquarePail	Put any white plastic bottle in the square pail	simple	3	5	6	7
OneBottleOnShelf †	Put any white plastic bottle on the shelf	simple	0	0	0	0
PhoneOrRemoteInBin	Put the phone or the remote in the grey bin	simple	8	3	2	1
PickDrill	Pick up the cordless drill.	simple	6	0	0	0
PickGlasses	Pick up the eye glasses	simple	5	0	0	0
PickOrangeObject	Pick up the orange measuring cup	simple	5	0	0	1
PickUpGreenObject	Pick up the green vegetable block	simple	6	0	0	1
PutBowlOnShelfTop	Put the serving bowl anywhere on the shelf in front of you	simple	0	2	0	2
RecycleCarton	Put the recyclable cartons in the grey bin	simple	4	0	0	0
RecycleCartonsOnBox	Put the cartons that can be recycled on the box	simple	0	0	0	0
RedDishesInBin †	Put the red dishware in the grey bin	simple	3	1	0	1
RubiksCubeAndBanana †	Put the cube and the banana in the bowl	simple	6	7	7	3
RubiksCubeOrBanana †	Put the cube or the banana in the bowl	simple	8	7	8	7
RubiksCube	Put the cube in the bowl	simple	8	8	8	8
RubiksCubeThenBanana	Put the cube then the banana in the bowl	simple	1	3	6	7
SauceBottlesCrate	Put the red bbq sauce bottle in the crate	simple	7	5	6	4
SmallPumpkinInBin	Put the small pumpkin in the bin	simple	0	0	0	1
SmallerObjectButterInBin	Place the smaller object in the grey bin.	simple	6	4	6	6
SmartphoneInBin	Put the smartphone in the grey bin	simple	0	4	0	0
TakeMeasuringSpoonOut †	Take the white colored measuring spoon out of the red bowl and put it on the table.	simple	4	5	8	8
ThrowAwayApple	Throw away the apple	simple	0	2	2	2
ThrowAwaySnacks	Put away the snacks in the bin	simple	1	0	5	1
ToolsPickingDrill	Select the cordless drill and put it on the table	simple	2	0	0	0
ToolsPickingHammer	Select the blue hammer and put it on the table	simple	0	0	0	0
ToyInBin †	Put the lizard away in the bin	simple	5	4	2	2
WhiteMugsInBin †	Clean up the white mugs	simple	0	0	0	0
WoodSpatulaToBowl	Put the wooden spatula in the bowl	simple	6	0	0	0
YellowAndWhiteObjectsInBin	Put all white objects and yellow objects in the grey bin	simple	1	0	2	0
YogurtInBowl	Put the small red yogurt in the red bowl	simple	3	1	6	4
AppleAndYogurtInBowl	Put the apple and yogurt in the bowl	moderate	5	1	2	3
BananasInBinOneMore	Put one (1) more bananas in the grey bin.	moderate	7	8	8	2
BananasInBinThreeTotal	Make sure there are 3 (three) bananas in the grey bin.	moderate	8	8	8	5
BananasInCrate	Put 2 bananas in the crate	moderate	7	8	8	8
BananasOutOfBin	Take the bananas out	moderate	6	4	6	8
ClutterPlastic	Put all plastic bottles away in the bin	moderate	0	0	0	0
CookingClearPlate	Put the two measuring cups outside of the plate	moderate	6	0	0	0
DishesInBin	Put the dishware in the grey bin	moderate	0	0	0	0
FoodPacking3Boxes	Pack boxed foods into the bin	moderate	0	0	0	0
FoodPacking3Cans	Pack canned foods into the bin	moderate	2	0	0	0
FoodPackingByColor	Pack yellow objects in right container and blue object in the left container	moderate	0	0	0	0
FruitsOrangesOnPlate	Put all the oranges on the plate	moderate	5	2	0	0
HammersInLeftBin	Put the red hammer and black hammer in the left bin	moderate	3	1	0	0
MarkerInMug	Put the whiteboard marker in the mug	moderate	5	0	1	3
NonHammerToolsInRightBin	Put the non-hammer tools in the right bin	moderate	4	0	0	0
PickUpBluePitcher	Pick up the large blue pitcher	moderate	4	0	0	1
PinkSpoonInPot	Put the pink spaghetti spoon in the pot	moderate	4	0	1	0
PutMugsOnShelf	Put the two mugs on the shelf	moderate	0	0	0	0
PutTwoMugsOnShelf	Put two (2) mugs on the wire shelf	moderate	1	0	0	0
RecycleCartonsVerticalCrate	Put the cartons that can be recycled in the vertical crate	moderate	0	0	0	0
RedItemsInBin	Put all the red things in the grey bin	moderate	3	0	1	0
ReorientJug	Stand the jug upright	moderate	0	0	0	0
ReorientRedMug	Put the red mug upright so that the opening is facing upwards.	moderate	3	0	0	0
ReorientWhiteMugs	Make sure all the white mugs are upright so that the opening is facing upwards.	moderate	4	1	0	0
RubiksCubeBehindBowl	Put the rubiks cube behind the bowl	moderate	7	7	1	3
RubiksCubeInFrontOfBowl	Put the rubiks cube in front of the bowl	moderate	0	0	0	0
RubiksCubeLeftOfBowl	Put the rubiks cube to the left of the bowl	moderate	1	2	2	3
RubiksCubeRightOfBowl	Put the rubiks cube to the right of the bowl	moderate	0	3	2	2
SpoonInMug	Put the metal spoon that's in the wooden bowl in the mug	moderate	0	0	0	0
Stack3RubiksCube	Stack the rubiks cubes in a tower	moderate	4	1	0	1
StackWhiteMugs	Stack the white mugs on top of each other.	moderate	6	4	1	1
StackYellowOnRed	Stack the yellow block on the red block	moderate	6	0	0	0
TakeMugsOffOfShelf	Take the mugs off the shelf	moderate	1	0	0	0
TakeSpatulaOffShelf	Take the spatula off the shelf and put it on the table	moderate	0	0	0	0
ToolOrganizationBoth	Put hammers in the right bin and do not touch anything else	moderate	0	0	0	0
ToolOrganization	Put the red hammer and black hammer in the left bin	moderate	3	0	0	0
UnstackRubiksCube	Unstack the rubiks cube tower	moderate	8	7	8	8
UtensilsInMug	Put the fork and spoon in the ceramicmug	moderate	0	0	0	0
WhiteMugInCenterOfTable	Put the white mug in the center of the table.	moderate	4	1	2	3
BlackItemsInBin	Put the black items in the grey bin	complex	0	0	0	0
BlockStackingOrderAgnostic	Stack the blocks into a tower	complex	1	0	0	0
BlockStackingSpecifiedOrder	Stack the blocks in the order from bottom to top: red, blue, green, yellow	complex	0	0	0	0
BlocksInBin	Sort all colored blocks into the bin	complex	1	0	0	0
CleanUpToys	Clean up all the smaller toys and leave the birdhouse on the table	complex	0	0	0	0
ClearOrganicObjects	Clear away the organic objects	complex	0	0	0	0
CondimentsInBin	Sort the sauce condiments into the grey bin	complex	3	0	2	0
CubesAndBlocksInBin	Put all the cubes and blocks in the bin	complex	4	0	0	0
ElectronicsInBin	Put the electronic devices in the grey bin	complex	1	1	0	0
FruitsOnPlate3	Put three (3) fruits on the plate	complex	6	4	5	8
FruitsOnPlate	Put all the fruits on the plate	complex	0	0	0	0
GreenSpoonsInPot	Put the green spoons in the pot	complex	2	0	0	0
PlasticBottlesInSquarePail	Put all the small plastic bottles in the square pail	complex	4	3	1	1
ReorientAllMugs	Reorient all the mugs upright so that the opening is facing upwards.	complex	0	0	0	0
RubiksCubesInBin	Sort all rubiks cubes into the bin	complex	8	4	1	0
SpoonsInPot	Put all of the serving spoons with no holes in the pot	complex	0	0	0	1
ToolsPickingAllHammers	Take out all the hammers and put them on the table	complex	0	0	0	0
Total			364 / 960	177 / 960	192 / 960	196 / 960

Successes out of 8 layouts. † marks the 18 DROID-covered tasks.

Does a bigger VLM help?

In simulation we trained the same recipe with five sizes of InternVL3.5, from 1B to 14B parameters. The vision encoder is the same frozen InternViT-300M in every model, so only the language model changes. On the standard LIBERO benchmark (40 tasks, 2,000 episodes per model), success rises from 84.8% at 1B to 89.3% at 8B. 14B is no better than 8B. When the object jumps mid-reach, larger models did not help: 51.5% at 1B, 40.0% at 8B and 40.0% at 14B.

Model	Language model	Spatial	Object	Goal	Long	Average, async	Average, sync
ARP-1B	Qwen3-0.6B	89.4	97.6	89.8	62.4	84.8[83.2, 86.3]	82.9
ARP-2B	Qwen3-1.7B	89.2	96.0	88.6	72.6	86.6[85.0, 88.0]	84.4
ARP-4B	Qwen3-4B	91.4	96.0	84.6	66.0	84.5[82.8, 86.0]	83.5
ARP-8B	Qwen3-8B	92.8	98.6	90.4	75.2	89.3[87.8, 90.5]	86.5
ARP-14B	Qwen3-14B	88.4	96.4	80.2	74.0	84.8[83.1, 86.3]	81.3
Baseline: same backbone and recipe, no camera input in the action expert
π0-style 1B	Qwen3-0.6B	83.2	95.2	90.6	51.8	80.2[78.4, 81.9]	75.7
π0-style 8B	Qwen3-8B	85.4	95.0	90.0	60.4	82.7[81.0, 84.3]	81.3
Reported by the original authors (different pre-training and vision encoder; not directly comparable)
π0	PaliGemma-3B	96.8	98.8	95.8	85.2	94.2	–
Diffusion Policy	–	78.3	92.5	68.3	50.5	72.4	–

Success rate (%) on LIBERO. “Async” and “sync” run the same weights without and with the VLM in the control loop. Asynchronous execution is 1 to 3.5 points higher at every size. The released π0 is far ahead. It uses large-scale robot pre-training and an unfrozen vision encoder, so its row is only there for scale.

Limitations

The real-robot study is small: three tasks, ten trials each, one robot and one lab. The two policies were run in separate sessions on the same day, and π0.5-DROID did better on cup stacking.

ARP-3B is not a better generalist than π0.5-DROID. It trails on RoboLab by 17.9 points overall. The two models differ in both architecture and training data, so this comparison cannot tell which of the two matters more.

We have not shown that a larger VLM makes the robot react better. On LIBERO-Perturb the larger models did worse. In that test, most of ARP's advantage comes from the action expert's own camera, and only a little from asynchrony. Before running it, we registered a check that asynchronous execution stalls less often than synchronous execution there, and the check failed: 12.0% against 12.5% of episodes stalled for more than a second. Reaction times favour asynchronous execution but are not significant, and settling the question would take roughly ten times more trials.

We do not know how slowly the VLM can run before performance drops. We tested down to one refresh every 4 s. In simulation, the π0-style baseline is our reimplementation, not the released π0. The real-robot and RoboLab comparisons use the released π0.5-DROID.

Code and models

We will release the code and the checkpoints below with the paper. The simulation checkpoints contain only the weights trained on top of the public VLM: LoRA adapters, projector, memory adapter and action expert.

Checkpoint	Semantic expert	Training data	Trained weights
ARP-1B	InternVL3.5-1B	LIBERO (40 tasks)	0.84 GB
ARP-2B	InternVL3.5-2B	LIBERO	0.88 GB
ARP-4B	InternVL3.5-4B	LIBERO	0.96 GB
ARP-8B	InternVL3.5-8B	LIBERO	1.03 GB
ARP-14B	InternVL3.5-14B	LIBERO	1.14 GB
π0-style 1B / 8B	InternVL3.5-1B / 8B	LIBERO	0.83 / 1.02 GB
Staleness ablations (d_max = 0, 8, 80)	InternVL3.5-1B	LIBERO	0.84 GB
ARP-1B and π0-style 1B, Dyn-Bump	InternVL3.5-1B	Dyn-Bump (scripted expert)	0.84 / 0.83 GB
ARP-3B	PaliGemma-3B + DINOv3	DROID	–

Citation

@misc{arp2026,
  title         = {Asynchronous Robot Policies},
  author        = {Anonymous},
  year          = {2026},
  eprint        = {XXXX.XXXXX},
  archivePrefix = {arXiv},
  primaryClass  = {cs.RO}
}