RoboOS-NeXT: Unified Memory for Multi-Robot Collaboration

• RoboOS-NeXT is a unified memory-based framework that leverages a shared spatio-temporal and embodiment memory to drive multi-robot collaboration.
• It integrates a brain–cerebellum hierarchy that links high-level reasoning with low-level execution, enabling dynamic task allocation and effective failure recovery.
• Empirical evaluations demonstrate significant gains in lifelong adaptability, collaborative scalability, and scheduling robustness in varied environments.

Searching arXiv for the specified paper to verify bibliographic details. RoboOS-NeXT is a unified memory-based framework for lifelong, scalable, and robust multi-robot collaboration. It was introduced to address a central limitation in existing multi-agent robotic systems: the lack of a shared representation that spans space, time, and embodiment, which in turn constrains long-horizon learning, heterogeneous coordination, and recovery from failures. At its core is the Spatio-Temporal-Embodiment Memory (STEM), integrated with a brain–cerebellum hierarchy in which a high-level planner performs global reasoning over shared memory and low-level controllers execute actions locally in a closed loop. The framework is evaluated in restaurants, supermarkets, and households, with reported gains in lifelong adaptability, collaborative scalability, and scheduling robustness across heterogeneous embodiments (Tan et al., 30 Oct 2025).

1. Problem formulation and design rationale

RoboOS-NeXT is motivated by service and industrial settings in which robot teams must continually accumulate and reuse experience, coordinate many heterogeneous agents, and recover from hardware or sensing failures. The framework explicitly targets three requirements: lifelong adaptability, scalable collaboration, and robust scheduling (Tan et al., 30 Oct 2025).

The motivating critique is directed at two broad classes of prior systems. Vision–language–action models are described as effective at mapping perception directly to motor commands, but as lacking persistent memory, which causes degradation on long-horizon tasks and weak transfer across embodiments. Hierarchical planners introduce task decomposition, but remain tied to individual-agent state and are characterized as brittle under morphology changes or unexpected errors. The paper identifies a common deficit in both paradigms: the absence of a unified, shared representation that jointly models spatial structure, temporal history, and robot embodiment.

RoboOS-NeXT is therefore organized around memory rather than around isolated policies or per-agent control stacks. The paper states that the system uses a single, shared Spatio-Temporal-Embodiment Memory at its core, coupled to a brain–cerebellum closed loop linking high-level reasoning to low-level action. This suggests that the framework treats memory not as an auxiliary cache but as the primary substrate for coordination, rescheduling, and state synchronization.

2. Spatio-Temporal-Embodiment Memory

The full multi-robot memory at time $t$ is represented as

$M(t) = (S(t), T(t), E(t))$

where $S(t)$ is spatial memory, $T(t)$ is temporal memory, and $E(t)$ is embodiment memory (Tan et al., 30 Oct 2025). The memory is continuously updated by incoming events $\{e_k\}$ through a deterministic update operator:

$$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$

Spatial memory stores scene geometry and object relations. Its structure includes a scene tree $\mathcal{S}_T$, defined as a rooted hierarchy from root to regions to carriers, storing global and regional 3D reconstructions and SLAM poses. It also includes per-carrier object graphs $\{\mathcal{S}_{G,c}\}$, whose nodes hold attributes

$a(v) = (\pi_v, \sigma_v, T_v)$

for object category and size, dynamic state, and pose. Edges encode geometric relations such as $M(t) = (S(t), T(t), E(t))$0 via predicates $M(t) = (S(t), T(t), E(t))$1. Object insertion and movement are defined through update primitives such as:

$\{\mathcal{S}_{G,c}\}$3

with analogous Remove(·) and Move(·) operations. Initial alignment between multi-view images and SLAM uses ICP and PnP solves:

$M(t) = (S(t), T(t), E(t))$2

and

$M(t) = (S(t), T(t), E(t))$3

Temporal memory is an append-only, timestamped queue that logs every spatial or embodiment change:

$M(t) = (S(t), T(t), E(t))$4

where $M(t) = (S(t), T(t), E(t))$5 and $M(t) = (S(t), T(t), E(t))$6 are deltas to spatial and embodiment memory, $M(t) = (S(t), T(t), E(t))$7 is the task ID, $M(t) = (S(t), T(t), E(t))$8 is the prerequisite subtask queue, and $M(t) = (S(t), T(t), E(t))$9 records each tool call as (tool, args, status∈{ok,fail}, feedback).

Embodiment memory maintains a heartbeat-updated profile for each robot $S(t)$0:

$S(t)$1

where the components encode location in $S(t)$2, skill set, resources such as battery and CPU, sensor snapshot, and availability $S(t)$3.

To support retrieval and planning, the three memory components are embedded as

$S(t)$4

and fused through a learned function

$S(t)$5

Memory reads use an attention-style similarity, where a query $S(t)$6 scores past events $S(t)$7 according to

$S(t)$8

and retrieval returns a weighted sum. Writes append to temporal memory and trigger local updates in spatial and embodiment memory. A plausible implication is that the temporal log serves as the authoritative write path, while spatial and embodiment structures act as query-efficient materializations.

3. Brain–cerebellum hierarchy and closed-loop execution

RoboOS-NeXT places the STEM substrate beneath a two-tier hierarchy composed of a brain and a cerebellum (Tan et al., 30 Oct 2025). The brain is a global planner implemented as a retrieval-augmented generation LLM. It reads the spatial, temporal, and embodiment embeddings together with a global instruction $S(t)$9, and produces both a reasoning trace and a workflow graph:

$T(t)$0

where $T(t)$1 is a chain-of-thought rail and $T(t)$2 is a workflow graph whose elements are subtasks $T(t)$3, depths $T(t)$4, and assigned agents $T(t)$5.

The cerebellum consists of low-latency local skills such as navigation, grasp, and place. These skills are invoked by each robot’s local agent. During execution, skill calls query STEM for parameters such as target object poses, execute locally, and then log outcomes back into temporal memory for feedback-driven error recovery. The framework therefore couples high-level planning, memory retrieval, motor execution, and memory update within a recurrent loop.

The paper gives the following high-level closed-loop pseudocode:

$\{\mathcal{S}_{G,c}\}$4

A common misreading would be to regard RoboOS-NeXT as only a hierarchical planner. The formulation instead defines a memory-centric closed loop in which planning is conditioned on unified memory, execution modifies that memory, and subsequent planning reuses the updated state. This interpretation follows directly from the integration of STEM with the brain–cerebellum hierarchy.

4. Task allocation, scheduling, and fault tolerance

Once the workflow graph $T(t)$6 is generated, a Monitor schedules subtasks under two modes (Tan et al., 30 Oct 2025). Parallel allocation is used for subtasks at the same depth when no cross-dependency exists. Sequential allocation enforces that a subtask $T(t)$7 at depth $T(t)$8 waits until all tasks at depth $T(t)$9 finish. This defines a depth-structured scheduling regime compatible with the workflow graph emitted by the brain.

The scheduling objective is to minimize makespan. Let $E(t)$0 be the completion time of subtask $E(t)$1, $E(t)$2 its processing time, and $E(t)$3 the set of precedence edges. The optimization problem is

$E(t)$4

subject to

$E(t)$5

with the additional constraint that each subtask is assigned to one or more robots drawn from embodiment memory $E(t)$6 so that capability is guaranteed.

Fault tolerance is implemented through memory-mediated rescheduling. Robot-offline or tool-failure events create new update entries in temporal memory, which prompt the Monitor to re-solve the partial schedule and re-allocate unfinished subtasks to available agents. Because robot status and tool sets are maintained in embodiment memory $E(t)$7, the paper characterizes this rescheduling as swift and consistent.

The architecture therefore treats failure not as an external exception mechanism but as a first-class event type within the same memory system used for normal operation. This suggests a unification of nominal execution and recovery behavior: both are represented as updates over shared memory.

5. Empirical evaluation

The reported evaluation spans 200 tasks in each of three domains—restaurants, supermarkets, and households—covering simple (L1), medium (L2), and complex (L3) instructions over varying sequence lengths $E(t)$8 (Tan et al., 30 Oct 2025). The metrics are Success Rate (SR%), Marginal Success Rate (MSR%) on the last task of each sequence, Average Execution Steps per Task (AEST), and Success-per-Step (SS).

The principal empirical claims concern lifelong adaptability, collaborative scalability, and scheduling robustness. For lifelong adaptability, the paper highlights Restaurant L2 at $E(t)$9: baseline MSR is $\{e_k\}$0, whereas RoboOS-NeXT reaches $\{e_k\}$1; AEST decreases from $\{e_k\}$2 to $\{e_k\}$3, a reported $\{e_k\}$4. For collaborative scalability, increasing the team from $\{e_k\}$5 wheeled robots reduces AEST from $\{e_k\}$6, corresponding to reported changes of $\{e_k\}$7 and $\{e_k\}$8, while SR declines only mildly from $\{e_k\}$9. Success-per-step rises from $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$0 to $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$1. For scheduling robustness, under robot offline (E1), tool failure (E2), or hallucination (E3), RoboOS-NeXT sustains SR approximately $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$2–$$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$3, whereas the baseline drops to $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$4–$$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$5.

Evaluation aspect	Reported condition	Reported result
Lifelong adaptability	Restaurant L2, SQ=5	MSR: $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$6; AEST: $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$7
Collaborative scalability	1, 3, 5 wheeled robots	AEST: $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$8; SR: $$M(t) = \mathrm{Reduce}(\mathcal{U}, M_0, \{e_1,\ldots,e_t\}).$$9
Scheduling robustness	E1, E2, E3	SR approximately $\mathcal{S}_T$0–$\mathcal{S}_T$1 vs. baseline $\mathcal{S}_T$2–$\mathcal{S}_T$3

Ablation results on Household L1 with $\mathcal{S}_T$4 are used to isolate the contribution of each memory dimension. Removing spatial memory yields $\mathcal{S}_T$5 and $\mathcal{S}_T$6. Removing temporal memory yields $\mathcal{S}_T$7 and $\mathcal{S}_T$8. Removing embodiment memory yields $\mathcal{S}_T$9. The paper interprets these results as confirming that all three memory dimensions are indispensable: spatial memory for efficient exploration, temporal memory for long-horizon consistency, and embodiment memory for coordinating multiple agents.

Failure analysis over 200 restaurant trials attributes errors to three sources: $\{\mathcal{S}_{G,c}\}$0 subtask generation errors, described as LLM decomposition misorders; $\{\mathcal{S}_{G,c}\}$1 tool invocation errors, described as parameter drift; and $\{\mathcal{S}_{G,c}\}$2 memory operation errors, described as noise accumulation. These figures localize the dominant failure mode in tool invocation rather than in subtask decomposition or memory operation.

6. Limitations, interpretation, and future directions

The paper’s own interpretation is that unified shared memory enables lifelong learning, parallel use of many heterogeneous robots, and absorption of common failures through replanning, in contrast to purely episodic vision–language–action systems or per-agent hierarchical systems (Tan et al., 30 Oct 2025). At the same time, it identifies two principal weaknesses: the structural priors of LLM-based subtask generation and the fidelity of memory–perception grounding.

The listed future directions are specific. They include tighter integration of perceptual grounding, such as object trackers or learned keypoint networks, to reduce tool parameter drift; more robust memory retrieval through temporal-consistency regularizers or contrastive memory losses to limit drift over hundreds of events; hybrid symbolic/neural subtask planners to enforce stronger DAG constraints; and scaling to hundreds or thousands of robots with distributed memory partitions.

These prospective extensions clarify the present scope of RoboOS-NeXT. The framework already couples shared memory, global planning, local control, and runtime rescheduling, but the reported failure analysis indicates that decomposition quality, parameter grounding, and memory fidelity remain active constraints. A plausible implication is that the architecture is less limited by the existence of a memory substrate than by the precision with which perception, retrieval, and planning interact through that substrate.