Task Decomposition-Guided Reranking for Adaptive Agent Skill Retrieval Yanping Chen1 , Weijie Shi2 , Wen Yang1 , Jiajie Xu1 1
School of Computer Science and Technology, Soochow University 2 The Hong Kong University of Science and Technology
arXiv:2607.06283v1 [cs.AI] 7 Jul 2026
Abstract Skill usage can significantly enhance the ability of modern agent systems to complete complex tasks. However, the growing scale of skill libraries makes accurate skill selection increasingly challenging. In real-world scenarios, ambiguous semantic matching often arises between a specific task requirement and multiple generic yet semantically similar candidate skills. Moreover, existing methods tend to overlook the dynamic influence of task difficulty and skill applicability when selecting the optimal target skill set. To address these issues, we propose SkillReranker, an inference-time reranking framework for adaptive skill selection. Specifically, we first perform semantic decomposition on both the task and skill sides, yielding informative subtask and execution-state descriptions as well as transition-state descriptions that characterize each skill’s functionality. These descriptions are then used to construct a directed acyclic execution graph, where intermediate task states are modeled as nodes and candidate skills as edges, thereby establishing a structured task–skill correspondence. On this basis, SkillReranker determines whether each state node satisfies the split condition to identify subtask intervals. For each task interval, we employ a cross-encoder to perform comprehensive scoring over candidate skills and select the most suitable ones to form the final target skill set. Experiments on ALFWorld and ScienceWorld with three backbone LLMs show that SkillReranker effectively improves task performance, reduces environment interaction steps, and lowers token consumption compared with existing skill selection baselines.
1
Introduction
Skills have emerged as an effective mechanism for enhancing the ability of large language model (LLM) agents to solve complex tasks (Liu et al. 2025; Wang et al. 2026b; Li et al. 2026b). Rather than requiring agents to rely entirely on the implicit reasoning and action generation of the underlying LLM, skill libraries explicitly organize both domain knowledge and procedural guidance, thereby providing more stable execution support (Xu and Yan 2026; Jiang et al. 2026). However, as skill libraries continue to grow in scale (Li et al. 2026a), the functional boundaries among skills become increasingly blurred. Accurately selecting the skills that best match the requirements of a given task from a large candidate pool remains a key challenge for LLM-based agents (Su et al. 2026; Cho, Kang, and Kim 2026).
Welcome to TextWorld, ALFRED! Your task is to:
Task: put a hot cup in cabinet.
Candidate skill_A: alfworld-heat-object-with-appliance Description: Uses a heating appliance (microwave, stoveburner, oven) to apply heat to a specified object…
Similar?
Candidate skill_B: alfworld-object-heater Description: Heats a specified object using an available heating appliance (e.g., microwave, stoveburner)…
Distinction: Skill A has no prerequisites. Skill B has a prerequisite: The target object must be in your inventory.
Skill A: detailed workflow (Navigate & Locate → Acquire Object → Navigate to Appliance → Prepare Appliance → Execute Heating) Skill B: concise workflow (Navigate → Check state → Heat)
Figure 1: Task-matching difficulty caused by semantic similarity between skills. The task is selected from the ALFWorld dataset.
This challenge first arises from a granularity gap between task requirements and skill descriptions. In real-world scenarios, task requirements are typically concrete and concise, whereas skill descriptions tend to be more general, often targeting a class of similar tasks or a reusable operational pattern (Liang et al. 2026a; Zheng et al. 2026). As a result, a specific task can be matched to multiple candidate skills that appear semantically similar but differ substantially in their actual utility, as shown in Figure 1, where two heating-related skills exhibit different prerequisites and execution workflows. Selection methods that rely solely on overall textual similarity are prone to semantic ambiguity, mistaking surface-level semantic relevance for genuine functional applicability and thereby undermining the accuracy of skill selection. Meanwhile, tasks vary in execution difficulty and complexity, which in turn leads to different requirements for the number of skills needed and their scope of applicability (Qian et al. 2025). Selecting too few skills may be insufficient to support the completion of complex tasks, while selecting
too many may introduce redundant information, increase the agent’s decision-making burden, and even interfere with subsequent execution (Liu et al. 2024; Han et al. 2026). Therefore, skill selection should not be treated merely as a process of ranking a fixed number of candidate skills. Instead, the final target skill set should be determined dynamically based on task requirements and the functional differences among candidate skills. To address these issues, we propose SkillReranker, an inference-time reranking framework for adaptive skill selection. Specifically, semantic decomposition is first performed on task descriptions and skill texts. On the task side, each task is represented as an execution process composed of subtasks and intermediate states; on the skill side, state descriptions are extracted to characterize each skill’s applicable conditions and expected effects. Building on these state representations, SkillReranker constructs a directed acyclic execution graph in which intermediate task states serve as nodes and skills serve as edges, enabling fine-grained modeling of task–skill relationships. The framework then determines whether each state node can define a local boundary for skill selection, dynamically partitions the task into subtask intervals, and employs a cross-encoder to perform comprehensive scoring over candidate skills within each interval, thereby selecting the final target skill set. Through this two-stage design of structural modeling followed by interval-wise reranking, SkillReranker improves the discriminability of skill matching while adaptively determining the number and composition of selected skills based on task difficulty and skill applicability. We conduct experiments on two benchmark datasets, ALFWorld and ScienceWorld, across three different model configurations, and analyze the impact of our method on both skill selection quality and task completion performance. The results show that SkillReranker can more effectively identify skills that match different stages of task execution and dynamically adjust the target skill set according to task complexity, thereby improving the agent’s ability to solve complex tasks. Our main contributions are as follows: • We propose SkillReranker, an inference-time adaptive skill reranking framework that dynamically selects the target skill set based on task requirements, overcoming the limitations of fixed Top-k retrieval. • We design a structured alignment mechanism between task execution processes and skill state information, enabling fine-grained modeling and selection of candidate skills through a directed execution graph. • We conduct systematic experiments on ALFWorld and ScienceWorld, demonstrating the effectiveness of SkillReranker in terms of both skill selection quality and task completion performance.
2
Related Work
Skill retrieval and selection. Skill libraries give agents reusable procedural knowledge (Wang et al. 2023). Yet benchmarks show more skills is not better: an oversized context dilutes attention, and agents struggle to judge which skills are worth loading (Li et al. 2026b; Liu et al. 2026b;
Wang, Wang, and Xu 2026). To address this, retrieve-thenrerank pipelines narrow candidates via dense retrieval and cross-encoder scoring (Li, Tagkopoulos, and Tagkopoulos 2026; Zheng et al. 2026), the latter finding the skill body decisive over its metadata; others cast it as on-demand augmentation whose bottleneck is deciding whether and which skill to load (Su et al. 2026). On presentation and budgeting, work adapts the budget per task (Li et al. 2026c), trims redundancy through compression and progressive disclosure (Gao et al. 2026), or infers skill demands under a performance–cost trade-off (Wang et al. 2026a). These methods score a flat candidate set as one matching target; we instead align selection with the task’s intermediate execution states. Structured skill modeling. Unlike conventional tool calls, skills are self-contained packages of procedural knowledge, so managing and using them requires reasoning over interfaces, execution structure, and action evidence (Jiang et al. 2026). To curb the ambiguity of text-only representations, one line disentangles these signals into relational ontologies or layered schemas (Liang et al. 2026b,a), while another builds executable skill graphs or capability trees for dependency-aware retrieval and DAG-based orchestration (Liu et al. 2026a; Xia et al. 2026; Li et al. 2026a). These graphs, however, place skills at the nodes and capture skill-side dependencies without aligning to the task’s own execution. We instead construct a directed acyclic execution graph whose nodes are task intermediate states and whose edges are skills, aligning each skill’s preconditions and effects to task states and reranking within dynamically partitioned subtask intervals.
3
Problem Formulation
Given a task q described in natural language, our goal is to select a set of skills that can support the agent in completing the task. Let S = s1 , . . . , sN denote the skill library collected from the open-source platform skillsmp.com, which contains N = 67,884 skills. Each skill si has metadata mi , including its name and short description, and a complete skill text ci . Since this work focuses on adaptive skill selection in the reranking stage, we first retrieve a candidate set of size K for each task. We encode the task q and each skill metadata mi with an embedding model E(·), instantiated as Qwen3Embedding-0.6B (Zhang et al. 2025), and select the K skills with the largest cosine similarity: CK (q) = Top-K cos E(q), E(mi ) . (1) si ∈S
where K = 30 in our experiments. This step defines a compact candidate space for reranking, but it does not constrain the final selected set to contain exactly K skills. Given the candidate set CK (q), adaptive skill selection is formulated as selecting a subset of candidates according to the task description and the complete text of each candidate skill: S ⋆ (q) = f q, {si | si ∈ CK (q)} ⊆ CK (q). (2) Here, f denotes the reranking and selection function implemented by SkillReranker. The members and size of S ⋆ (q) are determined adaptively according to the task requirements and the functional differences among candidate skills.
Figure 2: Overview of the proposed framework. (1) Structural Parsing decomposes the task into sub-tasks and states (online) and parses each skill into precondition/completion states (offline). (2) Execution Graph Construction recalls top-K candidate skills and matches their precondition/completion states to task states, turning each skill into an edge of a state-matching graph. (3) Adaptive Skill Selection detects split points that partition the task into segments, reranks skills within each segment by a global and a local score, and deduplicates the per-segment winners into a final skill set of adaptive size.
4
Method
This section presents the concrete implementation of the proposed framework. The framework is organized into three main components, as shown in Figure 2. First, we perform structured parsing of the task and the skills separately. Based on the parsed representations, an execution graph is then constructed, where task sub-states are represented as nodes and skills are modeled as edges. Finally, guided by the graph structure, the framework adaptively determines the stage partition and selects skills for each stage.
4.1
Structured Parsing of Task and Skills
We first transform the free-form task instruction and skill documents into structured representations endowed with state semantics, so that subsequent alignment can be carried out in a unified state space. Task parsing. Given a task instruction, we use an expert LLM to first decompose it into an ordered sequence of highlevel sub-tasks T = (t0 , . . . , tm−1 ) in logical execution order. Based on these sub-tasks, the LLM further derives a sequence of key sub-states S = (s0 , . . . , sm ), where s0 denotes the initial task state and each subsequent state si+1 describes the task progress after completing sub-task ti . In this way, each sub-task naturally corresponds to a transition between two consecutive sub-states. The prompt template
used for task parsing is provided in Appendix B.1. To make the parsed representation more concrete, we show an example of the extracted task fields below. Example of parsed task fields Task
put a clean fork in countertop.
Sub-tasks T
t0 : Obtain a fork from a storage location. t1 : Clean the fork using a sink or other cleaning method. t2 : Place the clean fork on the countertop.
Sub-states S
s0 : The fork has not been obtained. s1 : A fork has been obtained but is not yet clean. s2 : The fork is clean but has not yet been placed on the countertop. s3 : The clean fork is on the countertop.
Skill parsing. For each skill k in the skill library, we also employ an expert LLM to parse its skill document into two state descriptions: a precondition state pk and a completion state ek . The precondition state specifies the task or environmental condition required before the skill can be invoked, while the completion state describes the expected state after the skill is successfully executed. If a skill does not require any specific prerequisite, its precondition state is set to None. This parsing process characterizes each skill as a state transi-
tion from pk to ek . Skill parsing is performed offline during preprocessing, and the parsed results are cached together with the original skill metadata. The prompt template used for skill parsing is provided in Appendix B.2. The following example illustrates how a skill document is converted into its structured precondition and completion states.
Identifying stage split points. We assign each edge a weight wk = σ(ρk ) (where σ is the sigmoid function), and for each node i we compute three quantities: In(i) =
k: tgtk ≤i
Example of parsed skill fields Skill name
alfworld-object-cooler.
Precondition state pk
The agent is holding the target object and is located at a valid cooling receptacle, such as a fridge or freezer.
Completion state ek
4.2
The held object has been successfully cooled, changing its temperature state and making it ready for subsequent placement or serving steps.
Execution Graph Construction
For a given task, we first perform coarse recall over the skill library with a sentence encoder, taking the Top-K skills by similarity to obtain the candidate skill set C. We then take the task sub-states as nodes and map each candidate skill to a directed edge in the graph, yielding the execution graph of the task, whose node set is {s0 , . . . , sn−1 }. Specifically, we use a cross-encoder reranker r(·, ·) to measure the relevance between two pieces of text. For each candidate skill k, we first align its precondition state with each sub-state and take the one with the highest relevance as the source node of the skill edge; if the skill has no precondition dependency, the source node is set to the initial state: 0, pk = None (3) srck = arg max r(si , pk ), otherwise. 0≤i≤n−2
Among the sub-states after the source node, we then align the completion state and take the best match as the target node: tgtk = srck +1+arg max r ssrck +1+j , ek . (4) 0≤j≤n−srck −2
If the source node is already at the end of the sequence and no landing point can be found after it (i.e., srck + 1 ≥ n), the skill cannot advance the task within this task sequence and is discarded. In this way, each candidate skill is represented as a directed edge from its source node to its target node, with the semantics that the skill can advance the task from the source sub-state to the target sub-state. In addition, we compute the relevance ρk = r(q, ck ) between the skill document and the entire task instruction q, which serves as the basis for the subsequent edge weights and scoring. All candidate skills together constitute the execution graph that covers the task’s state sequence.
4.3
Adaptive Skill Selection
The execution graph characterizes the active interval of each skill along the task timeline. An ideal skill combination should make these intervals connect end to end, jointly spanning the entire path from the initial state to the goal state. Accordingly, we first identify the natural stage boundaries of the task and then select skills stage by stage.
X
Out(i) =
X k: srck ≥i
Cross(i) =
wk , 1 + (i − tgtk )/(n − 1) wk , 1 + (srck − i)/(n − 1)
X
(5)
wk .
k: srck <i<tgtk
Here In(i) measures the strength of skills that complete at or before node i, Out(i) measures the strength of skills that start at or after node i (both decaying with distance), and Cross(i) measures the strength of skills that pass directly across node i without stopping at it. Intuitively, if at a certain node many skills finish while many others depart, yet almost no skill straddles it, then this node is an indispensable bottleneck in task execution and a natural boundary for stage transition. Accordingly, an intermediate node i (with 1 ≤ i ≤ n − 2) is taken as a split point if and only if In(i) > Cross(i)
and
Out(i) > Cross(i).
(6)
Denoting the resulting split points together with the two boundaries as P = {0} ∪ { i | i is a split point } ∪ {n − 1}, sorting P in ascending order divides the task into several contiguous stages. Note that the number of stages is entirely determined by the task’s own structure and the coverage of the candidate skills, rather than by a predefined fixed value. Stage-wise skill selection. For each stage, we concatenate its internal sub-tasks in order into an overall task description of the stage, and then compute a stage-fit score for each candidate skill. This score combines the task-level relevance and the stage-level sub-task relevance in log space: ϕk = log σ(ρk ) + log σ r(τ, ck ) , (7) where τ is the concatenated sub-task text of the current stage. The skill with the highest score is taken as the selected skill of that stage. The log-summation is equivalent to taking the geometric mean of the two relevance probabilities, requiring the selected skill to both fit the task overall and precisely cover the sub-tasks of the current stage, thereby suppressing skills that excel at only one of the two while being weak on the other. Deduplication and output. We arrange the selected skills of all stages in stage order and deduplicate them to obtain the final skill set. Since adjacent stages may hit the same skill, the final number of skills does not exceed the number of stages. The entire procedure does not rely on a fixed Top-k cutoff: when the task structure is simple it returns only a few skills, and when the task spans multiple execution stages it automatically returns more complementary skills, achieving an adaptive variation of both the number and the combination of skills according to the task.
Table 1: Main results across two interactive benchmarks. R = average reward/score (↑), S = average environment steps (↓). Best in bold, second-best underlined. For ALFWorld, R is average reward (0–100). For ScienceWorld, R is average score (0–100). ALFWorld Model
Method
DeepSeek-v4-Flash
GPT-5.4-Mini
Qwen3.6-27B
5 5.1
Seen
ScienceWorld
Unseen
Seen
Unseen
R↑
S↓
R↑
S↓
R↑
S↓
R↑
S↓
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
75.36 80.72 70.36 84.65
17.21 16.31 17.55 15.48
70.52 73.14 69.78 78.73
18.61 18.10 18.29 17.08
73.06 75.28 73.32 78.46
17.11 16.61 18.12 15.77
71.95 72.85 70.68 74.41
19.59 18.14 18.77 16.84
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
48.57 62.50 58.57 67.50
19.62 17.64 20.04 17.55
54.85 67.91 64.93 70.90
19.17 17.69 18.65 17.06
66.54 73.06 63.61 73.61
15.59 14.71 16.22 14.48
64.72 66.97 63.41 69.64
17.18 16.22 17.23 15.60
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
74.29 72.50 70.72 78.57
12.61 12.89 13.62 12.06
67.17 72.39 68.66 73.88
14.02 13.60 13.82 12.80
68.45 72.85 67.40 72.26
11.95 12.15 12.42 11.26
66.24 66.82 61.06 67.73
13.19 12.88 13.17 13.08
Experiment
Experimental Setup
Benchmarks. Our framework is evaluated on two interactive benchmarks: ALFWorld (Shridhar et al. 2020) and ScienceWorld (Wang et al. 2022). ALFWorld targets household manipulation tasks and is divided into seen and unseen test splits, with the seen split containing 140 tasks and the unseen split containing 134 tasks. ScienceWorld is a text-based interactive environment centered on scientific experimental tasks, covering 30 task types. To maintain consistency with ALFWorld, we refer to its original validation and test splits as the seen and unseen splits, which contain 194 and 211 task instances, respectively. Implementation. The LLM agent system with skill usage is built using the open-source LangChain framework. Experiments are conducted with representative LLMs from three different model families: DeepSeek-v4-Flash, GPT-5.4Mini, and Qwen3.6-27B (Qwen Team 2026). DeepSeek-v4Flash and GPT-5.4-Mini are accessed through their official APIs with temperature set to 0, while Qwen3.6-27B is locally deployed using vLLM under the same decoding temperature. In our method, DeepSeek-v4-Flash is used as the LLM for semantic decomposition during the structured parsing stage, while Qwen3-Reranker-0.6B (Zhang et al. 2025) is adopted as the cross-encoder scorer for execution graph construction and skill selection. All skills are collected from skillsmp.com, and the candidate pool size is set to K = 30 for each task. For evaluation on both benchmarks, the maximum number of environment steps is set to 30. Baselines. We compare SkillReranker against three baselines: LLM-as-selector, SkillRouter (Zheng et al. 2026), and Graph of Skills (Liu et al. 2026a). LLM-as-selector is a generative skill selector that prompts an LLM to rerank candidate
skills. Given the task description and the full text of K candidate skills as input, it outputs a reranked skill list. In our experiments, Mimo-v2.5-Pro (Xiaomi MiMo Team 2026) is used for this baseline. SkillRouter fine-tunes a bi-encoder retriever and a cross-encoder reranker to select relevant skills from large-scale skill libraries. Graph of Skills constructs a dependency-aware skill graph and retrieves structurally connected skill bundles through graph-based inference-time retrieval. All baselines share the same frozen agent and skill pool. Evaluation. We report three metrics for each experimental setting: average reward, average number of steps, and average number of tokens. Average reward denotes the average task success rate or reward score across all tasks, ranging from 0 to 100, where higher values indicate better performance. The average number of steps measures the mean number of environment steps taken until task completion or failure, ranging from 0 to 30, where lower values are preferred. The average number of tokens measures the mean token consumption during task execution across all tasks, where lower values indicate better efficiency. As the average number of skills adaptively selected by our method falls between 1 and 2, the reported baseline results are averaged over two settings, where the top-1 and top-2 selected skills are used, respectively.
5.2
Main Results
Overall Performance. We present the main results in Table 1 and Figure 3. As shown in Table 1, SkillReranker exhibits clear advantages across the two interactive benchmarks, both test splits, and all three backbone LLMs. Overall, our method ranks first in 11 out of 12 reward/score settings and 11 out of 12 average-step settings. Compared with SkillRouter, the strongest baseline in most cases, SkillR-
LLM-as-selector
SkillRouter
Graph of Skills
SkillReranker
DeepSeek-v4-Flash
GPT-5.4-Mini
80, 000
70, 000
Average Tokens
Average Tokens
100, 000
60, 000
50, 000
80, 000
60, 000
40, 000
40, 000
seen
Alf-
en unse Alf-
Sci-s
een
n nsee Sci-u
seen
Alf-
Alf-
n
e unse
een Sci-s
n nsee
Sci-u
Figure 3: Average token consumption of different methods on Alfworld and ScienceWorld (lower is better). Each group along the horizontal axis corresponds to a “dataset–split” combination (seen/unseen), and the vertical axis denotes the average number of consumed tokens. Table 2: Ablation results in terms of average reward (R) on ALFWorld and ScienceWorld under different model configurations. Configuration
ALFWorld
ScienceWorld
Seen
Unseen
Seen
Unseen
DeepSeek-v4-Flash Ours 84.65 w/o Parsing 80.71 w/o Graph Edge 79.29 w/o Split 82.15
78.73 75.37 76.12 77.98
78.46 71.82 76.39 76.40
74.41 71.42 73.56 72.85
Qwen3.6-27B Ours w/o Parsing w/o Graph Edge w/o Split
73.88 65.67 73.13 71.64
72.26 68.58 71.74 72.09
67.73 64.39 65.04 68.47
78.57 65.00 74.29 75.71
eranker shows particularly pronounced gains with DeepSeekv4-Flash and GPT-5.4-Mini. For example, on ALFWorldunseen, it improves the average reward from 73.14 to 78.73 and from 67.91 to 70.90, respectively. These results suggest that SkillReranker is not tied to a specific backbone model, but consistently improves skill selection quality across models with different capabilities. Execution Efficiency. Beyond task performance, SkillReranker also reduces environment interaction steps in nearly all settings. With DeepSeek-v4-Flash, for example, it lowers the average steps from 16.31 to 15.48 on ALFWorld-seen and from 18.14 to 16.84 on ScienceWorld-unseen, showing that better skill selection leads to more efficient execution. Although SkillReranker is slightly below the best baseline on the Qwen3.6-27B ScienceWorld-seen reward and ScienceWorld-unseen step metrics, it remains competitive, and the overall results demonstrate its effectiveness in both skill selection quality and execution efficiency.
Token Consumption. We also report the average token consumption during task execution in Figure 3. On average, SkillReranker selects 1.3 skills per task on ALFWorldseen and 1.291 skills on ALFWorld-unseen. On the seen and unseen splits of ScienceWorld, it selects 1.299 and 1.275 skills, respectively, with detailed results provided in Appendix A. This adaptive skill selection mechanism enables our method to consume fewer tokens. As shown in Figure 3, SkillReranker achieves the lowest average token consumption across all settings of the two models (see Appendix A for more results). These results indicate that SkillReranker can further reduce context length and token cost.
5.3
Ablation Study
To evaluate the contribution of each component, we conduct ablation experiments with two LLM backbones: DeepSeekv4-Flash and Qwen3.6-27B. The full version of our method is denoted as Ours. (1) The w/o Parsing variant removes structured task and skill decomposition, and directly applies the reranker to the original task description and candidate skills. (2) The w/o Graph Edge variant removes the execution graph structure and performs joint reranking only based on the decomposed subtask descriptions. (3) The w/o Split variant disables adaptive skill selection and instead selects one skill independently for each subtask. As shown in Table 2, the full method achieves the best performance in most settings across the two LLM backbones, with the only exception being ScienceWorld-unseen under Qwen3.6-27B, where removing split detection yields a slightly higher reward. Among the ablated variants, w/o Parsing generally causes the largest performance degradation, especially under Qwen3.6-27B, indicating that explicit task and skill state descriptions are crucial for reliable skill matching. Removing graph edges also consistently weakens performance, showing that modeling skills as transitions between task states provides useful structural information beyond independent subtask-level matching. The w/o Split variant per-
forms competitively in some cases but is generally inferior to the full method, suggesting that adaptive skill selection granularity is beneficial overall, although its effect may vary across models and dataset splits. These results demonstrate the importance of structural parsing, graph-based alignment, and adaptive skill selection in the proposed framework. Task: Put a watch on a sidetable. a
States & skills (top-5):
c
d 𝑆0
𝑆1
𝑆2
e b
a: alfworld-object-locator (w=0.89); b: alfworld-environment-scanner (w=0.72); c: alfworld-search-pattern-executor (w=0.48); d: alfworld-locate-target-object (w=0.33); e: alfworld-tool-user (w=0.13); … Task interval boundary point: 𝑆0 , 𝑆2 Subtask: "Obtain a watch from its current location. Place the watch on a sidetable."
Skill selection: {alfworld-object-locator}
6
(a) Task: Put a hot mug in coffeemachine. a
States & skills (top-5):
d e
𝑆0
𝑆1
𝑆2
𝑆3
b c
a: alfworld-object-locator (w=0.84); b: alfworld-heat-object-with-appliance (w=0.81); c: alfworld-object-heater (w=0.45); d: alfworld-device-operator (w=0.32); e: alfworld-tool-user (w=0.28); … Task interval boundary point: 𝑆0 , 𝑆1 , 𝑆3 Subtasks: “Obtain a mug from a storage container.” “Heat the mug. Put the hot mug into the coffeemachine.” Skill selection: {alfworld-object-locator, alfworld-heatobject-with-appliance}
(b)
Figure 4: Two examples of skill retrieval by our method on the ALFWorld dataset.
5.4
skill selection. In Figure 4a, the task “Put a watch on a sidetable” has a relatively simple execution structure. The value w denotes the matching score between the original task description and each skill text, which provides a global relevance estimate. Although several candidate skills are retrieved, the detected task interval contains only one major subtask: obtaining the watch and placing it on a suitable surface. By further incorporating the matching between the local subtask and candidate skills, the method selects alfworldobject-locator, which directly supports locating and acquiring the target object. This example shows that our method can avoid selecting redundant skills when the task can be handled by a single functional skill. Figure 4b shows a more complex task, “Put a hot mug in coffeemachine,” which requires multiple functional operations. The global task-skill scores w indicate that both alfworld-object-locator and alfworld-heat-object-withappliance are highly relevant to the original task. More importantly, after the task is divided into finer intervals, the local subtasks further distinguish the required operations: obtaining the mug and heating it with an appliance. By combining the global task-level matching scores with the local subtask-level matching scores, the method selects both skills. This example demonstrates that our method can adaptively increase the number of selected skills when the task involves multiple execution stages.
Case Study
Figure 4 presents two representative examples from ALFWorld to illustrate how our method performs structure-aware
Conclusion
In this paper, we propose SkillReranker, an inference-time adaptive skill reranking framework for LLM-based agents. Unlike fixed Top-k skill selection methods, SkillReranker explicitly models the alignment between task execution states and skill functionality. By decomposing tasks and skills into structured state representations, constructing a directed execution graph, and performing stage-wise reranking over dynamically identified task intervals, our method selects skills according to both task requirements and skill applicability. Experiments on ALFWorld and ScienceWorld across multiple backbone LLMs show that SkillReranker consistently improves task performance, reduces environment interaction steps, and lowers token consumption. These results demonstrate the effectiveness of structure-aware and adaptive skill selection for improving the reliability and efficiency of skillaugmented LLM agents.
7
Limitations
Although SkillReranker improves adaptive skill selection across different interactive benchmarks, it still has several limitations. First, the framework relies on LLM-based task decomposition and skill-state parsing, so inaccurate intermediate states or incomplete skill descriptions may affect the quality of graph construction and subsequent selection. Second, the current implementation depends on cross-encoder scoring over recalled candidates, which introduces additional inference overhead compared with simple embedding-based retrieval. Finally, our experiments focus on text-based interactive environments, and extending the framework to broader embodied, multimodal, or real-world agent settings remains
an important direction for future work.
References Cho, H.; Kang, R.; and Kim, Y. 2026. SkillRet: A large-scale benchmark for skill retrieval in LLM agents. arXiv preprint arXiv:2605.05726. Gao, Y.; Li, Z.; Ji, Z.; Ma, P.; Wang, S.; et al. 2026. Skillreducer: Optimizing llm agent skills for token efficiency. arXiv preprint arXiv:2603.29919. Han, T.; Zhang, Y.; Song, W.; Fang, C.; Chen, Z.; Sun, Y.; and Hu, L. 2026. SWE-Skills-Bench: Do Agent Skills Actually Help in Real-World Software Engineering? arXiv preprint arXiv:2603.15401. Jiang, Y.; Li, D.; Deng, H.; Ma, B.; Wang, X.; Wang, Q.; and Yu, G. 2026. SoK: Agentic Skills–Beyond Tool Use in LLM Agents. arXiv preprint arXiv:2602.20867. Li, F.; Tagkopoulos, P.; and Tagkopoulos, I. 2026. SkillFlow: Scalable and Efficient Agent Skill Retrieval System. Li, H.; Mu, C.; Chen, J.; Ren, S.; Cui, Z.; Zhang, Y.; Bai, L.; and Hu, S. 2026a. Organizing, orchestrating, and benchmarking agent skills at ecosystem scale. arXiv preprint arXiv:2603.02176. Li, X.; Chen, W.; Liu, Y.; Zheng, S.; Chen, X.; He, Y.; Li, Y.; You, B.; Shen, H.; Sun, J.; et al. 2026b. SkillsBench: Benchmarking how well agent skills work across diverse tasks. arXiv preprint arXiv:2602.12670. Li, Y.; Liu, W.; Gao, B.; Xie, J.; Ai, Z.; Zou, N.; Li, Y.; and Fu, T. 2026c. SkillsInjector: Dynamic Skill Context Construction for LLM Agents. arXiv preprint arXiv:2605.29794. Liang, Q.; Wang, H.; Liang, Z.; and Liu, Y. 2026a. From skill text to skill structure: The scheduling-structural-logical representation for agent skills. arXiv preprint arXiv:2604.24026. Liang, Y.; Zhong, R.; Xu, H.; Jiang, C.; Zhong, Y.; Fang, R.; Gu, J.-C.; Deng, S.; Yao, Y.; Wang, M.; et al. 2026b. Skillnet: Create, evaluate, and connect ai skills. arXiv preprint arXiv:2603.04448. Liu, D.; Li, Z.; Du, H.; Wu, X.; Gui, S.; Kuang, Y.; and Sun, L. 2026a. Graph of Skills: Dependency-Aware Structural Retrieval for Massive Agent Skills. arXiv preprint arXiv:2604.05333. Liu, N. F.; Lin, K.; Hewitt, J.; Paranjape, A.; Bevilacqua, M.; Petroni, F.; and Liang, P. 2024. Lost in the middle: How language models use long contexts. Transactions of the association for computational linguistics, 12: 157–173. Liu, S.; Shu, Y.; Guo, C.; and Yang, B. 2025. Learning generalizable skills from offline multi-task data for multiagent cooperation. arXiv preprint arXiv:2503.21200. Liu, Y.; Ji, J.; An, L.; Jaakkola, T.; Zhang, Y.; and Chang, S. 2026b. How well do agentic skills work in the wild: Benchmarking llm skill usage in realistic settings. arXiv preprint arXiv:2604.04323. Qian, C.; Acikgoz, E. C.; Wang, H.; Chen, X.; Sil, A.; Hakkani-Tur, D.; Tur, G.; and Ji, H. 2025. SMART: Selfaware agent for tool overuse mitigation. In Findings of the Association for Computational Linguistics: ACL 2025, 4604–4621.
Qwen Team. 2026. Qwen3.6-27B: Flagship-Level Coding in a 27B Dense Model. Shridhar, M.; Yuan, X.; Côté, M.-A.; Bisk, Y.; Trischler, A.; and Hausknecht, M. 2020. Alfworld: Aligning text and embodied environments for interactive learning. arXiv preprint arXiv:2010.03768. Su, W.; Long, J.; Ai, Q.; He, Q.; Tang, Y.; Wang, C.; Tu, Y.; Wang, Y.; and Liu, Y. 2026. Skill retrieval augmentation for agentic AI. arXiv preprint arXiv:2604.24594. Wang, G.; Xie, Y.; Jiang, Y.; Mandlekar, A.; Xiao, C.; Zhu, Y.; Fan, L.; and Anandkumar, A. 2023. Voyager: An openended embodied agent with large language models. arXiv preprint arXiv:2305.16291. Wang, J.; Ming, Y.; Ke, Z.; Joty, S.; Albarghouthi, A.; and Sala, F. 2026a. Skillorchestra: Learning to route agents via skill transfer. arXiv preprint arXiv:2602.19672. Wang, J.; Yan, Q.; Wang, Y.; Tian, Y.; Mishra, S. S.; Xu, Z.; Gandhi, M.; Xu, P.; and Cheong, L. L. 2026b. Reinforcement learning for self-improving agent with skill library. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 1529– 1550. Wang, L.; Wang, Z.; and Xu, A. 2026. Skilltester: Benchmarking utility and security of agent skills. arXiv preprint arXiv:2603.28815. Wang, R.; Jansen, P.; Côté, M.-A.; and Ammanabrolu, P. 2022. Scienceworld: Is your agent smarter than a 5th grader? In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, 11279–11298. Xia, T.; Hu, L.; Sun, Y.; Xu, M.; Xu, L.; Wang, S.; Xu, W.; and Jiang, J. 2026. GraSP: Graph-structured skill compositions for LLM agents. arXiv preprint arXiv:2604.17870. Xiaomi MiMo Team. 2026. MiMo-V2.5-Pro. https:// huggingface.co/collections/XiaomiMiMo/mimo-v25. Xu, R.; and Yan, Y. 2026. Agent skills for large language models: Architecture, acquisition, security, and the path forward. arXiv preprint arXiv:2602.12430. Zhang, Y.; Li, M.; Long, D.; Zhang, X.; Lin, H.; Yang, B.; Xie, P.; Yang, A.; Liu, D.; Lin, J.; Huang, F.; and Zhou, J. 2025. Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models. arXiv preprint arXiv:2506.05176. Zheng, Y.; Zhang, Z.; Ma, C.; Yu, Y.; Zhu, J.; Wu, Y.; Xu, T.; Dong, B.; Zhu, H.; Huang, R.; et al. 2026. Skillrouter: Skill routing for llm agents at scale. arXiv preprint arXiv:2603.22455.
A
Additional Token Consumption Results
Table 3: Detailed token consumption results on ALFWorld and ScienceWorld. “Num.” denotes the average number of selected skills, and “Tokens” denotes the average token consumption during task execution. Lower token consumption is better. ALFWorld Model
Method
Seen
ScienceWorld Unseen
Seen
Unseen
Num.
Tokens
Num.
Tokens
Num.
Tokens
Num.
Tokens
DeepSeek-v4-Flash
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
1–2 1–2 1–2 1.30
60324 59323 59062 52900
1–2 1–2 1–2 1.291
66087 66810 62727 59696
1–2 1–2 1–2 1.299
65256 65739 66916 56810
1–2 1–2 1–2 1.275
73807 73343 70784 63513
GPT-5.4-Mini
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
1–2 1–2 1–2 1.30
104807 73830 76686 71102
1–2 1–2 1–2 1.291
101451 72594 71752 68036
1–2 1–2 1–2 1.299
53019 54665 57005 52882
1–2 1–2 1–2 1.275
57797 58691 58369 53700
Qwen3.6-27B
LLM-as-selector SkillRouter Graph of Skills SkillReranker (ours)
1–2 1–2 1–2 1.30
37952 42685 37731 36824
1–2 1–2 1–2 1.291
44839 48302 39579 38453
1–2 1–2 1–2 1.299
60976 47124 52212 44826
1–2 1–2 1–2 1.275
55616 76143 50360 76763
B
Prompt Templates
This appendix provides the prompt templates used for structured task parsing and skill parsing. Appendix B.1 shows the prompt used to decompose a task into high-level subtasks and key sub-states, while Appendix B.2 shows the prompt used to extract the precondition and completion states from each skill document.
B.1
Task Parsing Prompt
The following prompt is used to parse each task instruction into an ordered sequence of high-level subtasks and the corresponding key task states. Task parsing prompt 1 2 3 4
5 6 7 8 9 10 11 12 13 14 15
Analyze the given task and decompose it into a sequence of high-level subtasks in logical execution order. After identifying the subtasks, define the corresponding key sub-states based on the task progress before and after each subtask. To help understand the task space, assume the system can perform the following actions: Go to, Take, Move, Open, Close, Use, Clean, Heat, Cool, Examine. (Replacement for ScienceWorld: To help understand the task space, assume the system operates in a multi-room environment, can explore to find required items, and has access to the following actions: Open, Close, Activate, Deactivate, Connect-to, Disconnect, Use, Look around, Examine, Look at, Read, Move-to, Pick up, Pour-into, Mix, Teleport to, Focus on, and Wait.)
Task: {question} Subtask Decomposition Rules: 1. Each subtask should represent a meaningful execution stage of the task rather than an atomic action, and merge simple or closely related steps into a single subtask. 2. It should be described in one complete sentence that balances abstraction and specificity, avoiding both excessive granularity and excessive vagueness. 3. Use the minimum number of subtasks necessary to represent the task flow. State Decomposition Rules:
16 17 18 19 20 21 22 23 24 25 26 27 28
B.2
1. State 1 must describe the initial state of the task before any subtasks are executed . Each subsequent state should describe the new task status achieved after completing the previous subtask. 2. Each state should describe the status or progress of the task in a single sentence, rather than the agent’s internal state or irrelevant environmental details. 3. The number of states must equal the total number of subtasks plus one. Output one item per line using exactly this format (no preamble, no extra text): Subtask 1: <one complete sentence describing the first subtask to be executed> ... Subtask N: <one complete sentence describing the last subtask to be executed> State 1: <one complete sentence describing the initial task state> State 2: <one complete sentence describing the state after Subtask 1> ... State N+1: <one complete sentence describing the final goal-achieved state>
Skill Parsing Prompt
The following prompt is used to parse each skill document into two structured state descriptions, namely the precondition state and the completion state. Skill parsing prompt 1 2 3 4 5 6 7 8 9 10 11
12
13 14 15 16 17 18 19 20 21
You are analyzing an AI skill. A skill is a reusable capability designed to address a specific task or scenario. Your job is to analyze the skill’s operational boundaries from its full documentation. Skill name: {skill_name} Skill full content: {content} Based on the complete skill content above, extract two structured fields that describe how this skill connects to the corresponding task state: Precondition_State: The task state that must be satisfied BEFORE this skill can be invoked. Derive the corresponding task state either by analyzing explicit precondition descriptions or by summarizing the relevant required conditions from the skill’s overall description. Do not directly copy prerequisite statements or raw text; instead, convert them into concrete task-state descriptions. Use 1-2 sentences to describe the required state. If the skill content does not imply any necessary precondition state, output exactly "None". Completion_State: The task state or outcome achieved AFTER this skill successfully executes. Derive this from the documented outputs, expected results, or the final state implied by the execution process. Do not directly copy textual descriptions from the skill content; instead, summarize the resulting task state or accomplished goal in 1-2 sentences. Requirements: 1. Ground every statement in the actual skill content; do not invent details not supported by the text. 2. Keep the description focused on the execution states associated with the skill itself rather than on any specific example invocation. Output in exactly this format (no preamble, no extra text): Precondition_State: <1-2 sentences describing or summarizing the precondition state, or "None"> Completion_State: <1-2 sentences describing or summarizing the completion state>