Voice went through two generations before it got here. First a pipeline: transcribe, reason over text, synthesize speech back - always waiting for one stage to finish before the next starts. Then fused speech-to-speech models, which removed some of the translation loss but kept the turn-based structure. Neither could interrupt, backchannel, or think while listening, because the architecture never let two things happen at once.
Manipulation is currently stuck at stage one. Sense, think, act, repeat - a robot arm finishes looking, then finishes deciding, then finishes moving, then looks again. This works for a block sitting still on a table. It does not work for anything that requires a correction mid-motion: a grip that's starting to slip, a handoff that arrives half a second early, contact that needs to be felt and reacted to inside the same window it happens in. By the time the loop comes back around to “sense,” the moment is already over.
The fix, and who's already building it
A small cluster of papers published within months of each other this year attack this the same way voice did: stop treating sensing, reasoning, and control as sequential stages, and start treating them as independent processes that run at their own frequencies and share state instead of blocking on each other.
FiS-VLA (Fast-in-Slow) puts a lightweight action head inside a larger reasoning model and runs them at different frequencies - the fast head consumes the slow model's latent features, robot state, and visual input at a 1:4 ratio, rather than waiting for a fresh forward pass every step.
DuoCore-FS, from the Astribot team, is more explicit about the failure mode it's fixing: existing dual-system architectures nominally separate a slow reasoning system from a fast action system, but the two subsystems still run synchronously, so the fast system has to wait for updates from the slow one. Their fix is a latent buffer between a VLM-based slow pathway and a diffusion-based fast pathway, with the two trained jointly end-to-end but executed as truly separate loops.
Libra-VLA targets a subtler version of the same problem: even when the two systems run at different frequencies, a static latent handoff between them goes stale as the environment changes mid-execution. Their planner instead generates a predictive sequence of coarse actions covering the upcoming execution horizon, so the fast loop has forward-looking guidance rather than a frozen snapshot.
AsyncVLA takes this outside the lab and onto a network: a large VLA runs remotely and sends high-level guidance, while a lightweight edge model refines actions locally at high frequency, so the robot keeps moving smoothly even when the network round-trip to the “thinking” model is slow. Most existing dual-loop systems are only built to absorb small inference delays, up to roughly 300 milliseconds, and rarely test against anything moving faster than about a centimeter per second - this is the paper naming, plainly, how far the field still has to go before this is robust in the real world.
Why touch makes this harder than voice
Voice has a latency budget measured in hundreds of milliseconds before a conversation starts to feel stiff. Contact does not have that luxury. A correction that lands 200ms late in speech sounds slightly awkward; a correction that lands 200ms late on a slipping grip means the object has already left the hand. That's the honest reason none of the papers above claim to be finished - AsyncVLA's own numbers on delay tolerance and motion speed are the field admitting this out loud, not us reading between the lines.
It's also why this connects to sensing, not just control frequency. A fast loop that's blind to slip or force has nothing useful to react to quickly. The asynchronous-control research above and the early tactile-sensing work we're tracking separately (vibration-based contact sensing, visuotactile policies) are really the same problem from two sides - one is about not blocking on computation, the other is about not blocking on perception.
Where we sit
We think this is the more durable bet than chasing bigger single-stream models. A bigger model that still senses, thinks, and acts in strict sequence has a hard latency floor no amount of scale removes. The path to something that can be nudged, interrupted, and corrected mid-motion the way a hand actually is runs through decoupling the loops, not through parameter count - full duplex, not a faster half duplex.