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

REA. A Routed Embodied Agent Runtime for Asynchronous Brain-Cerebellum Control. By Pengfei Zhou and seven others, from the HPC-AI Lab at the National University of Singapore, InfRec's Cardinal AI Lab, and four other institutions. Published on the thirtieth of October.

Foundation models are becoming remarkably reliable at high-level reasoning, but they are too slow and too costly to act as fine-grained controllers. Fast policies, such as VLAs and whole-body controllers, have quicker reflexes but struggle to generalize. Pairing a deliberative brain with a reactive cerebellum looks like the natural arrangement for embodied systems, and two obstacles stand in its way. Methods are built and scored on incompatible stacks. And coordinating the two halves asynchronously is hard.

The abstract gives the failure in both directions. An agent that calls the VLA inside its agentic loop can stall the fast execution. A VLA that calls the agent on errors tends either to re-trigger fallbacks again and again, or to miss silent failures entirely.

REA, short for Routed Embodied Agent, is a unified runtime with three tiers. A deliberative System 2 does the reasoning. An embodied router, System 1, sits in the middle. Reactive System 0 policies do the acting. All three cooperate under a single golden rule: no running policy waits on the brain. The slow part is never allowed to block the fast part. The rule answers the first failure direction directly, since an agent can no longer stall the policy it called. The question that remains is how the brain gets involved at all, without being queried after every error.

Instead of querying the brain at each failure, REA leans on three mechanisms. The first is a route memory, which stores each policy's measured success, recorded ahead of time rather than discovered during the run. The second is a boundary-triggered judge gate, which consults the brain on policy execution. The third is a shared-budget escalation ladder for recovery. Recovery climbs the ladder step by step, and because every step draws on one shared budget, the recovery stays bounded rather than looping on the same fallback. Taken together, these replace the pattern of calling the brain on every error, the pattern that re-triggers fallbacks and misses silent failures.

The main evaluation covers three thousand test episodes across sixty LIBERO-Pro tasks. REA reaches ninety-five point nine percent success. That beats the best single-agent baseline drawn from its own policy pool, at ninety-four point seven percent, while cutting control steps by twenty-five percent and control time by seventeen percent. The baseline is drawn from the same pool of policies REA routes between, so the comparison is against the best that any one of those policies managed on its own.

A separate study on RoboTwin 2.0 runs one hundred episodes. With VLA policies REA reaches eighty-four percent success, and with VLA plus code, eighty-six percent. The strongest single VLA baseline, MEDex, reaches eighty percent. Learned and programmatic policies, in other words, operate inside the same runtime. REA also transfers to BEHAVIOR-1K and to a real Unitree G1 humanoid, with the highest observed success among the compared methods.

One rule organizes the whole system. Since no running policy may wait on the brain, the brain's judgment has to reach the fast policies by other routes: a memory filled in beforehand, a gate at execution boundaries, and a ladder with a shared budget. The reflexes keep running, and deliberation is called in at defined points instead of at every stumble.

REA. A Routed Embodied Agent Runtime for Asynchronous Brain-Cerebellum Control. By Pengfei Zhou and seven others, from the HPC-AI Lab at the National University of Singapore, InfRec's Cardinal AI Lab, and four other institutions. Published on the thirtieth of October. This is the long version: the whole paper rather than the abstract.

A coding agent can now write a robot manipulation program that calls segmentation, grasp planning and inverse kinematics. That ability is slow and expensive: in the authors' runs, a Codex pipeline consumed eighty-nine million input tokens writing programs for sixty tasks. Nor can the brain simply drive the robot. Models emitting one action token at a time solved one of one thousand nine hundred and eighty-seven LIBERO-Pro episodes. Fast vision-language-action policies act at a few to tens of hertz, but collapse off their training distribution.

Pairing a slow brain with a fast cerebellum is the obvious answer, and the paper argues the pairing itself is where things break. If the agent calls the fast policy, the robot waits on every decision: an advisor the router waited for left it idle a fifth of its control time. If the fast policy calls the agent on errors, most failures never call at all.

Two ideas come first. The first is the silent failure. A policy can return cleanly, raise no exception, and leave the task undone: a program told to turn on the stove returns with no error, and the stove is still off. The second is that re-running is not free. If the task already succeeded, running a policy again may undo it. Recovery has to know when to stop as much as when to retry.

The runtime, REA, short for Routed Embodied Agent, has three levels. System Two is the brain: an agent that writes candidate policies offline and, online, can advise or judge. System Zero is the cerebellum: frozen programs, VLA policies or whole-body controllers, each running its own loop at native rate. Between them, System One is the router. It emits no actions. It decides which policy runs and when the brain is consulted, under one rule: no running policy waits on the brain.

Three modules make the rule hold. The first is route memory. Before testing, the router runs each candidate policy on development episodes, with seeds kept apart from the test seeds, and stores its success rate and mean steps. At test time, dispatch is a lookup: highest development success, ties broken by fewer steps. No model is called.

The second is the boundary-triggered judge gate. It fires once every time a policy returns, not on errors. A vision-language model sees the episode's first frame, the current frame and the instruction, and answers done or not done. Done ends the episode, protecting completed work. Not done escalates. The first frame matters: in calibration on two hundred and sixteen development labels, removing it made precision and recall collapse.

The third is the escalation ladder: the first policy, then the other, then the first again. Each rung starts from the current state, not a reset, and every run and judge call draws on one shared step and time budget, so an episode never exceeds a single policy's allowance. Success is read once, after the last run, for evaluation only. The paper's variants are REA-M, route memory with a free exception gate; REA-A, an agent choosing policies; and REA-V, route memory with the visual judge.

On three thousand test episodes across sixty LIBERO-Pro tasks, routing reached ninety-five point nine percent, against ninety-four point seven for the best single method in its own pool, within one percent of a hindsight oracle. It also took a quarter fewer steps per success.

The comparison that most directly tests the thesis is where the brain sits. An agent choosing the policy at dispatch reached exactly the same ninety-five point nine percent, only slower. A blocking advisor left the robot idle two point six two seconds per episode and gained nothing. It overrode route memory in one thousand two hundred and thirty-six episodes, and route memory's own choice solved more of those. REA-M was the fastest timed method.

The judge earns its place where policies fail silently. On ASPIRE's Fix-loop programs, route memory lifted success from sixty-six point three to seventy-one point nine percent, and the judge gate added three point one points more, at about twice the wall time per success. The surprise is how noisy the judge is: its final verdicts are barely more accurate than always answering done. It helps because its done verdicts are precise, and because re-running a finished task rarely breaks it. Re-runs converted nineteen percent of failed first runs and undid nine percent of successful ones.

The paper has no limitations section, though its Discussion and appendices flag a good deal. The headline gain over the best single method is one point two points: significant, but small. The judge's fifteen point three point gain comes from a subset selected for failures; the authors say three point one is the estimate to expect, and call their account of the noisy judge a consistent explanation, not a tested mechanism.

Transfer results are thinner. On BEHAVIOR-1K the margin over the Agents SDK agent is not significant and comes from one task. On RoboTwin, the same configuration moved by thirty-six scenes between two nights. The VLA study mixes new runs with historical baselines. The real robots get ten trials per method, and on both, higher success came with longer runtime.

The idea to carry away is a placement rule for the slow model. Use the brain ahead of time, to write policies and to have already settled which one runs. Use it again when a policy returns, as a judge of a before and after picture. Never put it inside a running policy: as a controller it solved almost nothing, and as an advisor in the loop it made the robot wait. The router emits no actions. What it decides is timing: when the brain is allowed to speak.