Modular Virtual Robot Abstraction: Unified Approach

• Modular virtual robot abstraction is a representation method where robots are modeled as interchangeable modules, decoupling task specifications, morphology, and interfaces.
• It employs diverse formalisms like contextual MDPs, graph models, and URDF/Xacro synchronization to bridge simulation and physical deployment.
• This approach supports integrated learning, planning, and co-optimization, enabling robust policy generalization and flexible reconfiguration across dynamic environments.

Modular virtual robot abstraction denotes a class of representations in which a robot is modeled as a composition of modules while planning, control, simulation, or user interaction is conducted through a higher-level description rather than a fixed embodiment. In the cited literature, this appears as contextual MDPs in which each robot morphology defines a context $c$, virtual modules that serve as segmentation markers in manipulator encodings, directed graph models of modules and assemblies, URDF/Xacro-based descriptions synchronized with hardware, and simulation environments with interface equivalence to the physical platform (Engwegen et al., 10 Jun 2025, Lei et al., 18 Dec 2025, Külz et al., 2022, Antony et al., 19 Mar 2026). This suggests that modular virtual robot abstraction is best understood not as a single formalism, but as a unifying strategy for decoupling task specification, morphology, and software interfaces across reconfigurable robotic systems.

1. Conceptual scope

The literature uses the concept in several distinct but related senses. In universal morphology control, the abstraction is a policy-level representation over a robot family: each morphology is treated as a context in a CMDP, and the controller is expected to generalize across arbitrary robot bodies from the UNIMAL design space in MuJoCo (Engwegen et al., 10 Jun 2025). In modular manipulator design, abstraction is explicitly topological: a morphology is encoded as a vector $\bm{C}_v$ containing hardware-module IDs and special virtual modules that do not correspond to physical hardware but partition the chain into multiple segments, allowing both single-branch and bi-branch morphologies to be described in a chain-type format (Lei et al., 18 Dec 2025).

A second usage emphasizes software-defined embodiment. The Robot Of Theseus (TROT) maintains a mapping between the “virtual robot” used for planning or simulation and the “physical robot” given by the current hardware configuration, with synchronization achieved through URDF and associated configuration files (Urs et al., 19 May 2025). In construction automation, the abstraction is described as a software-driven representation of modular reconfigurable robots in which modules are virtual building blocks used for synthesis, feasibility checking, and optimization before physical assembly (Külz et al., 2024).

A third usage is interface-centric. The LIPI Networked Robot and the earlier microcontroller-based modular networked robot divide the system into main unit, data acquisition, and data processing modules, while exposing control and monitoring through an integrated web interface (0812.0070, 0809.0727). In social robotics, M separates perception, expression control, and data management, and couples this with a simulation environment whose interfaces are equivalent to hardware (Antony et al., 19 Mar 2026). Taken together, these works indicate that abstraction may target morphology, kinematics, control authority, software composition, or user-facing access, depending on the problem domain.

2. Representational formalisms

One major formalism is morphology as context under partial observability. In "Modular Recurrence in Contextual MDPs for Universal Morphology Control" (Engwegen et al., 10 Jun 2025), observable context includes mass, geometric parameters, initial positions wrt parent limb, and joint angle limits, while unobservable context includes friction, damping, full adjacency/topology, and interactions among limbs. The central hypothesis is that many relevant morphological properties are only partially observable and therefore must be inferred from experience. For each limb $i$, the local action-observation history is

$$\tau_t^{i} = (o_0^{i}, a_0^{i}, \dots, a_{t-1}^{i}, o_t^{i}),$$

and the shared recurrent update is

$h_t^{i} = \text{RNN}(o_t^i, a_{t-1}^i, h_{t-1}^i).$

The policy is then conditioned on the set of limb hidden states. This formulation makes memory itself modular: each limb maintains its own RNN-encoded history, and all limbs share RNN weights.

A second formalism is explicit topology encoding by virtual modules. In the planner-in-the-loop framework for modular manipulators (Lei et al., 18 Dec 2025), virtual modules are “segmentation markers” inserted into the module sequence vector $\bm{C}_v$. When such a module is present, the chain is partitioned into multiple segments, and a Y connector hardware module links the branches in the physical robot. The paper further embeds discrete morphology and continuous mounted pose into a continuous search space by a sorting-based mapping $\bm{C}_v = g(\bm{M})$, enabling CMA-ES to explore hybrid design variables without switching to a separate representation for branched topologies.

A third formalism is graph-based abstraction. Timor models each module as a directed graph $G_{m_i} = (V_{m_i}, E_{m_i})$, where vertices correspond to bodies, joints, and connectors, and edges carry the relative homogeneous transformation between reference frames (Külz et al., 2022). Assemblies are represented by a directed assembly graph $G_a$, and transformations along paths are composed as

$$T(F_u, F_v) = T_{e_1} \cdot T_{e_2} \cdot \ldots \cdot T_{e_n}.$$

This provides a uniform representation for model generation, simulation export, and optimization.

Task-oriented manipulator design uses yet another abstraction layer: the robot is first described by DH parameters $\bm{C}_v$0, then directly mapped to a modular unit sequence such as $\bm{C}_v$1 (Dogra et al., 2021). This is a notable contrast with brute-force composition search: the optimized virtual configuration is treated as primary, and physical modular composition is derived from it by rule-based conversion. Across these formalisms, the common structure is compositionality: modules are first-class entities, and the virtual description is designed to survive reconfiguration.

3. Software architecture and interface patterns

The architectural literature consistently treats modular abstraction as a separation-of-concerns problem. The LIPI Networked Robot divides the system into three abstract modules: Main Unit, Data Acquisition Module, and Data Processing Module (0812.0070). Linux on the main unit provides networking and intra-system communication, application logic reaches lower-level signal processing and actuator control through software drivers and interface routines, and the web interface abstracts all user interaction so that only a browser is required. The earlier microcontroller-based modular networked robot presents essentially the same tri-part decomposition and emphasizes software-dominated DSP, standardized command/data protocols, and remote accessibility over the web (0809.0727).

Later systems formalize this modularity through middleware and typed interfaces. TROT uses two Raspberry Pi 4B boards, one for low-level actuator/sensor interface and one for control, planning, and simulation, with Lightweight Communication and Marshaling (LCM) providing message-based APIs and an open-source controller framework adapted from the MIT Mini Cheetah’s Cheetah-Software (Urs et al., 19 May 2025). M is ROS2-native and cleanly separates perception, expression control, and data management; sensor streams are exposed as ROS2 topics, expressive behaviors are defined as timed, parameterized sequences, and the m-logging package synchronizes sensor inputs, system events, and interaction state (Antony et al., 19 Mar 2026).

Simulation frameworks make these boundaries more explicit. robosuite organizes the environment as a composition of RobotModel(s), GripperModel(s), Arena, Object(s), controllers, sensors, and I/O devices, with abstract base classes and a factory-like make() interface (Zhu et al., 2020). MRTA-Sim exposes a pipeline of Allocation Solver, Task Allocator, Room Queues, Waypoint Generator, Path Planner, Controller, and Gazebo Simulation, with ROS2 topics and services mediating exchange between layers and allowing individual components to be swapped independently (Tuck et al., 21 Apr 2025). These systems show that modular virtual robot abstraction is not only a modeling choice; it is also an architectural commitment to replaceable modules with stable APIs.

4. Learning, planning, and control over abstractions

The strongest evidence for the value of abstraction appears in controller generalization and design co-optimization. In universal morphology control, R-MeMo and R-MoMo extend MetaMorph and ModuMorph by inserting limb-wise recurrence before transformer-based multi-limb integration (Engwegen et al., 10 Jun 2025). The recurrent variants outperform the non-recurrent baselines in all environments for unseen dynamics and kinematics, and on 70 unseen topologies R-MoMo achieves $\bm{C}_v$2 on Flat Terrain, $\bm{C}_v$3 on Incline, $\bm{C}_v$4 on Variable Terrain, and $\bm{C}_v$5 on Obstacles, exceeding the corresponding MetaMorph and ModuMorph results listed in the paper. Because training performance is comparable while test performance improves, the authors interpret recurrence as enabling genuine context inference rather than overfitting.

In modular manipulation, the virtual module abstraction supports joint morphology-and-pose design. The framework couples hierarchical model predictive control (HMPC) with CMA-ES over a representation that includes virtual modules and mounted pose (Lei et al., 18 Dec 2025). HMPC serves as a unified motion planning backbone for both redundant and non-redundant manipulators, while bi-branch morphologies emerge during optimization when advantageous. The reported outcome is that the framework can generate multiple feasible designs satisfying kinematic and dynamic constraints while avoiding environmental collisions, can realize flexible objectives such as maximizing manipulability or minimizing joint effort, and can produce a bi-branch morphology capable of operating in a large workspace without requiring more powerful basic modules.

Aerial modularity provides a further generalization of the same idea. MARS-Dragonfly introduces a force-torque-equivalent and polytope-constraint virtual quadrotor that maps arbitrary connected drone formations into a control abstraction compatible with existing quadrotor controllers (Huang et al., 7 Apr 2026). A constrained predictive tracker computes virtual inputs while respecting force/torque bounds, and a dynamic allocator maps these inputs to individual modules. In real-world experiments, this enables agile flight and transport with 40 deg peak pitch while maintaining an average position error of 0.0896 m.

Related work on hierarchical learning and modular optimization reinforces the same pattern. MLSH-based control for modular SCARA robots uses a master policy to select shared motor primitives across 3DoF and 4DoF configurations and transfers the learned network from simulation to real hardware (Kojcev et al., 2018). PyRoki formulates kinematic optimization as

$\bm{C}_v$6

over modular kinematic variables and costs, and reports optimization benchmarking in which it can be 1.4-1.7x faster and converges to lower errors than cuRobo (Kim et al., 6 May 2025). In each case, the abstraction reduces embodiment-specific rewriting and exposes a reusable control surface.

5. Model generation, simulation, and virtual-to-physical synchronization

A recurring theme is that abstraction must be recoverable from the assembled robot and transferable back to hardware. The vision-based kinematic construction method for re-configurable modular robots uses AR tags with unique IDs, a module database, and geometric constraints to identify parent-child relations and automatically generate a kinematic chain and URDF/Xacro model (Lin et al., 2017). The process proceeds from image acquisition and marker detection to database query, chain construction, joint-angle estimation, and visualization. This is significant because it removes the assumption that the modular structure is already known to the software stack.

TROT approaches the same issue from the opposite direction: morphology changes are encoded by updating the URDF and corresponding parameter files, and kinematics and dynamic models such as contact Jacobian and limb end-effector transforms are auto-updated based on the URDF description (Urs et al., 19 May 2025). The mapping between virtual robot and physical robot is maintained by synchronizing software description and physical assembly. This enables parameter sweeps over morphology and gait while keeping the control stack morphology-aware.

Simulation frameworks generalize these ideas to software ecosystems. Timor offers URDF export of arbitrary modular robot assemblies and direct Pinocchio model generation; in the reported IMPROV study it generated 32,768 valid six-DoF robot configurations in 127 seconds, corresponding to 3.9ms per model (Külz et al., 2022). The VR-based workspace framework imports robots from URDF into Unity, uses Unity Robotics Hub with a ROS backend, records demonstrations as trajectories or DMP parameters, and then executes the task on a real robot (Tram et al., 2023). M extends this principle through interface equivalence: the simulation exposes the same ROS2 message, service, and action interfaces as the physical robot, including perception and expression topics and services (Antony et al., 19 Mar 2026). A common implication is that virtual abstraction becomes most useful when it is operationally identical, or nearly identical, to the interface used at deployment time.

6. Applications, misconceptions, and limitations

The applications are broad, but they also clarify what the abstraction is not. In construction automation, a BIM-based interface specifies tasks, a robot synthesis module optimizes morphology, and the resulting design is physically assembled and executed; the reported system compensates for base placement errors up to 16cm and 12.6°, achieves end-to-end precision of drill holes within 1cm, and can reduce re-assembly time to as little as 5 minutes when a configuration is similar to a previous task (Külz et al., 2024). In biomechanics, TROT costs approximately $4000 to build, supports modular legs with 2 or 3 rigid links, telescoping mechanisms, configurable joints, and open-source software for user-defined gaits and morphology changes (Urs et al., 19 May 2025). In networked monitoring robots, modularity is tied to low development cost, remote access over the web, and partial replacement of modules according to user needs (0812.0070, 0809.0727).

A common misconception is that modular virtual robot abstraction is synonymous with simulation alone. The surveyed work contradicts this. In some papers, the abstraction is a learned latent context for zero-shot policy transfer (Engwegen et al., 10 Jun 2025); in others it is a topology encoding for co-design (Lei et al., 18 Dec 2025), a graph model for automated synthesis (Külz et al., 2022), or a web-mediated software boundary between sensing, processing, and control (0812.0070). Another misconception is that modularity is purely mechanical. Several systems explicitly shift intelligence upward into software, including software-defined DSP and control in networked robots, cost-based optimization in PyRoki, and interface-equivalent simulation in M (0809.0727, Kim et al., 6 May 2025, Antony et al., 19 Mar 2026).

The limitations are equally consistent. Universal morphology control still faces partial observability of friction, damping, and full topology, and the memory scaling cost of modular recurrence grows with the number of limbs (Engwegen et al., 10 Jun 2025). Timor notes that URDF generation applies to tree-like kinematic structures because URDF does not support closed-loops (Külz et al., 2022). The vision-based identification method is especially suited to tree- or chain-type modular robots, even though the general optimization-based approach can accommodate more complex branching and looped topologies (Lin et al., 2017). Kernaug states that hardware modularity is so hard to implement but is being pursued even partially, and also notes trade-offs among security, computational power, and battery life (Rachdi et al., 2022). These constraints indicate that abstraction does not eliminate embodiment-specific difficulty; rather, it reorganizes that difficulty into explicit models, interfaces, and optimization variables.

Across these strands, modular virtual robot abstraction functions as an engineering and scientific device for separating what must change from what should remain stable. Morphology, sensing packages, topology, and actuation can vary, while policies, planners, controllers, user interfaces, and model-generation pipelines operate over an intermediate representation. The surveyed literature shows that this intermediate layer may be recurrent state, a module-sequence vector, a graph, a URDF/Xacro description, a ROS/ROS2 API, or a virtual controller model, but its role is consistent: to make reconfigurable robots computationally tractable, experimentally reproducible, and transferable across embodiments.