REA Framework Enables Async Agent-VLA Collaboration for Embodied Robot Control

Problem: Mismatched Frequencies Between Reasoning and Control

Large models can understand tasks and plan steps, while fast policies execute continuous actions. However, combining them naively creates latency: if the robot waits for the "brain" after every action segment, inference delay slows control; if it only asks for help on errors, it misses silent failures where a policy finishes normally but the task remains incomplete (e.g., a stove knob turned but still off). A blocking advisor baseline averaged 1.7 calls per task, with the robot idling 2.62 seconds (20% of control time) waiting for the brain.

REA Architecture: Three-Layer Async Handoff

REA inserts a Router between reasoning and execution, splitting the system into three layers:

System 2 (Reasoning) : Generates candidate policies offline or online, analyzes observations, and gives advice.

System 1 (Scheduling) : Selects, switches, and stops policies at agreed policy boundaries (end of a VLA action chunk, motion segment, or program return).

System 0 (Execution) : Runs VLA, code policies, or whole-body controllers unchanged.

Handoff occurs only at these boundaries. In sync mode the Router judges after a policy returns; in async mode System 2 reasons in parallel with System 0 execution, and new advice is applied at the next boundary. The currently running policy never pauses to wait for the brain.

Router Memory: Experience-Guided Policy Selection

Before deployment, REA records each candidate's success rate and average step count on a held-out development set, building a routing memory . At runtime, the Router picks the policy with the highest success rate; ties go to fewer steps. This exploits the fact that the best average performer may not be best on every task — routing lets each policy handle the tasks it excels at.

Visual Judge: Detecting Silent Failures

Programs can return success while the goal is unmet (e.g., arm retracts but knob stays off). In ASPIRE's 590 trials, exception-triggered recovery fired only 6 times, yet 166 tasks actually failed. REA adds a Visual Judge that compares the initial and current images after each policy returns. If the Judge says "done", the Router stops; if "not done", it continues with the next candidate from the routing memory. Recovery shares the same time and step budget, so completed tasks stop early while unfinished ones get another try.

Experimental Results

LIBERO-Pro (60 tasks, 50 seeds each, 3,000 total)

REA-M (routing memory only): 95.9% success vs. 94.7% best single policy; steps per success dropped from 1,343 to 1,003 (~25% reduction); control time reduced ~17%.

REA-A (online Agent queries): also 95.9% success but slower (11.36s vs. 9.96s per task), showing routing memory alone sufficed for this policy pool.

ASPIRE (visual judge ablation)

Single Fix policy: 66.3% success.

+ Routing memory + exception recovery: 71.9%.

+ Visual Judge controlling recovery: 74.9%.

Wall-clock time per success rose ~2.1× vs. exception-only, indicating the trade-off depends on the failure profile of the policy pool.

RoboTwin 2.0 (7 VLAs + code policies, 50 tasks, 100 scenes)

Selector reads initial instruction, image, and robot state once at task start.

VLA-only routing: 84% success.

+ Code policies: 86% success, completing two more tasks in randomized scenes.

Real-Robot Deployment

Unitree G1 (walk to chair and push): 10 trials each. REA 8/10; Agents SDK 5/10; Codex 4/10; ASPIRE 2/10.

AlohaMini2 (block-in-box with stable placement): 10 trials each, up to 3 grasp attempts. REA 10/10.

π0.5 + Code async routing (separate controller experiment): π0.5 alone 3/10; REA async routing 8/10. Grasp failures unchanged (2 each), placement failures dropped from 5 to 0. Code executed in 5 of 10 REA trials, handling the task's second half. REA average active time 128.89s vs. π0.5 16.57s (combined control uses more time but achieves higher success).

Conclusion

REA demonstrates concrete divisions of labor in brain-cerebellum collaboration: routing memory enables fast selection when experience suffices; visual judgment catches silent failures; unified scheduling lets VLAs and code policies complement each other. The framework provides an implementable, comparable pipeline where researchers can plug in different Agents, VLAs, and program policies to study which judgments belong to the slow brain and which actions can stay in the fast cerebellum.