REA: A Routed Embodied Agent Runtime for Asynchronous Brain-Cerebellum Control

Pengfei Zhou, Yixing Ma, Zhengfeiyang Zhang, Haoyuan Chen, Zhenglin Wan, Hexin Wang, Wangbo Zhao, Yang YouarXiv 2026 · arXiv

TL;DR

REA (Routed Embodied Agent) is a unified runtime that bridges the gap between slow, deliberative "brains" (foundation models) and fast, reactive "cerebellums" (low-level policies). By using a smart router and a visual judge to coordinate these systems asynchronously, REA achieves state-of-the-art success rates across diverse robotic tasks while significantly reducing execution time and computational cost.

What Problem Does This Paper Address?

In robotics, there is a fundamental tension between reasoning and reaction. Foundation models (System 2) are excellent at high-level reasoning and planning, but they are too slow and expensive to control a robot in real-time. Conversely, fast policies like Vision-Language-Action (VLA) models or whole-body controllers (System 0) provide quick "reflexes" but often fail to generalize or handle unexpected errors.

Existing attempts to pair these systems face two major hurdles:

  1. The "Stalling" Problem: If a fast policy has to wait for a slow brain to make a decision at every step, the robot becomes idle and inefficient.
  2. Silent Failures: Fast policies often fail "silently"—the code might finish running without errors, but the actual task (like turning on a stove) remains incomplete. Standard error-handling (exception catching) misses these cases.

Methods

REA introduces a three-level architecture designed around a "golden rule": no running policy ever waits on the brain.

  • System 0 (The Cerebellum): Executes fast, reactive policies (e.g., VLA models or generated Python code).
  • System 1 (The Router): Acts as the coordinator. It uses Route Memory—a pre-computed table of which policies work best for which tasks—to dispatch the best policy immediately without querying the brain.
  • System 2 (The Brain): A foundation model that operates in the background. It serves as a Visual Judge, looking at "before and after" frames to decide if a task is truly finished.

As shown in the overview below, if a policy returns and the Visual Judge deems the task "Not Done," REA uses an Escalation Ladder to trigger a recovery policy from the current state, drawing from a shared time and step budget.

Overview of the REA architecture showing the interaction between the Policy Library, Router, and Judge.

Datasets

The authors evaluated REA across a massive suite of over 30,000 test episodes:

  • LIBERO-Pro: A newly introduced, more challenging version of the LIBERO benchmark that adds perturbations to objects, positions, and instructions to test robustness.
  • RoboTwin 2.0: A simulator for bimanual (two-armed) manipulation tasks.
  • BEHAVIOR-1K: A large-scale benchmark for everyday household activities.
  • Real-World Hardware: Experiments were conducted on a Unitree G1 humanoid and an AlohaMini2 robotic arm to prove portability.

Key Insights and Ideas

  • Asynchronous is Better: By decoupling the "thinking" from the "acting," REA eliminates robot idle time. System 2 can reason about the next step or judge the previous one while System 0 is already moving.
  • Route Memory is "Free" Intelligence: Instead of asking an LLM "What should I do?" at runtime, REA looks at what worked during development. This provides the performance of an agentic loop at the speed of a frozen policy.
  • Judging vs. Catching: The "Visual Judge" is a game-changer for catching silent failures. As seen in Figure 3, traditional error-triggering is brittle, whereas REA’s boundary-triggered judging allows for robust recovery.
Comparison of three ways to couple a slow brain with fast policies, highlighting REA's uninterrupted execution.
  • Unified Policy Pool: REA is "policy-agnostic." It can manage a mix of neural VLA models and programmatic "Code-as-Policy" scripts in the same runtime, picking whichever is most likely to succeed for a specific task.

Key Results

  • Superior Success: On LIBERO-Pro, REA reached a 95.9% success rate, outperforming the strongest single-agent baselines (94.7%).
  • Efficiency Gains: REA reduced control steps by 25% and total control time by 17% compared to standard agent-led approaches.
  • Robust Recovery: The Visual Judge added a +3.1% success boost over simple exception-based recovery by catching tasks that "finished" but failed.
  • Real-World Portability: REA successfully commanded a Unitree G1 humanoid to walk to and push a chair in 8 out of 10 trials, significantly higher than baseline methods.
Success rate vs. control time on LIBERO-Pro, showing REA-M as the fastest and most successful method.

Limitations and Future Work

While REA significantly improves coordination, it still relies on the underlying quality of the policy library; the "Brain" (System 2) effectively sets the ceiling for what the system can achieve. The authors also noted that while the Visual Judge is precise, it can be "noisy," sometimes undoing a success if it misinterprets a frame.

Future work could involve tighter integration of real-time learning to update the Route Memory dynamically and expanding the system to handle even more complex, multi-stage long-horizon tasks where the "Brain" must play a more active role in mid-stream correction.

Summary updated

Abstract

Foundation models are becoming remarkably reliable at high-level reasoning, yet they remain too slow and costly to serve as fine-grained controllers. Conversely, fast policies like VLAs and whole-body controllers offer more efficient reflexes, but struggle to generalize. While pairing a deliberative brain (foundation models) with a reactive cerebellum (fast policies) seems natural for embodied systems, two obstacles remain: methods are built and scored on incompatible stacks, and their asynchronous coordination is difficult. For example, an agent that calls the VLA in the agentic loop can stall the fast execution, while a VLA that calls the agent on errors tends to re-trigger fallbacks repeatedly or completely miss silent failures. To address this, we propose REA (Routed Embodied Agent), a unified runtime where a deliberative System 2, an embodied router System 1 and reactive System 0 policies cooperate under a single golden rule - no running policy waits on the brain. Instead of querying the brain at each failure, REA employs a route memory that stores each policy's measured success ahead of time, a boundary-triggered judge gate that consults the brain on policy execution, and a shared-budget escalation ladder for bounded recovery. Evaluated on 3,000 test episodes across 60 LIBERO-Pro tasks, REA reaches 95.9% success and beats the best single-agent baseline in its own policy pool (94.7%) while reducing control steps by 25% and control time by 17%. In a separate 100-episode RoboTwin 2.0 study, REA achieves 84% success with VLA policies and 86% with VLA+code, compared with 80% for the strongest single VLA baseline MEDex. These results demonstrate learned and programmatic policies operating within the same runtime. REA also transfers to BEHAVIOR-1K and a real Unitree G1 humanoid, achieving the highest observed success among the compared methods.
BibTeX
@misc{zhou2026rea,
  author = {Pengfei Zhou and Yixing Ma and Zhengfeiyang Zhang and Haoyuan Chen and Zhenglin Wan and Hexin Wang and Wangbo Zhao and Yang You},
  title = {{REA: A Routed Embodied Agent Runtime for Asynchronous Brain-Cerebellum Control}},
  year = {2026},
  eprint = {2610.42053},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2610.42053},
}
Figure