Hierarchical Skill Retrieval (HSR)

• "Hierarchical Skill Retrieval (HSR) is a methodological framework used to decompose complex tasks into reusable skills, organize these skills at multiple levels of abstraction, and retrieve or compose task-relevant capabilities during execution. This approach is particularly valuable in robotics, natural language processing, and machine learning for enhancing task adaptability and efficiency."
• HSR addresses the shortcomings of flat demonstration retrieval and monolithic policy learning by treating tasks as hierarchies of reusable units, such as primitives, local dynamical modes, subtasks, interaction patterns, procedures, and composite skills. This hierarchical organization enables more flexible and efficient task execution.
• In vision-language-action adaptation, HSR decomposes a target manipulation task into candidate skill sequences, evaluates these sequences using semantic plausibility and skill reliability estimated from prior data, and performs hybrid retrieval using subtask-level language and behavior-feature compatibility.

Hierarchical Skill Retrieval (HSR) is a framework for decomposing complex tasks into reusable skills, organizing those skills at multiple levels of abstraction, and retrieving or composing task-relevant capabilities during execution. In its most specific formulation, HSR for vision-language-action (VLA) adaptation decomposes a target manipulation task into candidate skill sequences, evaluates those sequences using semantic plausibility and skill reliability estimated from prior data, performs hybrid retrieval using subtask-level language and behavior-feature compatibility, and adapts the policy through separate general-skill pretraining and task-specific finetuning (Hao et al., 25 Aug 2026). More broadly, HSR encompasses several related paradigms: dynamic-mode retrieval from motion data, automaton-guided policy reuse, latent or feature-conditioned skill selection, grammar-based hierarchy induction, semantic skill-library retrieval, dependency-aware graph traversal, and model-conditioned procedural memory.

1. Conceptual foundations and scope

HSR addresses a limitation of flat demonstration retrieval and monolithic policy learning. A complete trajectory may be too specific to reuse directly, while a single global task label does not expose the control, guidance, planning, or procedural structure that produced the behavior. HSR instead treats a task as a hierarchy of reusable units that may include primitives, local dynamical modes, subtasks, interaction patterns, procedures, and composite skills.

The central abstraction can be expressed as:

$$\text{task or query} \rightarrow \text{skill decomposition} \rightarrow \text{candidate skill retrieval} \rightarrow \text{compatibility and reliability filtering} \rightarrow \text{skill composition} \rightarrow \text{execution and feedback}.$$

A skill may be represented in several ways depending on the domain:

• a continuous trajectory segment or dynamic mode;
• an option with an initiation set, policy, and termination condition;
• an automaton-conditioned policy;
• a feature-conditioned goal-reaching controller;
• a latent variable and decoder predicting an abstract transition;
• a symbolic grammar production;
• a natural-language procedural rule;
• a graph node connected to executable action templates;
• a model–skill pair selected by an orchestration policy.

The term retrieval consequently has multiple meanings. Some systems perform explicit similarity search over skill descriptions or embeddings. Others implement implicit retrieval by selecting a policy, latent code, automaton state, feature subset, or graph node. The distinction is important: downstream task success does not by itself establish retrieval accuracy, and a learned controller that selects among abstractions is not necessarily equivalent to an indexed skill database.

The defining property of HSR is hierarchical organization. Retrieval is performed at more than one granularity, or its output is expanded through relations among levels. A typical hierarchy may distinguish:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$

Other systems use different axes. Multi-Resolution Skill Discovery organizes skills by temporal distance; Disentangled Unsupervised Skill Discovery organizes them by state factors; SkillResolve organizes candidates into same-capability families; and Hierarchical Skill Retrieval for VLA adaptation organizes retrieval around candidate task decompositions and behavior-compatible demonstrations (Hu et al., 2024, Gehring et al., 2021, Ding, 9 Jun 2026, Hao et al., 25 Aug 2026).

2. Hierarchical representations of skills

Control, guidance, and planning

A hierarchical representation of surgical behavior distinguishes three levels:

• Control: local tool-motion execution and dynamic regulation;
• Guidance: organization of movements around task-relevant spatial goals and subgoals;
• Planning: ordering and spatial organization of interaction patterns or subtasks.

The corresponding closed-loop structure is:

$$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$

The planner decomposes the task into interaction patterns and produces subgoals $g_k$. Guidance computes a motion gap and generates a reference trajectory $x_{\mathrm{ref}}$, while a low-level tracking controller generates the actual tool motion. An interaction pattern is an approximately invariant organization of human–tool–environment interaction. It can be decomposed into dynamic modes such as acceleration, deceleration, interception, and stable motion. This gives the representation:

$$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$

In the Peg Transfer task, PWARX clustering identified three expert-associated phases: starting, maneuvering, and interception. These phases correspond respectively to picking up blocks, moving them toward the central area, and transferring them between tools. The result illustrates how low-level dynamics can be linked to meaningful subgoals and higher-level task organization (Li et al., 2015).

Options and executable policies

Several HSR systems represent a skill as an option:

$$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$

where $\mathcal I_\omega$ is an initiation set, $\pi_\omega$ is an intra-option policy, and $\beta_\omega$ is a termination condition. This representation separates applicability, execution, and completion.

Hypothesis-Driven Skill Discovery uses this form for object-state transitions. An option is associated with a source object, target object, proposed displacement, policy, and termination set. Candidate motions are extracted from correlated changepoints and clustered with a Dirichlet-process Gaussian mixture model. A candidate is retained when its learned policy produces the hypothesized displacement more often than random behavior. The resulting hierarchy recursively expands:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$0

HiSD similarly converts segmented trajectory units into options using behavioral cloning and positive–unlabelled classifiers for initiation and termination. Composite grammar symbols become composite options whose execution expands into child options (Chuck et al., 2019, Harvey et al., 30 Jan 2026).

Automaton-conditioned skills

Automata-guided hierarchical reinforcement learning represents task progress with a finite-state automaton. A task specification in syntactically co-safe truncated linear temporal logic is converted into an automaton with state $$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$1, and the environment state is augmented:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$2

The automaton state records which portions of the task have been completed. A low-level policy conditioned on $$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$3 attempts to satisfy one of the outgoing transition predicates. Thus, the relevant skill is indexed not only by the physical state but also by the logical task-progress state. Conjunctive tasks are composed through product automata:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$4

This mechanism provides specification-driven skill reuse, although it does not perform similarity-based retrieval from a large skill database (Li et al., 2017).

Feature-conditioned and latent skills

HSD-3 defines a skill through a subset $$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$5 of robot-state features and a goal $$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$6 in the associated goal space:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$7

Its hierarchy contains:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$8

The discrete selector chooses the skill abstraction, the goal policy chooses a target within that abstraction, and the low-level controller produces actuator actions. HSD-3 therefore performs implicit retrieval over feature subsets rather than explicit search over named skills.

DUSDi instead factorizes the skill space according to state factors:

$$\text{domain} \rightarrow \text{task} \rightarrow \text{subtask} \rightarrow \text{procedure} \rightarrow \text{primitive action}.$$9

Each component $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$0 is intended to affect primarily one state factor $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$1. Components can be selected simultaneously, allowing concurrent composition rather than only sequential option execution. Its low-level policy receives the complete vector $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$2, while a downstream high-level policy selects the vector every $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$3 low-level steps (Gehring et al., 2021, Hu et al., 2024).

Natural-language procedural skills

LLM-agent systems often represent skills as natural-language procedures rather than executable controllers. SkillRL stores compact records containing a unique identifier, title, principle, and when_to_apply condition. Its two-level SkillBank separates general skills from task-specific skills. General skills encode transferable principles such as systematic exploration and precondition checking, while task-specific skills encode procedures for categories such as ALFWorld and WebShop (Xia et al., 9 Feb 2026).

SkillPyramid uses structured SKILL.md files containing applicability conditions, procedures, inputs, expected outputs, verification checks, constraints, and failure cases. It adds explicit dependency references to reused skills and organizes atomic, task-specific, and abstract skills in a layered pyramid (Xiong et al., 2 Jun 2026).

SkillFolder, used by Uni-Skill, provides a four-layer hierarchy:

$$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$4

The repository contains more than 10,000 skill traces mapped to 106 VerbNet classes and 1,659 unique skill formulations. Leaf demonstrations retain video intervals, trajectories, poses, scene context, semantic constraints, and spatial references (Xie et al., 3 Mar 2026).

3. Retrieval mechanisms and hierarchical selection

Explicit similarity retrieval

The most direct HSR mechanism uses a query representation and a skill representation in a shared embedding space. SkillTrace decomposes a user query into atomic requirements $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$5, embeds both queries and skills, and computes:

$$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$6

It then uses maximum-weight bipartite matching to assign primary skills to atomic requirements. Dependency-aware Personalized PageRank expands the selected seeds with supporting or prerequisite skills. The final result is a connected skill bundle rather than an independently ranked list.

HiSkill performs hybrid dense and sparse retrieval over both high-level skills and AtomicOp nodes:

$$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$7

Dense similarity uses text-embedding-3-large, while sparse similarity uses BM25. Top skill and AtomicOp seeds are selected separately, and the seed set is expanded through typed relations such as decomposition, continuation, support, compatibility, and recovery (Yao et al., 3 Aug 2026, Hao et al., 25 Aug 2026).

Uni-Skill uses coarse-to-fine semantic retrieval through SkillFolder. A requested skill is parsed with a VerbNet parser, routed through the four-level taxonomy, and refined at the leaf level by CLIP similarity between the deployment scene and candidate demonstrations. Retrieved demonstrations supply both semantic constraints and spatial trajectory references for few-shot skill implementation (Xie et al., 3 Mar 2026).

Family-aware representative resolution

SkillResolve-Bench identifies a failure mode in which a retriever selects the correct capability family but exposes the wrong same-capability representative. A helpful skill and a risky sibling may share vocabulary and broad functionality while differing in resources, preconditions, APIs, procedures, or output schemas.

The retrieval process is:

$$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$8

For a capability family $$\text{Planning} \rightarrow \text{Guidance/perception} \rightarrow \text{Control/tracking}.$$9, representative selection is:

$g_k$0

after which only one representative per active family enters the final ranking. The benchmark reports Recall@3 $g_k$1, NDCG@3 $g_k$2, and harmful sibling rate HSR@3 $g_k$3 for SkillResolve. Removing representative selection raises HSR@3 to $g_k$4, while helpful retrieval changes only slightly. The result shows that relevance alone is insufficient when multiple procedural representatives compete within one capability family (Ding, 9 Jun 2026).

Policy-based implicit retrieval

In policy-based systems, retrieval is represented by a learned selection policy rather than an external index. HSD-3 selects a feature subset $g_k$5, DUSDi selects a factored latent vector $g_k$6, and MRSD selects a temporal-resolution head and latent skill code. MRSD uses resolution-specific conditional variational autoencoders to predict future states at temporal distances $g_k$7. A manager samples one latent from each resolution, decodes candidate subgoals, and selects one with a one-hot choice head. The selected goal is passed to a worker for $g_k$8 environment steps (Sharma et al., 27 May 2025).

Maestro extends policy-based retrieval to joint model–skill routing. Its search action is:

$g_k$9

where $x_{\mathrm{ref}}$0 is an expert model, $x_{\mathrm{ref}}$1 is a Level-1 skill, and $x_{\mathrm{ref}}$2 is a sub-query. The orchestrator can reason internally, invoke a model–skill pair, process the returned observation, and issue additional calls before termination. Level-2 dispatch is handled through keyword-based activation or expert-model classification rather than the global RL policy (Wu et al., 21 May 2026).

Retrieval through logical task progress

Automata-guided HRL selects a sub-policy using the current automaton state and outgoing transition guards. The mechanism is symbolic rather than similarity-based:

$x_{\mathrm{ref}}$3

The automaton determines the active subtask, transition availability, progress reward, and completion condition. This is implicit retrieval keyed by formal task state (Li et al., 2017).

4. Skill composition, execution, and feedback

HSR differs from simple retrieval because the retrieved result must often be composed and executed under constraints.

Query decomposition and dependency completion

SkillTrace uses a three-level Query–Skill Graph:

$x_{\mathrm{ref}}$4

The query tree $x_{\mathrm{ref}}$5 decomposes the user request into atomic requirements. The bipartite graph $x_{\mathrm{ref}}$6 links those requirements to candidate skills. The dependency graph $x_{\mathrm{ref}}$7 connects skills whose outputs can be consumed by other skills.

The system first obtains primary skills using Hungarian matching, then propagates relevance over the dependency graph with reverse-aware Personalized PageRank. This allows retrieval to include prerequisites that were not explicitly mentioned in the user request. The method optimizes a set-level objective: the selected bundle should jointly accomplish the task, rather than merely contain individually similar skills (Yao et al., 3 Aug 2026).

Typed execution graphs

HiSkill makes the abstraction-to-action interface explicit. Its graph contains high-level skill nodes and AtomicOp nodes, connected by typed relations:

$x_{\mathrm{ref}}$8

A high-level skill decomposes into ordered AtomicOps. can_follow relations encode temporal continuation, supports relations provide missing prerequisites, and recovers_with relations provide alternatives after failure or stagnation. A symbolic task state records task stage, location, held objects, missing constraints, recent actions, and failure history. The runtime loop is:

$x_{\mathrm{ref}}$9

This design explicitly bridges high-level procedural knowledge and executable action syntax (Yao et al., 3 Aug 2026).

Demonstration-grounded skill implementation

Uni-Skill retrieves demonstrations rather than directly executing stored policies. Semantic constraints describe contact and waypoint requirements, while projected trajectories preserve spatial organization. GPT-4o predicts a target contact point and variable-length waypoints from the retrieved examples and target scene. Depth lifts the points to three dimensions, and source orientations are transferred into target local frames to produce executable $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$0 trajectories.

The resulting process is:

$$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$1

This form of HSR is particularly relevant when a target behavior is absent from a fixed API library but related demonstrations exist in an offline repository (Xie et al., 3 Mar 2026).

Recursive and temporal composition

Automata-guided HRL composes policies through product automata. SkillRL composes policies recursively through language instructions: a higher-level policy may invoke a previously learned global policy, which may itself invoke an earlier policy. A base-policy invocation is assumed to run to completion before the parent policy makes another branch decision.

MRSD composes a manager, resolution-specific latent skill modules, and a worker. Its temporal abstraction is determined by a manager refresh interval $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$2, while the skill representation itself models future states at distances $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$3. The two quantities are distinct: a skill can represent a transition farther in the future than the period for which its current goal is pursued (Li et al., 2017, Xia et al., 9 Feb 2026, Sharma et al., 27 May 2025).

Self-evolution and library maintenance

SkillRL converts successful and failed trajectories into compact procedural knowledge and recursively adds new skills when validation performance is low. ARISE uses a two-tier cache and reservoir: selected skills receive exponential-moving-average utility updates, new skills enter the cache, low-utility entries are evicted to the reservoir, and reservoir entries can later be promoted. The Manager retrieves before execution and summarizes successful trajectories after execution.

MASA evolves general skills by hill climbing and task-specific skills by UCB-driven tree search. Its objective is not to modify the target model but to rewrite the textual skill library for a particular backbone. SkillPyramid performs consolidation through atomic extraction, canonical merging, dependency linking, and abstract-skill induction. These systems treat the library as an evolving external data structure rather than a fixed collection (Li et al., 17 Mar 2026, Xia et al., 9 Feb 2026, Yu et al., 29 May 2026, Xiong et al., 2 Jun 2026).

5. Evaluation, empirical evidence, and limitations

Evaluation dimensions

HSR systems are evaluated using several distinct categories of metrics:

• Downstream task performance: success rate, episodic return, score, or Pass@1;
• Retrieval quality: Recall@$$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$4, NDCG@$$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$5, ranking utility, or representative selection;
• Exposure and safety: harmful sibling rate HSR@$$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$6;
• Segmentation quality: framewise accuracy, segment-level F1, mIoU, and global alignment;
• Hierarchy quality: depth, branching factor, tree count, grammar reuse, and dependency structure;
• Efficiency: execution steps, token consumption, retrieval latency, GPU memory, and training cost;
• Transfer: performance on unseen tasks, environments, models, embodiments, or skill combinations.

These metrics are not interchangeable. A method may achieve high downstream performance without reporting retrieval precision, or high retrieval relevance while exposing an unsafe same-capability sibling. SkillResolve-Bench explicitly argues for reporting both helpful retrieval and harmful exposure (Ding, 9 Jun 2026).

Reported empirical patterns

The surgical-motion study found that experts exhibited a larger speed–curvature movement envelope but more condensed dominant states. Dynamic clustering and spatial organization distinguished expertise more effectively than global kinematic distributions. Experts had lower spatial misclassification than intermediate clinicians and novices, with reported leave-one-out means of $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$7, $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$8, and $$\text{task demonstration} \rightarrow \text{interaction-pattern sequence} \rightarrow \text{dynamic-mode sequence} \rightarrow \text{continuous motion}.$$9, respectively (Li et al., 2015).

HyPE reported approximately $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$0 success in the robotic pushing domain and substantially faster Breakout learning than standard pixel-based DRL methods. Its evidence primarily concerns hierarchical discovery and sample efficiency rather than query-based retrieval (Chuck et al., 2019).

HSD-3 matched or exceeded the full-space skill baseline on the reported Walker tasks and outperformed the best fixed skill on several tasks. Its advantage was attributed to state-dependent selection among feature subsets of different complexity. DUSDi reported higher DCI disentanglement, completeness, and informativeness than DIAYN-MC in 2D Gunner, Multi-Particle, and iGibson, together with stronger downstream performance on tasks requiring concurrent control of multiple factors (Gehring et al., 2021).

HiSD achieved higher global skill alignment than competing segmentation methods in several longer or partially observable settings, but its Minecraft hierarchy generated one distinct tree per episode. This limits the usefulness of the induced hierarchy as a stable retrieval index. Downstream option execution improved learning in Craftax and Minecraft, although executable grounding required action-labelled data for behavioral cloning (Harvey et al., 30 Jan 2026).

SkillRL reported $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$1 ALFWorld success, $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$2 WebShop success, and a $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$3 average search-QA score. Removing hierarchical organization reduced ALFWorld performance to $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$4, while replacing distilled skills with raw trajectories reduced it to $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$5. These results support compact hierarchical procedural memory, although the system’s hierarchy is limited to general and task-specific levels (Xia et al., 9 Feb 2026).

Uni-Skill reported average success rates of $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$6 on RLBench tasks within the basic-skill distribution and $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$7 on tasks requiring skill extension, compared with lower scores for the reported baselines. In real-world evaluation with a Franka Emika arm, Uni-Skill reported an average of $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$8. The strongest evidence concerns retrieval-grounded skill implementation for behaviors absent from a fixed API library (Xie et al., 3 Mar 2026).

SkillTrace reached a $$\omega=\langle \mathcal I_\omega,\pi_\omega,\beta_\omega\rangle,$$9 success rate on SkillsBench and $\mathcal I_\omega$0 on ALFWorld. Removing its hierarchical query tree, query–skill bipartite graph, or skill dependency subgraph reduced SkillsBench success to $\mathcal I_\omega$1, $\mathcal I_\omega$2, and $\mathcal I_\omega$3, respectively. These ablations support the complementary roles of query coverage, constrained primary assignment, and dependency completion (Yao et al., 3 Aug 2026).

HiSkill reported $\mathcal I_\omega$4 Seen and $\mathcal I_\omega$5 Unseen ALFWorld success with Gemini-2.5-Pro, a WebShop score of $\mathcal I_\omega$6, and ScienceWorld scores of $\mathcal I_\omega$7 Seen and $\mathcal I_\omega$8 Unseen. Removing AtomicOps, typed edges, support and recovery relations, symbolic state, or dynamic retrieval reduced performance. Its results provide direct evidence that executable action templates and runtime graph relations improve over flat skill prompting (Yao et al., 3 Aug 2026).

The VLA-specific HSR framework reported an average success-rate improvement of $\mathcal I_\omega$9 on LIBERO and several real-world manipulation tasks. Its distinguishing mechanism is task decomposition followed by hybrid retrieval that combines subtask-level language matching with behavior-feature reranking, followed by general-skill pretraining and task-specific finetuning (Hao et al., 25 Aug 2026).

Common limitations

HSR remains limited by several recurring issues.

Semantic similarity does not guarantee execution compatibility. Skills with similar descriptions may bind to different resources, require different preconditions, or encode incompatible procedures. SkillResolve-Bench demonstrates that same-capability ambiguity can substantially increase risky exposure even when helpful retrieval remains high (Ding, 9 Jun 2026).

Unsupervised skill identities may lack stable semantics. Clustering, grammar induction, and latent-variable discovery can produce reusable units without guaranteeing that those units correspond to causal subskills or uniquely identifiable concepts. HiSD’s Minecraft hierarchy illustrates how segmentation noise can destabilize cross-episode identities (Harvey et al., 30 Jan 2026).

Retrieval and execution are distinct problems. A correct candidate may still fail because the agent cannot ground arguments, satisfy preconditions, terminate reliably, or adapt the procedure to the current scene. This is why HiSkill adds AtomicOps and symbolic state, while Uni-Skill adds semantic constraints, trajectories, depth lifting, and orientation transfer (Yao et al., 3 Aug 2026, Xie et al., 3 Mar 2026).

Hierarchy construction can be expensive and underspecified. LLM-based relation analysis, teacher-driven skill rewriting, video annotation, and repeated environment evaluation may dominate total cost. Several systems do not report exact retrieval latency, index complexity, or maintenance cost (Xie et al., 3 Mar 2026, Yu et al., 29 May 2026, Xiong et al., 2 Jun 2026).

Skill libraries may grow redundantly or interfere. Append-only evolution can accumulate duplicate or contradictory entries. Cache and reservoir management, canonical merging, family-aware representative selection, and utility-based eviction address this problem but do not provide universal guarantees (Xia et al., 9 Feb 2026, Li et al., 17 Mar 2026, Xiong et al., 2 Jun 2026).

Generalization is domain-dependent. Robotics systems depend on state representations, embodiment, action spaces, and visual correspondence. LLM-agent systems depend on backbone behavior, prompting conventions, and tool interfaces. MASA shows that the same skill formulation can help one backbone and harm another, while Maestro shows that model–skill compatibility can be important for multimodal routing (Yu et al., 29 May 2026, Wu et al., 21 May 2026).

Many methods do not provide explicit retrieval metrics. HSD-3, DUSDi, MRSD, HyPE, and automaton-guided HRL primarily evaluate downstream control or task reward. SkillRL, Uni-Skill, SkillPyramid, and Maestro also emphasize end-task outcomes rather than standard retrieval benchmarks. This complicates comparisons between representation quality, selection quality, and execution quality.

6. Research directions and system design principles

A complete HSR architecture would combine the strongest elements of these approaches while distinguishing discovery, indexing, retrieval, composition, execution, and maintenance.

Structured skill records

A skill record should expose more than a name or description. Useful fields include:

• semantic capability and task category;
• initiation conditions and required inputs;
• expected outputs and postconditions;
• resource bindings and API scope;
• executable procedures or AtomicOps;
• temporal resolution or duration;
• state-factor or object-effect descriptors;
• success probability and failure modes;
• provenance and supporting demonstrations;
• model, embodiment, and environment compatibility;
• dependency, support, and recovery relations.

This design follows the contract profiles of SkillResolve, the structured records of ARISE and SkillPyramid, the AtomicOp interface of HiSkill, and the semantic–spatial metadata of SkillFolder (Ding, 9 Jun 2026, Li et al., 17 Mar 2026, Yao et al., 3 Aug 2026, Xie et al., 3 Mar 2026).

Hierarchical indexing

Retrieval should separate multiple decisions:

$\pi_\omega$0

Query decomposition should preserve distinct input–output transformations without inventing requirements. Candidate assignment should avoid unnecessary duplication, while dependency expansion should recover prerequisites omitted by the user. Same-family candidates should compete locally before global top-$\pi_\omega$1 ranking.

SkillTrace supplies a query-side hierarchy, bipartite matching, and dependency propagation. SkillResolve supplies family-level representative selection. HiSkill supplies graph hydration, typed execution relations, and AtomicOp grounding. These mechanisms are complementary rather than mutually exclusive (Yao et al., 3 Aug 2026, Ding, 9 Jun 2026).

Reliability- and feasibility-aware ranking

Similarity should be combined with reliability and execution feasibility. A retrieval system should consider:

• semantic relevance;
• state and subgoal compatibility;
• input–output closure;
• initiation probability;
• predicted task value;
• model–skill compatibility;
• risk and failure history;
• latency and token cost;
• representative competition within capability families.

For manipulation, behavior-feature reranking is especially important because visually similar demonstrations may differ in contact geometry or trajectory feasibility. The VLA-specific HSR framework explicitly combines language-level subtask retrieval with behavior-feature reranking and skill reliability estimated from prior data (Hao et al., 25 Aug 2026).

Dynamic selection and abstention

Retrieval should be revisable. The agent may need to:

• select a skill;
• execute a partial procedure;
• observe the result;
• update a symbolic or recurrent state;
• switch to a successor;
• invoke support behavior;
• invoke recovery behavior;
• abstain when confidence is low.

ARISE implements confidence-gated skill injection. Maestro supports multi-turn expert selection and re-routing. HiSkill supports runtime switching through temporal, compatibility, support, and recovery edges. These mechanisms establish retrieval as an ongoing control process rather than a single preprocessing step (Li et al., 17 Mar 2026, Wu et al., 21 May 2026, Yao et al., 3 Aug 2026).

Model- and embodiment-aware adaptation

Skill utility is conditional on the target model, embodiment, environment, and interface. MASA therefore evolves skill formulations for each backbone using model cards, failure attribution, hill climbing, and UCB-driven search. In robotic systems, the same semantic behavior may require different trajectories, action templates, or pose transformations across embodiments.

A general HSR system should therefore distinguish:

$\pi_\omega$2

This is particularly important when retrieved skills are textual guidance rather than independently executable controllers (Yu et al., 29 May 2026).

Continual consolidation

Self-evolving systems require explicit lifecycle management:

$\pi_\omega$3

Successful trajectories can be distilled into reusable principles, while failures can provide recovery procedures or negative examples. ARISE uses successful-trace summarization, cache/reservoir organization, and utility-based maintenance. SkillPyramid performs atomic extraction, merging, and abstract induction. MASA searches for improved model-specific formulations. These mechanisms suggest that a skill repository should be treated as a maintained operational system rather than a static document collection (Li et al., 17 Mar 2026, Xiong et al., 2 Jun 2026, Yu et al., 29 May 2026).

Retrieval-specific evaluation

Future HSR benchmarks should measure:

• Recall@$\pi_\omega$4 and NDCG@$\pi_\omega$5;
• task and subtask coverage;
• family-resolution precision and recall;
• harmful same-capability exposure;
• dependency closure;
• representative-selection accuracy;
• skill initiation and termination reliability;
• execution success conditioned on retrieval;
• composition validity;
• recovery success;
• retrieval latency and memory cost;
• token or context consumption;
• transfer across tasks, models, environments, and embodiments.

The harmful sibling rate introduced by SkillResolve-Bench is especially important because positive retrieval metrics can conceal unsafe or procedurally inappropriate exposure (Ding, 9 Jun 2026).

HSR is therefore best understood as an intersection of hierarchical reinforcement learning, skill discovery, retrieval-augmented agents, program and grammar induction, graph search, procedural memory, and data-efficient policy adaptation. Its central research problem is not merely identifying a relevant skill. It is selecting a reliable representative, completing its prerequisites, composing it with compatible capabilities, grounding it into executable behavior, and improving the repository from feedback. The emerging direction combines hierarchical query decomposition, structured skill contracts, dependency-aware retrieval, behavior-feature compatibility, dynamic execution graphs, model-aware adaptation, and continual consolidation.