Summary (Overview)

• Embodied.cpp is a portable C++ inference runtime designed for embodied AI models, supporting both vision-language-action (VLA) models and world-action models (WAMs) on heterogeneous edge devices (Jetson, RK-based boards, x86, etc.).
• The runtime introduces a five-layer architecture (input adapters, sequence builders, backbone execution, head plugins, deployment adapters) that captures a shared execution path while keeping diverging components as pluggable modules.
• Three design principles guide the system: modular multi-rate execution (different modules run at different frequencies), latency-first fused inference (batch-1, low-jitter execution), and extensible operator/I/O support (beyond fixed token interfaces).
• Evaluation on two VLA models (HY-VLA and pi0.5) achieves 100.0% and 91.0% task success rates respectively in closed-loop settings; a WAM microbenchmark on a LingBot-VA Transformer block reduces block memory from 312.2 MiB to 88.1 MiB (Q4_K quantization) with minimal output drift (MAE < 3.3e-2, cosine similarity > 0.9997).
• The project is open-source (GitHub: SEU-PAISys/Embodied.cpp) and aims to unify embodied model deployment across diverse hardware, robots, and simulators.

Introduction and Theoretical Foundation

Background: Embodied AI models (VLA and WAM) have advanced rapidly, but practical deployment remains fragmented due to model-specific Python stacks, backend assumptions, and robot-side glue code. Existing inference runtimes (e.g., llama.cpp, ONNX Runtime, SGLang, vLLM-Omni) are designed for request-response serving and fail to meet the unique needs of embodied deployment.

Motivation: Embodied deployment imposes a different "runtime contract":

1. Multi-rate execution: Perception encoders, transformer backbones, predictive branches, and action heads may need to run at different rates within the same control loop (as in hierarchical and asynchronous VLA systems, and WAMs).
2. Latency-first closed-loop control: Optimization target is not throughput but stable control—low latency, low jitter, and efficient batch-1 inference on heterogeneous edge hardware.
3. Extensible embodied interfaces: Inputs (images, language, proprioception, force, tactile, simulator state) and outputs (discrete action tokens, continuous vectors, action chunks, world predictions, intermediate representations) go far beyond fixed token I/O.

Theoretical Basis: An architectural analysis of representative embodied models (Figure 1, Table 1) reveals a shared execution path: from perception/instruction inputs through a backbone (often transformer-based) to action/prediction heads. The main divergences are confined to head plugins and predictive modules. This convergence motivates a runtime that treats the common path as infrastructure and the diverging parts as plugins.

Related Work Comparison (Table 2): Existing systems either lack first-class VLA/WAM support, modular optimization, edge deployment capabilities, or direct robot/simulator integration. vla.cpp is the closest but remains VLA-centric. Embodied.cpp aims to fill this gap.

Methodology

Design Principles:

1. Modular multi-rate execution: Expose explicit execution units, pluggable modules, shared state pools, and configurable refresh policies so components can run at different frequencies.
2. Latency-first fused execution: Prioritize stable control performance with graph replay, buffer reuse, operator fusion, backend-specific dispatch, and careful host-device data movement for efficient batch-1 inference.
3. Extensible operator and I/O support: Provide typed embodied interfaces, pluggable heads, first-class deployment adapters, and broad backend/operator coverage.

Runtime Architecture (Figure 2):

• Five layers: Input adapters → Sequence builders → Backbone execution → Head plugins → Deployment adapters.
• Input adapters absorb online sensor streams (camera, force, tactile, IMU) and offline dataset samples (LIBERO, DROID, BridgeData, RT-X) through a typed embodied interface.
• Backbone execution handles transformer-style computation with backend abstraction for CPU, GPU, NPU.
• Head plugins allow model-specific action decoders, world predictors, etc.
• Deployment adapters bridge outputs to simulators (ManiSkill, Isaac Sim) and real robots.
• Supporting subsystems: Modular multi-rate execution engine, latency-first batch-1 heterogeneous HW execution, and an embodied AI kernel warehouse for reusable operators and model-specific kernels.

Implementation: Built on C++ for portability; leverages GGUF quantization for memory-efficient deployment.

Empirical Validation / Results

VLA model evaluation (Table 3):

• HY-VLA tested on RoboTwin place_empty_cup task; pi0.5 with its C++ deployment config.
• Both models run correctly through the C++ runtime while preserving task behavior.
• HY-VLA has higher latency due to larger backbone, three-view inputs, and video-history/MEM vision path. pi0.5 benefits from lighter backbone and longer action chunk (lower amortized step cost).

WAM microbenchmark (Table 4):

• Benchmark on LingBot-VA first Transformer block (WanTransformerBlock).
• Quantized C++ block reduces weight memory from 312.2 MiB to 88.1 MiB (71.8% reduction) with minimal output drift (MAE < 3.3e-2, cosine similarity > 0.9997). Latency remains comparable (3.171 ms vs 3.236 ms).
• Preliminary evidence that Embodied.cpp can host WAM components with significant memory savings and high fidelity.

Theoretical and Practical Implications

• Theoretical: The architectural analysis confirms that embodied models (both VLA and WAM) share a common execution path, with divergences limited to pluggable heads/predictive modules. This convergence justifies a unified runtime design.
• Practical:
  • Enables deployment of diverse embodied models on heterogeneous edge hardware without per-model software stack rewriting.
  • Multi-rate execution allows efficient scheduling (e.g., perception running at lower frequency than control).
  • Extensible interfaces support future model families (new heads, custom operators, new sensor types) through plugin mechanisms rather than one-off integration.
  • Quantization and latency-first execution make high-performance batch-1 inference feasible on resource-constrained robots.
  • Direct robot/simulator adapters reduce integration burden for real-world deployment.

Conclusion

Embodied.cpp captures the converging shared execution path of embodied AI models in a portable C++ inference runtime. Its five-layer architecture treats the common path as infrastructure and diverging model-specific components as plugins, enabling multi-rate execution, latency-first fused inference, and extensible I/O. Evaluation on two VLA models (100.0% and 91.0% success rates) and a WAM microbenchmark (71.8% memory reduction with minimal drift) demonstrates improved deployment efficiency while preserving accuracy. Future directions include full LingBot-VA closed-loop WAM evaluation, support for more model families, and further optimization for on-robot execution. The separation between a stable core and pluggable task-specific components becomes increasingly valuable as embodied model variants continue to diversify.