Modular Open Robot Skill Library

• MORSL is a modular system that organizes robot behavior as a composite of reusable skills structured as directed computation graphs.
• It emphasizes explicit skill interfaces with typed inputs/outputs and metadata schemas to ensure interoperability across platforms.
• The framework supports hierarchical runtime execution with integrated validation, learning backends, and simulation-backed adaptation.

Modular Open Robot Skill Library (MORSL) denotes a line of research in which robot capabilities are organized as reusable, modular skills rather than as monolithic task policies. In the clearest explicit formulation, MORSL is an “open, evolving” library of reusable robot skills that can be selected and wired into robot policies as directed computation graphs (Chen et al., 6 Jul 2026). Across adjacent work, the same idea appears through closely related components: structured skill libraries with dispatchers and validation pipelines, semantic skill contracts with world-model grounding, learning backends for training and distillation, hardware-independent skill agents, and open robot platforms or simulators that host, benchmark, and transfer such skills (Li et al., 2 Apr 2026, Mayr et al., 2023).

1. Conceptual foundations

In the MORSL literature, the central design move is to treat robot behavior as composition over a finite inventory of reusable capabilities. GaP formalizes this most directly: a robot policy is a directed computation graph $\mathcal{G}=(V,E)$ whose nodes encapsulate “a single, well-defined robotic operation with a typed input/output signature,” and whose skill nodes are drawn from MORSL (Chen et al., 6 Jul 2026). The same paper presents MORSL as a shared catalog that includes model-based procedures, model-free policies, perception modules, grasp planners, motion planners, geometry utilities, ROS translators, and learned policies, rather than only one algorithmic family.

Related systems make the same decomposition from different directions. OpenGo centers a “customizable and extensible” skill library, an LLM-based dispatcher, and a self-learning framework, with the explicit restriction that the LLM performs skill selection and bounded parameter tuning rather than low-level action generation (Li et al., 2 Apr 2026). SkiROS2 frames robot control as a skill-based architecture in which autonomous mission execution, knowledge integration, interchangeability, and interoperability are mediated through semantically described skills and extended behavior trees (Mayr et al., 2023). RoboMatrix similarly argues for a skill-centric hierarchy in which a high-level scheduling layer decomposes tasks into meta-skills, an intermediate skill layer executes them, and a hardware layer realizes the resulting commands (Mao et al., 2024).

This body of work suggests that MORSL is not a single finalized software standard. It is better understood as an architectural program that connects interpretable robot programming, reusable behavior modules, semantic world models, and deployment-oriented execution.

2. Skill representation and interface design

Current MORSL-relevant systems do not converge on one schema, but they repeatedly emphasize explicit skill interfaces. GaP uses a common metadata schema with a name, a description, and typed inputs and outputs; it further distinguishes composite skills, atomic skills, and primitive skills, with shared types such as Se3Pose, OrientedBoundingBox, PointCloud, Mask, Image, Trajectory, and JointState (Chen et al., 6 Jul 2026). OpenGo defines each skill through five fields—skill head, parameters, constraints, function, and prompts—and imposes the rule that “the function is immutable during online execution, while the parameters remain tunable within predefined bounds” (Li et al., 2 Apr 2026). SkiROS2 defines a skill as “a parametric procedure that changes the world from some initial state to some new state,” with zero or more parameters, pre-conditions, hold-conditions, and post-conditions (Mayr et al., 2023).

Several papers sharpen this interface idea from other angles. Playful Agentic Robot Learning stores each learned skill as executable Python source code together with description, preconditions, expected effects, dependencies, provenance, usage counts, success counts, and a reliability tier (Zhang et al., 17 Jun 2026). IROSA exposes skill adaptation primitives as JSON-schema tools with names, descriptions, typed arguments, validation logic, and deterministic execution code, while maintaining a protective abstraction layer between language and robot hardware (Knauer et al., 4 Mar 2026). The hardware-level reusability paper instead represents execution through task models and hardware-independent skill agents built around the relative relationship between the hand position and the environment, so that the same representation can be executed on different robots by swapping the inverse kinematics solver (Takamatsu et al., 2024).

A common misconception is that a skill library must consist only of learned policies. The literature is broader: MORSL-style entries may be typed computation nodes, semantic task operators, executable code helpers, JSON tools, contact-transition skill agents, or semantically grounded robot procedures. The shared requirement is not a single representation format, but explicit interfaces for invocation, parameterization, and composition.

3. Composition, dispatch, and runtime execution

MORSL research consistently treats runtime composition as a first-class problem. In GaP, the top-level policy is a graph over skill nodes, with data edges routing outputs to downstream inputs and control edges carrying predicates over node outputs; the orchestration agent partitions a task into semantic segments and maps them into MORSL skills before simulation-based refinement (Chen et al., 6 Jul 2026). OpenGo expresses dispatch as

$\prod = f_{LLM}(T,I,S,K),$

producing an ordered plan

$$\prod {(k_1,\theta_1),(k_2,\theta_2),...,(k_n,\theta_n)},$$

where $T$ is the task description, $I$ the instruction, $S$ the scene, and $K$ the skill library (Li et al., 2 Apr 2026). Candidate skills are filtered by constraints and current scene, parameter ranges are clamped, Memory/State Check validates the current context, and a Safety Tool can trigger emergency stop.

SkiROS2 provides a different but closely related runtime model. It uses extended behavior trees (eBTs), in which scripted and planned procedures are merged into one representation and pre-, hold-, and post-condition nodes are embedded into execution (Mayr et al., 2023). This lets planning and execution share the same semantic skill descriptions, while runtime monitoring remains reactive. RoboMatrix similarly decomposes a task into a sequence of meta-skills addressed by language prompts and executed by either VLA-based or hybrid skill modules; its skills terminate through an explicit stop signal in the action vector (Mao et al., 2024).

Skill composition is not always purely task-achieving. The safe manipulation paper separates a library into base skills $\{\pi_{b_0},...,\pi_{b_m}\}$ and failure prevention skills $\{\pi_{p_0},...,\pi_{p_n}\}$, with a higher-level selector that invokes the base skill when no risk is active and switches to the corresponding prevention skill when a risk channel becomes active (Ak et al., 2023). In multi-robot settings, MRTA-Sim distributes composition across allocation, waypoint generation, planning, control, and local centralized deconfliction, showing how what appears externally as one “delivery” behavior is a hierarchy of coordinated modules rather than a single atomic skill (Tuck et al., 21 Apr 2025).

Taken together, these systems show that MORSL runtime execution is typically hierarchical: semantic selection or planning at the top, skill invocation with typed parameters in the middle, and robot-specific planning and control below.

4. Learning, validation, and adaptation

A MORSL needs a way to acquire and refine its skills, and current work offers several complementary mechanisms. RSL-RL supplies a compact robotics-focused learning backend organized around Runner, Algorithm, and Network; it implements PPO and a behavior cloning method similar to DAgger, supports symmetry augmentation, intrinsic motivation through Random Network Distillation, recurrent policies, teacher-student distillation, and GPU-only large-scale training (Schwarke et al., 13 Sep 2025). It is therefore well suited as a training substrate for reusable skill assets, even though it does not itself provide skill cataloging or orchestration.

Agentic Skill Discovery addresses the cold-start problem directly. Starting from zero skills, it iteratively proposes tasks with an LLM, samples success and reward functions, trains policies with PPO, and validates survivors with an independent vision-LLM before admitting completed tasks as skills with multiple policy options (Zhao et al., 2024). This is significant because it turns skill-library emergence into a propose–learn–verify–collect loop rather than assuming a seed library. Playful Agentic Robot Learning pushes the same theme further through self-directed play: RATs proposes exploratory tasks, executes code policies, verifies progress at step level, diagnoses failures, retries, and distills successful code into a persistent skill library, later reused without fine-tuning (Zhang et al., 17 Jun 2026).

Validation is a recurring boundary condition. OpenGo imposes code review and simulation-based validation before admitting new skills (Li et al., 2 Apr 2026). GaP rehearses candidate computation graphs in Isaac simulator / Isaac Lab and uses node-level failure analysis to modify graph topology, swap nodes, and tune parameters (Chen et al., 6 Jul 2026). IROSA restricts LLMs to selecting and parameterizing validated tools over a Kernelized Movement Primitive representation, rather than allowing direct hardware access (Knauer et al., 4 Mar 2026). These designs all reject the idea that a skill should be trusted merely because it can be generated or learned; it must also be bounded, validated, and monitored.

5. Embodiment, simulation, and deployment substrates

Many MORSL-relevant papers are not skill libraries in the narrow sense, but they provide the embodiment and execution substrate on which such a library depends. Timor Python contributes standardized module descriptions, assembly graphs, URDF export of arbitrary modular robot assemblies, Pinocchio and FCL integration, and task-based configuration optimization for modular reconfigurable robots (Külz et al., 2022). ROMR offers a low-cost, ROS-based, modular mobile robot platform with released CAD, electronics, firmware, URDF, Gazebo integration, and baseline workflows for teleoperation, mapping, localization, and navigation (Linus et al., 2022). M provides a ROS2-native modular social robot with clear separation among multimodal perception, expression control, and data management, plus simulation with interface equivalence to hardware (Antony et al., 19 Mar 2026).

Simulation and environment modeling also appear as reusable MORSL infrastructure. MRTA-Sim connects allocation output to Nav2 planning and CBF-QP control in ROS2/Gazebo, with room queues, roadway following, human interaction and avoidance, and local centralized multi-robot deconfliction (Tuck et al., 21 Apr 2025). The semantic-geometric-physical transfer framework stores task graph, scene graph, and state graph in Neo4j and then couples high-level transfer, A*-based trajectory adaptation, and tactile execution refinement (Qi et al., 2024). The hardware-level reusability work demonstrates that the same task-model representations and manipulation skill agents can execute on Nextage and Fetch by keeping skills hand/environment-centered and swapping the IK solver (Takamatsu et al., 2024).

These works clarify a persistent MORSL theme: reusable skills are only partly about software packaging. They also depend on morphology models, simulation parity, semantic scene representations, sensor hooks, and embodiment adapters.

6. Open questions, misconceptions, and unsettled boundaries

The current literature repeatedly shows what MORSL is not. RSL-RL is highly suitable as a foundational backend for MORSL training and adaptation, but it does not provide explicit APIs for skills, metadata schemas, hierarchical composition, behavior-tree integration, task sequencing, or repository management (Schwarke et al., 13 Sep 2025). ROMR is an open execution substrate and benchmarkable host robot rather than a formal skill library (Linus et al., 2022). Timor is an embodiment and model-generation backbone, not a library of reusable motion primitives or semantic skills (Külz et al., 2022). IROSA focuses on adapting a single given skill through natural language, not selecting and switching among multiple skills (Knauer et al., 4 Mar 2026).

Even systems that come closest to MORSL remain incomplete as open standards. OpenGo provides a structured skill library, runtime dispatcher, and validation pipeline, but the paper does not specify a full repository model, versioning, dependency resolution, quantitative validation protocol, or released reproducibility assets (Li et al., 2 Apr 2026). RoboMatrix demonstrates meta-skill composition and a unified action representation, yet it lacks formal skill contracts, a machine-readable catalog, and strong automated replanning (Mao et al., 2024). GaP presents MORSL most explicitly, but its appendix-level schema and graph workflow do not amount to a universal interchange standard across labs or robots (Chen et al., 6 Jul 2026).

This suggests that MORSL remains an active architectural target rather than a settled canonical framework. The literature is converging on recurring requirements—typed skill signatures, parameter bounds, semantic world models, compositional runtimes, validation before admission, simulation-backed rehearsal, and embodiment adapters—but it has not yet converged on a single open specification for packaging, discovery, compatibility, lifecycle management, and cross-robot interoperability.