🤖 machine learning

$\pi\mathbf{R}^2$ : Reactive Real-time Flow Policies

The paper introduces $\pi\mathbf{R}^2$ , a framework that enhances generalist action-chunking flow policies with real-time reactivity by decoupling fast proprioceptive and slow visual conditioning and employing a latency-adaptive flow schedule, thereby enabling high-frequency closed-loop control and significantly improving success rates in dynamic manipulation tasks without requiring new backbone architectures.

Original authors: Sungjae Park, Shubham Tulsiani

Published 2026-07-29

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sungjae Park, Shubham Tulsiani

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 you are teaching a robot to juggle. In the world of robotics, there's a big push to build "foundation models"—massive, super-smart AI brains that can learn to do almost anything by watching humans. These brains are like giant libraries of knowledge, reading books (text) and looking at pictures (vision) to understand the world. To make these brains move, engineers use a trick called "action chunking." Instead of telling the robot "move your hand here, then there, then there" one tiny step at a time, the AI predicts a whole block of future moves all at once, like a chef writing out a full recipe before starting to cook. This makes the robot's movements smoother and more consistent.

However, there's a catch. Because the AI is so big and complex, it takes a long time to cook up that full recipe. By the time the robot finishes the first few moves of the recipe, the world around it might have changed—a ball might have rolled away, or a person might have bumped its arm. Since the robot is busy executing the old recipe "open-loop" (without looking at what's happening right now), it can't react fast enough. It's like trying to drive a car while wearing blindfolds that only let you see the road from ten seconds ago. If you want the robot to be truly reactive, you need it to look at the road now, but the massive brain is too slow to update its recipe that often.

This is where a new idea called πR2 (pronounced "Pi-R-Squared") comes in. Researchers at Carnegie Mellon University realized that while the robot's "eyes" and "brain" (the vision and language parts) are slow and heavy, its "body sense" (proprioception—knowing where its joints are, how fast they are moving, and how hard they are pushing) is incredibly fast. They built a system that splits the robot's attention into two channels: a slow, heavy channel for the big picture (what the object looks like) and a lightning-fast channel for the body's immediate feelings.

Think of it like a pilot flying a plane. The pilot looks at the map and the weather report (the slow vision part) to decide the general direction, but they constantly feel the controls and the wind in their hands (the fast proprioception part) to make tiny, split-second adjustments. πR2 lets the robot do the same thing. It keeps the big, slow recipe for the general plan but updates the immediate "steering wheel" moves with fresh data every single time the robot moves a muscle.

The paper shows that this approach is a game-changer. By using a clever scheduling trick that treats the robot's current actions like a "work in progress" rather than a finished product, πR2 can update its plan roughly 4 times faster than previous methods. In tests, this allowed the robot to react to new information every 40 milliseconds (which is 25 times a second), even when running on a massive, slow AI model.

The results are impressive. In computer simulations, the new method improved success rates by up to 23%. But the real magic happened in the physical world. When tested on a real robot arm with a dexterous hand, πR2 beat the best existing methods by up to 30%. It could catch a falling book, push a box upright, and tidy up a pile of books without dropping them, all because it could feel the world changing and adjust its grip instantly, rather than blindly following an old plan. The researchers found that while other robots would crush a book because they reacted too late, πR2 would gently adjust its grip the moment it felt the book slipping. This suggests that for robots to truly master dynamic, real-world tasks, they don't just need to be smarter; they need to be faster at listening to their own bodies.

Technical Summary: πR2: Reactive Real-time Flow Policies

Problem Statement

Recent advancements in robotics foundation models have established a standard architecture combining large pre-trained backbones (e.g., Vision-Language Models or VLMs), expressive multi-modal policy heads (diffusion or flow matching), and action chunking. While this paradigm enables scalable imitation learning, it suffers from two critical limitations when applied to dynamic, closed-loop control:

Reduced Reactivity: Action chunks are executed open-loop. Once a chunk is predicted, the robot cannot react to sensory inputs arriving mid-execution until the next chunk is generated.
High Latency: The perception-to-action pipeline involves heavy computation (large backbone inference + multiple denoising steps). This latency prevents frequent replanning, forcing the policy to rely on "stale" sensory observations. Consequently, the robot commits to actions based on outdated states, making it ill-suited for tasks requiring fast, smooth, and reactive corrections (e.g., contact-rich manipulation).

Simply reducing the chunk size to improve reactivity is infeasible because the computational cost of the backbone and multiple denoising iterations remains too high for high-frequency control loops.

Methodology

The authors propose πR2, a framework that modifies existing flow-matching policies to achieve real-time, closed-loop reactivity without discarding large backbones or multi-action prediction. The approach relies on two core architectural and scheduling innovations:

1. Proprioception-Reactive Diffusion Forcing

The authors identify an asymmetry in input processing costs: proprioceptive signals (joint positions, velocities, torques) can be processed orders of magnitude faster than visual or language data.

Dual-Channel Conditioning: The policy disentangles conditioning into two channels:
- Fast Channel: Proprioception, updated at every control tick (e.g., every 40 ms).
- Slow Channel: Vision and language features from the VLM backbone, updated asynchronously.
Asynchronous Processing: The action head conditions on fresh proprioception at every denoising step while tolerating bounded staleness in vision-language features. During training, the slow channel is artificially delayed by a random amount $d_{vlm}$ to teach the model to handle stale visual inputs. At inference, the vision-language features are processed in a background thread, allowing the action head to run immediately using cached features and fresh proprioception.

2. Latency-Adaptive Flow Schedule

To handle variable inference delays ( $d$ ) caused by hardware, network latency, or computational load, πR2 introduces a staircase noise schedule parameterized by the measured delay $d$ .

Three-Region Schedule: For a target delay $d$ $d$ , the action chunk of length $H$ $H$ is divided into:
1. Front ( $0 \le p < d$ ): "In-flight" actions that are already being executed. These are treated as inpainting conditioning (clamped clean) and are not re-predicted.
2. Interior ( $d \le p < H-d$ ): A linear ramp from clean to noise. The model predicts new actions here.
3. Tail ( $H-d \le p < H$ ): Pure noise slots appended to the buffer for future prediction.
Single-Step Inference: Unlike standard flow matching which requires $K$ denoising steps to predict a full chunk, πR2 uses one denoising step per call to emit $d$ new clean actions. The buffer then slides forward, appending fresh noise slots.
Training Strategy: The model is trained by sampling a random delay $d$ and applying the corresponding staircase schedule. A mask excludes the "front" (in-flight) actions from the loss. This allows a single model to adapt to varying inference latencies at deployment.

Key Contributions

Reactive Real-Time Inference: πR2 enables flow policies to replan closed-loop roughly 4× faster than base policies (achieving 25 Hz on an A5000 GPU with a large VLA like GR00T-N1.7), acting on fresh proprioceptive observations every 40 ms.
Architectural Minimalism: The method requires minimal modification to existing architectures. It can be applied by finetuning a pre-trained policy (e.g., a VLA) without retraining the heavy backbone, simply by changing the conditioning mechanism and noise schedule.
Latency Adaptation: The proposed noise schedule allows a single model to seamlessly handle variable inference delays, maintaining smooth execution even when the delay fluctuates.

Experimental Results

The authors evaluated πR2 in both simulation and real-world settings using the GR00T-N1.7 model on an xArm6 + XHand platform.

Simulation (Leap Cube Reorientation):
- Without inference delay, πR2 matched the performance of standard flow policies with a small execution horizon ( $h=1, 2$ ) while amortizing the denoising cost.
- Under realistic latency constraints, πR2 with asynchronous processing significantly outperformed baselines (Naive Async, Train-Time RTC). As delay increased, πR2 maintained high success rates, whereas baselines degraded sharply. This confirms that up-to-date proprioception is critical for reactive tasks, even with stale vision.
Real-World Manipulation:
- Tasks included contact-rich scenarios: "Don't Spill," "Tidy Up Book," "Insert Box," and "Catch Book."
- Performance: πR2 improved success rates by up to 23% in simulation and 30% in the real world compared to the strongest baseline (Train-Time RTC).
- Qualitative Analysis: In the "Tidy Up Book" task, πR2 successfully modulated grip force based on live proprioceptive feedback (stopping at ~~50 N), whereas the baseline (Train-Time RTC) reacted late to contact, over-gripping (~~120 N) and crushing the book. πR2 demonstrated superior ability to recover from failures and execute smooth, reactive motions.

Significance and Claims

The paper claims that πR2 successfully bridges the gap between the expressivity of large-scale foundation models and the reactivity required for dynamic manipulation. By decoupling the slow semantic backbone from the fast control loop and adapting the flow schedule to latency, πR2 allows robots to:

React to sensory inputs (specifically proprioception) within an action chunk.
Maintain the benefits of multi-action prediction and large pre-trained backbones.
Achieve real-time closed-loop control frequencies (25 Hz) that were previously unattainable with complex VLA architectures.

The authors emphasize that this approach does not require training from scratch but rather a principled finetuning of existing policies, making it a practical solution for deploying reactive behaviors on current robotics foundation models.