Efficient Coordination with the System-Level Shared State: An Embodied-AI Native Modular Framework

TL;DR

The paper tackles the brittleness and interface drift that arise when Embodied AI systems evolve under workload changes and partial failures. It proposes ANCHOR, a modular framework built around Canonical Records as a shared-state contract and a high-concurrency Communication Bus to enable many-to-many coordination and closed-loop feedback. The authors demonstrate end-to-end feasibility through a de-identified workflow and characterize latency under load, plus automatic recovery after hard crashes with shared-memory loss, showing controlled degradation and self-healing properties. The work advances practical robustness for scalable, iterative embodied-AI deployments by making shared state and coordination explicit system primitives, enabling safer, more maintainable, and extensible architectures with explicit runtime semantics and recovery paths.

Abstract

As Embodied AI systems move from research prototypes to real world deployments, they tend to evolve rapidly while remaining reliable under workload changes and partial failures. In practice, many deployments are only partially decoupled: middleware moves messages, but shared context and feedback semantics are implicit, causing interface drift, cross-module interference, and brittle recovery at scale. We present ANCHOR, a modular framework that makes decoupling and robustness explicit system-level primitives. ANCHOR separates (i) Canonical Records, an evolvable contract for the standardized shared state, from (ii) a communication bus for many-to-many dissemination and feedback-oriented coordination, forming an inspectable end-to-end loop. We validate closed-loop feasibility on a de-identified workflow instantiation, characterize latency distributions under varying payload sizes and publish rates, and demonstrate automatic stream resumption after hard crashes and restarts even with shared-memory loss. Overall, ANCHOR turns ad-hoc integration glue into explicit contracts, enabling controlled degradation under load and self-healing recovery for scalable deployment of closed-loop AI systems.

Figures (5)

• Figure 1: ANCHOR system overview. Upstream ingestion normalizes heterogeneous inputs into Canonical Records; inference consumes records and publishes commands/actions to the communication bus; execution subscribes and produces status/events; feedback is materialized back into Canonical Records, forming an explicit closed loop without a centralized monolithic controller.
• Figure 2: Canonical Records as an explicit shared-state contract. A memmap-backed region stores normalized observations and system context with an agreed layout and update conventions, enabling cross-process sharing, persistence, and controlled schema evolution.
• Figure 3: Communication bus roles and routing. A master maintains subscriptions and forwards messages within a cluster; gateways bridge cross-cluster traffic; nodes publish/subscribe to commands/actions and status/events for many-to-many coordination and feedback.
• Figure 4: Message-bus delivery latency ECDFs under a 1$\times$1 setup for four (payload size, publish rate) configurations.
• Figure 5: Delivered throughput over time under a controlled hard crash and restart.