Skill Library

A skill library consists of parameterized motion primitives—fundamental, reusable actions like Pick(pose), Place(pose), or NavigateTo(goal). Each primitive is a self-contained module that encapsulates the low-level control logic, sensor feedback, and error handling required to reliably execute a specific physical movement. This abstraction allows planners to sequence high-level tasks without managing joint-level details.

• Example: A ScrewTurn(torque, angle) primitive handles the force control and verification for a specific fastener.
• Benefit: Drastically reduces code duplication and standardizes robot behavior across different applications and teams.

Skills are not hardcoded sequences but generalized templates that accept runtime parameters. This allows a single Grasp(object_id) skill to adapt its grip force, approach vector, and finger positioning based on the perceived properties of different objects. Effective parameterization is what transforms a fixed script into a flexible, composable capability.

• Key Parameters: Target pose, object properties (size, weight), force/torque limits, speed, and success conditions.
• Enables: The same library to be used for diverse tasks, from assembling electronics to packing boxes, by simply changing the input arguments.

Each skill is formally defined with preconditions (logical and physical states required for execution) and effects (the expected changes to the world state upon successful completion). This formal specification is critical for automated task planners (using languages like PDDL) to reason about which skills can be legally applied in a given situation and to predict the resulting state of the world.

• Precondition Example: Pick(object) requires object.isVisible == true and robot.gripperIsEmpty == true.
• Effect Example: Successful execution of Place(object, location) results in object.location == location and robot.gripperIsEmpty == true.

Complex tasks are achieved through hierarchical composition, where high-level "macro-skills" are decomposed into sequences of simpler primitives. A MakeCoffee() macro-skill might call a sequence: NavigateTo(kitchen), Grasp(mug), Place(mug under brewer), PressButton(brew). The library manages this hierarchy, allowing for modular testing and reuse at every level.

• Architecture Link: This characteristic directly enables Hierarchical Task Network (HTN) planning, where planners recursively decompose abstract tasks into this library's executable primitives.

A core value of a skill library is the encapsulation of robustness logic. Each primitive internally handles sensor monitoring, error detection, and recovery strategies. For instance, a Insert(peg, hole) skill would monitor force feedback, detect misalignment jams, and execute a corrective wiggle motion—all transparently to the higher-level planner. This turns fragile open-loop commands into reliable closed-loop behaviors.

• Includes: Timeout handling, conditional retries, failure state reporting, and fallback behaviors.
• Result: The overall system's reliability is the product of its individual, well-tested skills.

The library acts as the critical interface layer between the task planner (which decides what to do) and the motion controller (which determines how to move the joints). It receives symbolic task commands and translates them into calls to the robot's Model Predictive Control (MPC), trajectory optimization, or inverse kinematics solvers. This clean separation of concerns is essential for maintainable and scalable robotic software architecture.

• Input: Symbolic command from a planner (e.g., "pick block_A").
• Output: Low-level trajectory or torque commands sent to the robot's actuator controllers.

A foundational manipulation skill involving the sequential execution of a reach, grasp, lift, transport, and release motion. It is highly parameterized by:

• Target Object Pose: The 3D position and orientation of the object to be picked.
• Grasp Type: e.g., power grasp, precision pinch, or suction.
• Placement Pose: The desired final location and orientation of the object.
• Trajectory Profile: The speed and acceleration constraints for the move. This skill is often decomposed into finer sub-skills like pre-grasp positioning and compliant insertion.

A contact-rich fine manipulation skill requiring precise alignment and force control to mate a cylindrical peg into a closely-toleranced hole. Key parameters and techniques include:

• Chamfer Detection: Using force/torque sensing to locate the hole's edge.
• Compliance: Employing impedance control or a remote center of compliance (RCC) device to absorb lateral forces and prevent jamming.
• Search Pattern: A spiral or raster scan executed upon initial contact to find the correct alignment. This skill is critical for assembly tasks and demonstrates the need for skills that handle uncertainty and physical interaction.

A constraint-aware mobile manipulation skill that combines navigation, grasping, and trajectory following. It requires reasoning about the kinematic chain formed by the robot, the handle, and the door. The skill is parameterized by:

• Handle Type: Knob vs. lever, which dictates the grasp and initial turning motion.
• Door Swing Direction: Inward vs. outward, which determines the robot's retreat path.
• Required Force: The torque needed to overcome the door's resistance. Execution involves compliantly following the arc of the door's motion while the robot's base adjusts its position to avoid over-extension or collision.

A closed-loop perception-action skill that uses real-time visual feedback to guide a robot's end-effector to a desired pose relative to a target. It is parameterized by:

• Visual Feature: Points, edges, or template markers used for tracking.
• Servoing Law: The control rule (e.g., Image-Based Visual Servoing (IBVS) or Position-Based Visual Servoing (PBVS)) that maps feature error to joint velocities.
• Gain Parameters: Control gains that affect convergence speed and stability. This skill enables precise alignment in the presence of calibration errors and is fundamental for tasks like connector mating or part feeding from a conveyor.

A mobile base skill that plans and executes a collision-free path from the robot's current location to a specified goal in a 2D or 3D map. Core parameters include:

• Goal Pose: The target (x, y, theta) coordinates.
• Costmap: A grid representing obstacle locations and traversal costs (e.g., prefer lanes, avoid grass).
• Planner Algorithm: e.g., A* for global planning, Dynamic Window Approach (DWA) or Model Predictive Control (MPC) for local obstacle avoidance.
• Recovery Behaviors: Parameterized routines for situations like getting stuck (e.g., rotate-in-place, clear-costmap).

A hybrid force-position control skill for tasks requiring maintained contact with a surface while moving along a path. It is essential for applications like polishing, cleaning, or deburring. Parameters define:

• Desired Contact Force: The normal force to apply against the surface.
• Wiping Path: The geometric trajectory to follow on the surface (e.g., a raster pattern).
• Compliance Frame: The orientation in which force control is active (typically normal to the surface).
• Surface Stiffness Estimate: Used to adjust the controller's responsiveness. This skill demonstrates how primitives encapsulate both motion geometry and physical interaction models.

A Motion Primitive is a short, parameterized trajectory segment representing a fundamental robot movement, such as a straight-line reach, a turning arc, or a specific gripper opening sequence. It serves as the atomic, reusable building block from which complex skills are composed.

• Parameterization: Primitives are defined by a set of parameters (e.g., target pose, duration, maximum velocity) that allow them to be adapted to different contexts.
• Library Role: A Skill Library is essentially a curated collection of these primitives, often with associated preconditions and effects.
• Execution: Primitives are typically executed by low-level controllers that handle dynamics and real-time feedback.

A Hierarchical Task Network (HTN) is a classical AI planning formalism that decomposes high-level tasks into networks of subtasks using a library of predefined methods. It is a direct conceptual framework for implementing a Skill Library.

• Decomposition: An HTN planner breaks down abstract tasks (e.g., 'Deliver Package') by recursively applying methods that map tasks to subtasks or primitive actions.
• Method Library: This library is analogous to a Skill Library, containing the rules for how complex tasks can be achieved.
• Deterministic Structure: Unlike purely search-based planners, HTNs use domain knowledge encoded in methods to guide planning efficiently, making them practical for robotics.

A Behavior Tree (BT) is a modular, hierarchical control architecture used to structure the decision-making logic of autonomous agents, including robots. Skills from a library are often implemented as subtrees or individual action nodes within a BT.

• Node Types: Combines action nodes (skills), condition nodes (checks), and control flow nodes (sequence, selector, parallel) to create complex behaviors.
• Reactivity: BTs are inherently reactive; they can be ticked at high frequency, allowing for dynamic re-evaluation and response to environmental changes during skill execution.
• Composability: Skills (as action nodes) can be easily reused and rearranged within different branches of the tree, promoting modularity similar to a Skill Library.

Task Decomposition is the overarching process of breaking down a complex, high-level goal into a structured sequence or hierarchy of simpler, executable subtasks or actions. A Skill Library provides the vocabulary for this decomposition.

• Hierarchical Planning: The planner's role is to find a valid decomposition path from the top-level goal to a sequence of library skills.
• Symbolic Grounding: Decomposition bridges the gap between symbolic task descriptions ('make coffee') and parameterized motor commands (move to kettle, grasp handle).
• Feasibility Checking: Each step in decomposition must verify that the preconditions for the selected skill are met in the current world state.

A Primitive Action is the fundamental, indivisible motor command or movement in a robotic plan. It is the output of task decomposition and the element executed directly by the robot's controllers. In a Skill Library context, a skill may encapsulate one or more coordinated primitive actions.

• Atomic Unit: Cannot be decomposed further by the planning system (e.g., 'close gripper with force 5N', 'set joint 1 to 0.5 rad').
• Interface to Control: Primitive actions are the commands sent to the joint-level PID controllers, motor drivers, or low-level API of the robot.
• Skill vs. Primitive: A 'Pick' skill might sequence the primitives: 'Move to pre-grasp pose', 'Open gripper', 'Move to grasp pose', 'Close gripper'.

Plan Validation is the verification process to ensure a generated plan—often a sequence of skills—is logically sound, kinematically feasible, and safe before physical execution. It is a critical step after retrieving skills from a library.

• Simulation-Based Checking: The planned skill sequence is often tested in a physics simulator to check for collisions, dynamic stability, and success probability.
• Constraint Satisfaction: Validates that all geometric, temporal, and resource constraints are satisfied throughout the plan.
• Precondition/Effect Consistency: Ensures the symbolic preconditions of each skill are met by the effects of the preceding skill, maintaining a consistent world state prediction.