betaFeedback

WorksComputer Science

SkillBrowser: Selective Skill Exposure for Scalable Skill-Using Agents

Abstract

Large language model agents increasingly rely on skills to extend their capabilities in complex tasks. However, scalable skill use requires Selective Skill Exposure (SSE): providing relevant procedural content when needed while avoiding unnecessary exposure that may disrupt reasoning. Existing paradigms fall short in complementary ways. Progressive disclosure exposes metadata for a growing skill library, introducing context pollution; retrieval limits catalog exposure, but static retrieval from the initial task query may be misaligned with capability needs that emerge during reasoning and may still inject unnecessary skills. We propose SkillBrowser, a Meta-Skill-managed framework that enables an agent to identify current capability needs, formulate targeted queries, and selectively load skills on demand. Across six SRA-Bench subsets and five LLMs, SkillBrowser improves aggregate accuracy over static retrieval and LLM-based selection, including multi-step tool use, and mitigates accuracy degradation on already-solvable instances. Benefits remain model- and task-dependent, with under-invocation of useful skills and additional latency as key limitations. These results demonstrate the viability of Meta-Skill-managed SSE for scalable skill repositories.

Introduction

Large language models have rapidly evolved from passive text generators into agentic systems capable of planning, tool invocation, environmental interaction, and iterative problem solving. As LLM-based agents are applied to increasingly open-ended and long-horizon tasks, they must draw on external reusable capabilities beyond their static parametric knowledge. Such modularity enables agents to reuse procedural knowledge and interact with task-specific resources in a structured manner.

Skills extend LLM agents with reusable task-specific capabilities: each Skill contains procedural instructions and may include auxiliary resources such as scripts or references Xu and Yan (2026). Unlike callable tools, loaded Skills contribute instructions directly to the agent’s working context and can therefore influence its subsequent reasoning Li et al. (2026b); Han et al. [7]. This property raises a central scalability problem, which we term Selective Skill Exposure (SSE): a scalable Skill system should expose the procedural support needed for solving a task while avoiding unnecessary Skill information that may disrupt the agent’s reasoning.

Existing paradigms fall short of SSE in complementary ways. Recent Skill-compatible agents commonly adopt progressive disclosure, exposing lightweight metadata, typically Skill names and descriptions, before loading detailed instructions and resources on demand Xu and Yan (2026); Jiang et al. [8]. Although this avoids preloading every full Skill, its globally exposed metadata still grows with the repository, consuming context budget, introducing semantic noise, and preventing the agent from accessing the required Skill Zheng et al. (2026). As illustrated in Figure 1 (a), metadata exposure alone may exhaust the available context before the Gold Skill is loaded.

Motivating example of Skill access over a large repository

Figure 1. Motivating example of Skill access over a large repository. (a) Progressive disclosure exposes excessive Skill metadata to the agent and distracts it from loading the required Skill, while (b) static retrieval is misled by a noisy user query. (c) SKILLBROWSER lets the agent formulate a capability-oriented query and retrieve the required Skill on demand, enabling a correct solution.

Retrieval provides a natural alternative by selecting a small subset of Skills from an external repository Su et al. (2026); Cho et al. [4]; Lumer et al. (2025). However, static Skill retrieval addresses exposure size rather than SSE itself. First, retrieving from the initial user request may be misaligned with the procedural capability required during solving: as shown in Figure 1 (b), that capability may be obscured by a noisy request or emerge only after reasoning begins. Second, once retrieved, Skill contents are injected irrespective of whether external procedural assistance is necessary. Because Skills alter the reasoning context, such blind injection may interfere with tasks that the agent could otherwise solve correctly.

To address this problem, we propose SKILLBROWSER, a Meta-Skill-managed framework for selective Skill exposure over large Skill repositories. Rather than globally exposing Skill metadata or unconditionally injecting statically retrieved Skills, SKILLBROWSER equips the agent with a reusable Meta-Skill that governs access to the repository during reasoning. The agent can identify its current capability need, generate a targeted query, retrieve relevant Skills through SKILLGREP, and load selected Skill contents only on demand, as illustrated in Figure 1 (c). This design changes repository access from passive exposure to agent-controlled acquisition: repository scale is decoupled from the context visible to the agent, while unnecessary procedural content need not enter an already successful reasoning process.

Our contributions are as follows:

  • We formulate Selective Skill Exposure as a central problem in scaling Agent Skills, and identify two complementary failures of existing paradigms: metadata-level context pollution under progressive disclosure and capability misalignment or unnecessary Skill exposure under static retrieval.

  • We propose SKILLBROWSER, a Meta-Skill-managed framework that allows agents to decide whether external Skills are needed, formulate structured capability-oriented queries and load retrieved Skill contents on demand during problem solving.

  • We develop SKILLGREP, a capability-oriented Skill search system that expands Skill metadata into multiple retrieval views and applies hybrid retrieval to align agent-formulated needs with relevant Skills.

  • We conduct experiments on SRA-Bench (Su et al., 2026), showing improved end-task performance over static retrieval and substantially reduced degradation from unnecessary Skill exposure on already-solvable instances.

Related Work

Skill-Based Agents

Early tool-augmented agents extend LLMs with external callable capabilities: ReAct (Yao et al., 2023) establishes the reasoning-and-acting paradigm, while API-Bank, ToolLLM, and Gorilla (Li et al., 2023; Qin et al., 2024; Patil et al., 2024; Patel et al., 2026) study API use and selection over increasingly large tool collections. Recent Agent Skills broaden this abstraction to reusable capability packages containing procedural instructions and optional resources such as scripts, templates, examples, or references (Xu and Yan, 2026). Unlike callable tools, Skills are loaded as procedural context for subsequent reasoning.

To access Skills efficiently, recent systems commonly adopt progressive disclosure, exposing compact metadata before loading detailed Skill contents on demand [8] (Xu and Yan 2026). Although this avoids preloading full Skill documents, the exposed metadata catalog still grows with the repository and may hinder reliable Skill selection at scale (Zheng et al., 2026). This limitation motivates retrieving a compact candidate set rather than exposing the full Skill catalog; however, as discussed next, retrieval alone does not determine whether the returned procedural contents should enter the agent’s reasoning context.

Skill Retrieval Methods

Retrieval provides an alternative to global capability exposure. Prior work investigates dedicated tool retrieval, feedback-enhanced retrieval, and generation-based tool selection over large tool inventories [5] (Xu et al. 2024; Wang et al. 2025; Shi et al. 2025). ToolReAGt further performs iterative retrieval of callable tools for decomposed complex requests [1]. These methods are related to our work in external capability access, but focus on executable tool interfaces rather than procedural Skill contents injected into the model context.

In the Skill setting, SRA retrieves Skills from a large external corpus and evaluates both retrieval quality and downstream Skill use (Su et al., 2026; Liu et al., 2026), while SkillRouter studies large-scale Skill routing with richer Skill representations (Zheng et al., 2026). We study a complementary problem: static retrieval may fail to match capability needs that emerge during reasoning, and retrieved Skill contents need not always be exposed to the agent. SkillBrowser addresses this problem through Meta-Skill-managed access, allowing agents to formulate capability-oriented queries and load selected Skills on demand.

Selective Capability Use

Beyond selecting which external capability is relevant, a complementary line of work studies whether external assistance should be used at all. In tool-augmented agents, When2Call explicitly evaluates decisions to invoke a tool, request clarification, or refrain from tool use, while When2Tool studies tool necessity under controlled capability boundaries and shows that agents frequently invoke tools even when their parametric capabilities suffice (Ross et al., 2025; Sun et al., 2026). Moving from tool invocation to retrieval, ProactAgent treats access to factual, episodic, and behavioral-skill experience as an explicit policy action and learns when and what to retrieve through process-level reinforcement learning [2]. These works establish that capability access itself can be treated as a decision rather than mandatory.

Recent work has begun to study this question specifically for Agent Skills. SelSkill formulates Skill use as a decision-point-level skill-or-skip problem and learns selective invocation through dual-granularity preference learning [3]. SkillApt instead separates retrieval from activation: after a candidate Skill has already been retrieved, it uses counterfactual evidence from matched executions to decide whether the Skill should actually be loaded [6]. Skill-Gate trains in-policy, mid-episode Skill selection with action-local credit assignment over a visible candidate slate, reducing exposure to misleading Skills, although its selection-specific objective does not directly assign credit to abstention (Li et al., 2026a). SkillBrowser differs in both the decision point and the mechanism: we study pre-retrieval Skill necessity, allowing an agent to bypass Skill search entirely when external procedural guidance is unnecessary, while jointly formulating a capability-oriented query when search is warranted. Moreover, unlike learned invocation or activation policies, this control is realized through a training-free Meta-Skill and can be combined with different underlying Skill retrieval methods.

Motivation

Accessing a large Skill library requires deciding which Skills should enter the agent’s working context. Existing paradigms make this decision imperfectly: progressive disclosure exposes metadata for a growing candidate catalog, while static retrieval exposes a small set of Skill contents selected from the initial task query. We formulate the resulting problem as Selective Skill Exposure: a scalable Skill access mechanism should expose only the information necessary for the agent’s current solving need, avoiding both irrelevant metadata and unnecessary procedural contents.

Progressive Disclosure Does Not Eliminate Context Pollution

As the Skill repository grows, progressive disclosure requires the agent to identify the needed capability from an increasingly large metadata catalog. We examine whether this growing metadata exposure impairs reliable Skill access.

We evaluate this effect by fixing the task instances, backbone model, and target Skill, while varying only the number of exposed Skill descriptions, denoted by KK. Figure 2 reports downstream accuracy and gold-Skill loading rate (Gold Load).

Figure 2. Effect of scaling the number of exposed skill descriptions under progressive disclosure.

Increasing KK consistently reduces the agent’s ability to load the required Skill. For example, on MedCalcBench, Qwen3-8B’s Gold Load decreases from 76.1 at K=4K = 4 to 48.7 at K=32K = 32, with accuracy dropping from 68.6 to 58.6. On TheoremQA, Qwen3.6-Plus’s Gold Load further drops from 71.2 at K=4K = 4 to 7.1 at K=512K = 512.

Since only the number of exposed descriptions changes, this degradation reveals metadata-level context pollution: progressive disclosure reduces full-content exposure, but does not provide scalable selective access to large Skill repositories.

Static Retrieval May Misalign with Agent Needs

Static retrieval relies on the original task query to identify relevant Skills before solving. We examine whether this query adequately represents the procedural capability required by the agent.

To examine this assumption, we compare LLM gold-Skill identification with static retrieval under a fixed library size of K=16K = 16. Table 1 reports Gold Load when models directly observe candidate Skill descriptions, together with Recall@5 for BM25 and SkillGrep static retrieval from the original query. Once candidates are available, both models identify the gold Skill with near-perfect reliability. In contrast, even SkillGrep retrieval reaches only 31.7 Recall@5 on LogicBench and 32.1 on CHAMP, far below the corresponding agent-side Gold Load rates.

MethodTheo.LogicCHAMPMedCalcBigCode
Qwen3-8B GL99.3100.098.7100.099.1
Qwen3.6-Plus GL99.598.5100.0100.092.6
BM25 R@577.728.730.766.396.5
SkillGrep R@582.031.732.181.386.9

Table 1. Comparison between agent-side gold-skill identification and static retrieval from the original task query under a skill library of size N=16N = 16. GL denotes the gold-skill loading rate, and R@5 denotes Recall@5.

This gap indicates that stronger matching alone is insufficient: the original query may describe task context or final objectives rather than the intermediate capability needed during solving. Thus, static retrieval bounds exposure size, but may expose Skills misaligned with the agent’s current procedural need.

Design Implication: Selective Skill Exposure

Together, these observations show that scalable Skill access requires controlling how Skill contents enter the agent’s context. Progressive disclosure forces the agent to select Skills from an increasingly polluted metadata context, while static retrieval may preselect Skills from an initial query that does not reflect the capability need emerging during solving. Furthermore, retrieved Skill contents should not be injected unconditionally when external support is unnecessary. We therefore formulate Selective Skill Exposure: Skill contents should be introduced according to the agent’s current capability need, rather than through global metadata exposure or one-shot query-based retrieval. We instantiate this principle with Skill-Browser in the next section.

Methods

We propose SKILLBROWSER, a Meta-Skill-managed framework for Selective Skill Exposure over a large external Skill repository. As illustrated in Figure 3, SKILLBROWSER separates scalable repository maintenance from online Skill access: SKILLGREP maintains an offline searchable library, while a reusable Meta-Skill allows the solving agent to request and load external Skills only when needed.

Figure 3. Overview of SKILLBROWSER. A reusable Meta-Skill enables the agent to decide whether external procedural support is needed and, when necessary, formulate a retrieval intent for SKILLGREP. Only selected Skills are introduced into the agent–environment interaction loop.

Selective Skill Exposure Formulation

Let S={(mj,fj)}j=1N\mathcal{S} = \{(m_j, f_j)\}_{j=1}^{N} denote an external Skill repository, where mjm_j is the metadata of the jj-th Skill and fjf_j is its full procedural content. Let PP denote the user task and ci−1c_{i-1} the solving context before the ii-th potential Skill exposure step. For any subset A⊆S\mathcal{A} \subseteq\mathcal{S}, we denote the corresponding full Skill contents by

F(A)={fj∣(mj,fj)∈A}.(1)\mathcal{F}(\mathcal{A}) = \{f_j \mid(m_j, f_j) \in\mathcal{A}\}. \tag*{(1)}

Following the definition of Selective Skill Exposure introduced above, we formalize the ideal Skill exposure under the agent’s current solving state. At step ii, let

zi⋆∈{0,1}(2)z_i^\star\in\{0,1\} \tag*{(2)}

denote whether external Skill contents should be introduced, where zi⋆=0z_i^\star= 0 indicates that no additional Skill is needed and zi⋆=1z_i^\star= 1 indicates that external procedural support is required. When zi⋆=1z_i^\star= 1, let Sineed⊆S\mathcal{S}_i^{\mathrm{need}} \subseteq\mathcal{S} denote the Skills providing the required capability. The ideal exposure is

Ei⋆={∅,zi⋆=0,F(Sineed),zi⋆=1.(3)\mathcal{E}_i^\star= \begin{cases} \varnothing, & z_i^\star= 0,\\ \mathcal{F}(\mathcal{S}_i^{\mathrm{need}}), & z_i^\star= 1. \end{cases} \tag*{(3)}

Existing paradigms instantiate exposure differently. Progressive disclosure conditions Skill selection on the exposed repository metadata:

EmetaPD={mj}j=1N.(4)\mathcal{E}_{\mathrm{meta}}^{\mathrm{PD}} = \{m_j\}_{j=1}^{N}. \tag*{(4)}

Static retrieval instead directly exposes the contents of Skills retrieved from the initial task query:

ESR=F(R(P,S,k)).(5)\mathcal{E}^{\mathrm{SR}} = \mathcal{F}(R(P,\mathcal{S},k)). \tag*{(5)}

Neither formulation represents the state-dependent ideal Ei⋆\mathcal{E}_i^\star: the former requires selection over repository metadata, while the latter fixes exposure through task-level retrieval without an explicit no-exposure decision.

Approximating Ei⋆\mathcal{E}_i^\star requires exposing relevant Skills only when an external capability need arises during solving. SKILLBROWSER implements this by providing a Meta-Skill-managed search interface that the agent can invoke within its ordinary reasoning trajectory, while SKILLGREP retrieves Skills matching the expressed need.

Meta-Skill-Managed Agent Loop

The online interaction process is shown in the center of Figure 3. We provide the agent with a fixed Meta-Skill s⋆s^\star together with the user task. Unlike task-specific Skills, s⋆s^\star does not contain a procedure for solving a particular problem. Instead, it describes how the agent can access the external Skill repository when its ongoing reasoning requires additional procedural support.

Importantly, the Meta-Skill does not impose a separate retrieve-or-not decision stage. The agent proceeds with ordinary inference and environment interaction, and may invoke SkillGrep through the Meta-Skill whenever an external capability need arises. When such an invocation occurs at step ii, the agent constructs a structured retrieval query

qi=QM(P,ci−1;s⋆),(6)q_i = Q_M(P, c_{i-1}; s^\star), \tag*{(6)}

where qiq_i expresses the capability needed under the current solving context rather than simply repeating the original task request.

In our implementation, qiq_i may include a concise capability description, relevant task context, required or preferred capability attributes, type hints, positive or negative retrieval signals, and explicit constraints. These fields allow the agent to articulate diverse intermediate needs, refine retrieval when necessary, and reuse the same Meta-Skill across heterogeneous tasks.

Given the agent’s invocation behavior, the actual repository-derived exposure introduced by SkillBrowser is

EiSB={F(R(qi,S,k)),invocation,∅,otherwise.(7)\mathcal{E}^{\mathrm{SB}}_i = \begin{cases} \mathcal{F}(R(q_i, \mathcal{S}, k)), & \text{invocation},\\ \varnothing, & \text{otherwise}. \end{cases} \tag*{(7)}

Retrieved Skills are then returned to the agent loop as additional procedural context. Depending on the task, they may provide a formula, reasoning procedure, domain workflow, software usage pattern, or tool-use instruction, which the agent applies in subsequent inference and interaction.

This design approximates selective Skill exposure without prescribing when retrieval must occur: the Meta-Skill makes external Skill access available as a reusable capability, while the agent retains flexibility over whether and when to invoke it during problem solving. It relies on capability-need recognition but does not assume that this recognition is accurate. The ideal variable zi⋆z_i^\star is a conceptual target, not an observed supervision label; BER and UER diagnose the model’s access behavior rather than certify correct self-assessment.

SkillGrep: Capability-Oriented Skill Retrieval

Once the agent invokes Skill search with a structured query qiq_i, SkillGrep retrieves a small set of Skills that approximate the capability required at the current solving state:

S^i=R(qi,S,k)≈Sineed.(8)\widehat{\mathcal{S}}_i = R(q_i, \mathcal{S}, k) \approx\mathcal{S}^{\mathrm{need}}_i. \tag*{(8)}

As shown on the right side of Figure 3, SkillGrep consists of offline repository construction and online retrieval. Offline, each raw Skill is converted into searchable representations derived from its metadata and instructional content, such as capability descriptions, usage conditions, representative queries, and the original instructions. This preprocessing provides a shared retrieval interface for heterogeneous Skills while preserving their original contents.

Online, SkillGrep matches the agent-generated query against these representations using hybrid retrieval. It combines lexical matching, which captures precise terms and identifiers, with semantic matching, which captures paraphrased capability needs, and fuses the resulting rankings to return the top-kk Skills. The contents of the retrieved Skills are then returned to the agent loop for subsequent application. Further implementation details are provided in Appendix § 7.

Experiments

Experimental Setup

Benchmarks. We evaluate SkillBrowser on six subsets of SRA-Bench (Su et al., 2026): TheoremQA, LogicBench, CHAMP, MedCalcBench, BigCodeBench, and ToolQA. The first five cover theorem application, logical reasoning, mathematical problem solving, clinical calculation, and software-library usage. ToolQA additionally evaluates multi-step tool interaction, jointly testing Skill retrieval, exposure, tool selection, and execution. All full-corpus retrieval experiments use the same fixed repository of 26,262 candidate Skills. Appendix § 8 gives benchmark details.

Models. We use five LLMs from different model families: Qwen3-8B, Qwen3.6-Plus, GLM-5.1, GPT-5.4-mini, and Gemini-3.1-Flash-Lite.

Methods. SkillBrowser combines Meta-Skill-managed access with SKILLGREP. Static BM25 and Static SkillGrep retrieve from the initial task query and expose the retrieved contents before solving; Static SkillGrep shares the full framework’s retrieval backend. LLM Selection follows the SR-Agent baseline (Su et al., 2026), selecting Skills from a precomputed BM25 top-50 candidate set. Gold Exposure directly provides the annotated gold Skill as a relevance-controlled reference, not a performance upper bound. Meta-Skill+BM25 retains managed access with BM25 retrieval for component analysis. Progressive disclosure is evaluated separately as a feasible-budget scaling diagnostic (Figure 2), since exposing metadata for all 26,262 Skills exceeds the evaluated context budget.

Retrieval configuration. Dense retrieval uses bge-base-en-v1.5 with mean pooling and L2 normalization. Retrieval evaluation uses k=5k = 5. Multi-view weights, fusion weights, and the abstention threshold were selected by grid search on the development set; Appendix § 7 specifies the available scoring configuration.

Metrics. We report end-task accuracy as the primary metric. For Selective Skill Exposure, we additionally analyze two subsets constructed separately for each model–benchmark pair: skill-beneficial instances, which are solved incorrectly without Skills but correctly with the gold Skill, and skill-unnecessary instances, which are solved correctly under both conditions. We report Beneficial Exposure Rate (BER) on the former and Unnecessary Exposure Rate (UER) on the latter, each defined as the fraction of instances receiving retrieved Skill contents. These are outcome-conditioned, model-dependent diagnostic partitions, not intrinsic labels of Skill necessity; they omit instances incorrect under both conditions and those harmed by gold exposure. BER measures exposure to any retrieved Skill, not successful gold-Skill retrieval. We additionally report retrieval quality, end-to-end resource use, and paired correctness comparisons.

Main Results

Table 2 reports accuracy across five models and six benchmarks. SkillBrowser outperforms Static BM25 in 26 of 30 settings and Static SkillGrep in 23, with one tie against the latter. Because Static SkillGrep uses the same retrieval backend, this comparison controls for backend strength while changing both query formulation and exposure timing. It does not isolate the no-exposure decision from capability-oriented query generation.

ModelMethodTHEO.LOGICCHAMPMEDCALCBIGCODETOOLQA
Qwen3-8BSkillBrowser71.079.568.265.446.744.0
Qwen3-8BStatic SKILLGREP61.772.069.060.646.717.0
Qwen3-8BStatic BM2553.072.067.351.445.817.0
Qwen3-8BLLM Selection56.080.061.071.042.013.0
Qwen3-8BGold Exposure58.987.066.875.050.051.0
Qwen3.6-PlusSkillBrowser84.584.181.293.061.057.0
Qwen3.6-PlusStatic SKILLGREP83.180.982.190.157.327.0
Qwen3.6-PlusStatic BM2583.980.081.687.858.332.0
Qwen3.6-PlusLLM Selection83.084.080.092.054.040.0
Qwen3.6-PlusGold Exposure83.590.584.391.759.776.0
GLM-5.1SkillBrowser82.584.374.990.761.751.0
GLM-5.1Static SKILLGREP78.180.379.480.559.339.0
GLM-5.1Static BM2577.973.078.573.260.037.0
GLM-5.1LLM Selection78.084.077.088.057.041.0
GLM-5.1Gold Exposure78.189.780.387.260.073.0
GPT-5.4-miniSkillBrowser80.771.778.985.062.043.0
GPT-5.4-miniStatic SKILLGREP76.777.776.281.057.732.0
GPT-5.4-miniStatic BM2574.368.373.581.059.333.0
GPT-5.4-miniLLM Selection75.081.078.083.055.031.0
GPT-5.4-miniGold Exposure78.085.376.284.163.071.0
Gemini-3.1-Flash-LiteSkillBrowser81.369.374.983.058.061.0
Gemini-3.1-Flash-LiteStatic SKILLGREP81.080.775.382.656.318.0
Gemini-3.1-Flash-LiteStatic BM2583.072.769.179.957.717.0
Gemini-3.1-Flash-LiteLLM Selection81.075.079.082.052.038.0
Gemini-3.1-Flash-LiteGold Exposure83.087.771.381.759.370.0

Table 2. End-task accuracy (%). Static SKILLGREP shares the retrieval backend of SKILLBROWSER. LLM Selection selects from a BM25 top-50 set. Gray rows denote Gold Exposure, a relevance-controlled reference rather than an upper bound.

Against LLM Selection, the reported comparison yields 21 wins, four ties, and five losses at whole-percentage-point reporting precision. Improvements are task-dependent: the advantage over Static SkillGrep is consistent across all five models on TheoremQA, MedCalcBench, and ToolQA, whereas losses remain on CHAMP and LogicBench. On ToolQA, SkillBrowser reaches 43–61% accuracy versus 17–39% for static retrieval. Appendix § 11 details retrieval behavior.

Gold Exposure does not consistently achieve the highest accuracy: SkillBrowser surpasses it in 13 of 30 settings, comprising four on TheoremQA, four on MedCalcBench, three on CHAMP, and two on BigCodeBench. This does not establish that retrieved Skills are more relevant than the gold annotations. Relevant instructions may be redundant, may have mismatched granularity, or may alter an otherwise successful reasoning trajectory. The transition analysis in Appendix § 13 examines both gains and failures without attributing all improvements to skipping retrieval.

Paired statistical evidence. On valid paired predictions pooled across six datasets, SkillBrowser improves over Static SkillGrep (78.59% vs. 74.64%; N=11,736N = 11{,}736; two-sided exact McNemar p=1.46×10−28p = 1.46 \times10^{-28}) and LLM Selection (75.93% vs. 72.82%; p=4.41×10−10p = 4.41 \times10^{-10}), while remaining below Gold Exposure (78.59% vs. 80.52%; p=1.49×10−8p = 1.49 \times10^{-8}). These pooled comparisons use baseline-specific valid intersections, so their accuracies need not match macro-averages of Table 2. They support aggregate differences, not uniform gains or significance in every setting; Appendix § 14 reports discordant counts and interpretation limits.

Selective Skill Exposure Analysis

Table 3 compares Meta-Skill-managed access with Static SkillGrep under the same retrieval backend. Static SkillGrep exposes retrieved Skill contents for every query, whereas Meta-Skill-managed access allows the agent to decide whether external procedural support should enter its reasoning context. This comparison controls for retrieval-backend strength; its effect jointly reflects the decision to search and the capability-oriented queries generated when searching.

ModelExposure (%) SB.Exposure (%) SG.Accuracy (%) SB.Accuracy (%) SG.NN
Skill-Beneficial (↑ exposure; ↑ accuracy)
Qwen3-8B74.9100.067.167.1859
Qwen3.6-Plus80.3100.076.277.4336
GLM-5.184.0100.085.377.1556
GPT-5.4-mini30.3100.046.272.4145
Gemini-3.1-Flash-Lite34.0100.026.274.5141
Skill-Unnecessary (↓ exposure; ↑ accuracy)
Qwen3-8B66.5100.095.285.41216
Qwen3.6-Plus77.4100.099.195.82173
GLM-5.188.2100.098.295.11852
GPT-5.4-mini45.1100.098.893.6763
Gemini-3.1-Flash-Lite43.4100.097.493.7772

Table 3. Selective Skill Exposure analysis aggregated across the four diagnostic benchmarks (TheoremQA, LogicBench, CHAMP, and MedCalcBench). SB. denotes the full SkillBrowser pipeline and SG. denotes static SkillGrep retrieval. Blue-shaded bold values indicate the better accuracy between the two methods. Full model–benchmark results are provided in Appendix § 9.

Avoiding unnecessary exposure. On skill-unnecessary instances, Meta-Skill-managed access reduces exposure and improves accuracy for every model after aggregation across the four diagnostic benchmarks. Since these instances are already solvable without external Skills, the result shows that even retrieved procedural contents can disturb otherwise correct reasoning when introduced unconditionally. This finding directly supports SSE: Skill access requires controlling not only which Skills are retrieved, but also whether their contents should be exposed to the agent at all.

Selective access to beneficial Skills. The fine-grained results in Appendix § 9 reveal model-dependent behavior. Qwen3-8B, Qwen3.6-Plus, and GLM-5.1 expose Skills more often on beneficial than unnecessary instances in multiple benchmarks. However, GPT-5.4-mini and Gemini-3.1-Flash-Lite frequently under-invoke Skills on beneficial instances, particularly on LogicBench and CHAMP. The framework makes capability-need recognition explicit but does not solve it. These outcome-conditioned subsets diagnose such failures for a particular backbone and run; they do not establish model-independent Skill necessity or a causal effect of exposure alone.

Component Analysis

Table 4 examines how the retrieval backend and exposure policy contribute to the effectiveness of SKILLBROWSER.

ExposureRetrieverTHEO.LOGICCHAMPMEDCALC
StaticBM2574.4273.2074.0074.66
StaticSG.76.1278.3276.4078.96
MetaBM2575.5274.3271.4077.66
MetaSG.80.0077.7875.6283.42

Table 4. Component analysis averaged across backbone models, measured by end-task accuracy (%). Static and Meta denote static exposure and Meta-Skill-managed exposure, respectively; SG. denotes SkillGrep. Meta + SG. is the full SkillBrowser framework. Blue-shaded values indicate the best result in each column.

Effect of SKILLGREP. Under static exposure, replacing BM25 with SKILLGREP improves average accuracy by 3.38 points. The largest gains occur on LOGICBENCH and MEDCALCBENCH (+5.12 and +4.30 points), showing that retrieval-oriented Skill representations and hybrid matching improve the quality of Skills selected from the original query.

Effect of Meta-Skill-managed exposure. With BM25 retrieval fixed, Meta-Skill-managed exposure yields a modest average improvement, with its clearest benefit on MEDCALCBENCH (+3.00 points). This is consistent with its long clinical queries, where the required procedure can be better articulated during solving. In contrast, performance decreases on CHAMP (−2.60 points), where models may not request external support for tasks that appear solvable through internal reasoning.

Complementarity of the two components. Combining Meta-Skill-managed exposure with SkillGrep produces the strongest overall configuration, improving over Static + SkillGrep by 1.76 points on average. The gains are concentrated on TheoremQA and MedCalcBench (+3.88 and +4.46 points), while small drops remain on LogicBench and CHAMP. Together with the SSE analysis, these results indicate that improved retrieval and selective exposure are complementary when the required procedural capability is identifiable during solving, while recognizing beneficial Skill use remains challenging for tasks resembling ordinary internal reasoning.

Efficiency and Access Overhead

Across five models with 100 valid ToolQA trajectories each, SkillBrowser makes 383 retrieval calls on 500 trajectories (0.766 calls per trajectory). Every searching trajectory invokes SkillGrep exactly once and loads five candidates, yielding 3.83 loaded Skills per trajectory; 278/383 calls retrieve a gold Skill (72.6%). These are cross-model totals, distinct from the GLM-5.1 token and latency measurements.

Total ToolQA LLM calls vary by backbone: SkillBrowser uses more calls than LLM Selection for four models but fewer for GLM-5.1. For GLM-5.1, combined input/output token use is lower on three of six benchmarks and higher on the other three, whereas measured latency is higher on all six. LLM Selection uses precomputed BM25 candidates and its latency excludes that retrieval stage. Thus, selective access does not imply uniformly lower cost or latency. Appendix § 12 reports complete-trajectory token counts, LLM calls, and measured latency.

Retrieval components and stronger retrievers. Using initial task descriptions as queries over the same 26,262-Skill corpus, SkillGrep leads the SRA-Bench BGE, TF–IDF, BM25, and Contriever baselines on all six reported retrieval metrics (Appendix § 10). Leave-one-component-out ablations show contributions from dense retrieval, sparse views, reciprocal-rank-fusion scoring, and capability/type signals. GoldHit@5 drops from 0.623 to 0.463 without dense retrieval and to 0.462 without capability/type signals. Removing the compatibility penalty has negligible effect, so it is not a demonstrated source of gains on this benchmark.

Conclusion

In this work, we formulate Selective Skill Exposure as a central problem for scaling Skill-using LLM agents: procedural support should be introduced according to the agent’s current need, without exposing excessive metadata or unnecessary Skill contents. We show that existing paradigms fall short in complementary ways. Progressive disclosure remains vulnerable to metadata-level context pollution, while static retrieval may expose Skills selected from an initial query misaligned with the capability needed during reasoning.

We propose SKILLBROWSER, a Meta-Skill-managed framework for SSE. Rather than selecting Skills from a globally exposed catalog or unconditionally injecting retrieved contents, it makes Skill exposure an agent-initiated action: when procedural support is needed, the agent formulates a capability-oriented query through the Meta-Skill and retrieves relevant Skills from SKILLGREP for on-demand use.

Experiments on SRA-Bench show that metadata exposure impairs Skill loading at scale, while SKILLBROWSER improves end-task accuracy over static query-based retrieval, especially when the required procedure is obscured by noisy context. Meta-Skill-managed access further mitigates the degradation caused by unnecessary Skill exposure on already-solvable instances. The added ToolQA evaluation extends this evidence to multi-step tool interaction, while comparisons with LLM Selection support aggregate gains over a stronger deployable baseline. Under-invocation, task-dependent losses, and additional latency remain limitations of the approach.

Limitations

SKILLBROWSER depends on imperfect capability-need recognition. Models may under-invoke useful Skills on problems resembling ordinary internal reasoning, especially LogicBench and CHAMP. The beneficial/unnecessary partitions are model-and outcome-dependent diagnostics, not intrinsic necessity labels. They omit two reference-outcome groups and do not capture variability across repeated runs. Improving need recognition through targeted training, preference optimization, or uncertainty modeling is future work.

Our six-subset evaluation includes multi-step ToolQA interactions but uses a fixed repository. It does not test continual Skill addition, removal, or updating, persistent cross-session reuse, or long-horizon interaction with an evolving repository. A static corpus isolates exposure behavior from indexing, versioning, and invalidation. The separation between the agent interface and offline index could support dynamic repositories, but this extensibility has not been evaluated.

Retrieval adds latency, and token savings depend on the task. The LLM Selection timing excludes precomputed BM25 retrieval, so reported latency is not a fully symmetric online-system comparison. Pooled significance tests do not establish gains for every model or dataset; repeated task instances across backbones can also induce dependence among pooled observations. Broader sensitivity studies of kk, encoder choice, and abstention thresholds remain open.

Real repositories may contain erroneous, incomplete, or unsafe instructions. SSE addresses when and which Skills enter context; it does not verify their trustworthiness or guarantee safe execution. Provenance review at ingestion, content validation before loading, permission checks before tool use, and execution sandboxing are possible deployment safeguards, none of which is established by the present evaluation.

Detailed Design of SkillGrep

SkillGrep is the retrieval tool used by SkillBrowser to map an agent-generated retrieval intent to task-relevant skills. This appendix describes its repository construction, query representation, hybrid retrieval procedure, and compatibility-aware selection mechanism.

Retrieval-Oriented Skill Indexing

SkillGrep operates over an indexed skill repository. Each skill sjs_j is represented as a pair

sj=(mj,fj),(9)s_j = (m_j, f_j), \tag*{(9)}

where mjm_j is structured metadata used for retrieval and fjf_j is the full instructional content retained for downstream application. The metadata includes a skill description, capability annotations, usage conditions, representative positive examples, tags, interaction information, and optional input/output information.

For each skill, we construct a collection of searchable views:

Vj={vjdesc,vjcap,vjuse,vjex,vjschema,{vj,lsec}l}.(10)\mathcal{V}_j = \{v_j^{\mathrm{desc}}, v_j^{\mathrm{cap}}, v_j^{\mathrm{use}}, v_j^{\mathrm{ex}}, v_j^{\mathrm{schema}}, \{v_{j,l}^{\mathrm{sec}}\}_l\}. \tag*{(10)}

The description view contains the skill name, description, category, and tags. The capability view contains explicit capability annotations. The usage and example views represent when the skill should be used and typical matching queries. The schema view, when available, represents input/output characteristics. Finally, content-section views are constructed from sections of the full instructional document.

Sections describing failure modes, contraindications, or conditions under which a skill should not be used are not included as positive content views. Instead, they are retained as negative evidence for compatibility-aware scoring. This design preserves the complete skill content while separating information that supports retrieval from information that indicates non-applicability.

Structured Retrieval Intent

The input to SKILLGREP is a structured retrieval intent generated by the agent through the meta-skill. We denote it as

qi=(qitext,qictx,Cireq,Cides,Ii,Oi,Pi+,Pi−,Γi),(11)q_i = (q_i^{\mathrm{text}}, q_i^{\mathrm{ctx}}, C_i^{\mathrm{req}}, C_i^{\mathrm{des}}, I_i, O_i, P_i^{+}, P_i^{-}, \Gamma_i), \tag*{(11)}

where qitextq_i^{\mathrm{text}} is a concise capability-oriented query, qictxq_i^{\mathrm{ctx}} is task context, CireqC_i^{\mathrm{req}} and CidesC_i^{\mathrm{des}} are required and desired capabilities, IiI_i and OiO_i are input/output type hints, Pi+P_i^{+} and Pi−P_i^{-} are positive and negative signals, and Γi\Gamma_i contains explicit constraints.

For lexical retrieval, all non-empty fields are concatenated into a single query representation. For dense retrieval, the query is further decomposed into semantic groups aligned with the skill views:

qidesc=[qitext;qictx],qicap=[Cireq,Cides,qitext],qiuse=[Pi+;qitext],qischema=[Ii;Oi;Γi],qisec=[qictx;qitext].(12)\begin{aligned} q_i^{\mathrm{desc}} &= [q_i^{\mathrm{text}};q_i^{\mathrm{ctx}}],\\ q_i^{\mathrm{cap}} &= [C_i^{\mathrm{req}}, C_i^{\mathrm{des}}, q_i^{\mathrm{text}}],\\ q_i^{\mathrm{use}} &= [P_i^{+};q_i^{\mathrm{text}}],\\ q_i^{\mathrm{schema}} &= [I_i;O_i;\Gamma_i],\\ q_i^{\mathrm{sec}} &= [q_i^{\mathrm{ctx}};q_i^{\mathrm{text}}]. \tag*{(12)} \end{aligned}

This alignment allows different parts of a retrieval intent to match the corresponding information represented in each skill.

Hybrid Candidate Retrieval

SKILLGREP combines three complementary retrieval signals.

Lexical Retrieval. We first concatenate the searchable views of each skill into a document representation and compute a BM25 score:

slex(j)=BM25⁡(qi,Concat⁡(Vj)).(13)s_{\mathrm{lex}}(j) = \operatorname{BM25}(q_i, \operatorname{Concat}(\mathcal{V}_j)). \tag*{(13)}

This component captures exact matches such as method names, formula names, software libraries, tools, and domain-specific terminology.

Sparse Multi-View Retrieval. We additionally compute TF–IDF cosine similarity separately for each skill view:

sspv(j)=Cos⁡(TFIDF⁡(qi),TFIDF⁡(vj)).(14)s_{\mathrm{sp}}^{v}(j) = \operatorname{Cos}(\operatorname{TFIDF}(q_i), \operatorname{TFIDF}(v_j)). \tag*{(14)}

The sparse view score is obtained by aggregating normalized per-view scores:

ssp(j)=∑v∈Vjwvsspv(j)‾∑v∈Vjwv.(15)s_{\mathrm{sp}}(j) = \frac{\sum_{v \in\mathcal{V}_j} w_v \overline{s_{\mathrm{sp}}^{v}(j)}}{\sum_{v \in\mathcal{V}_j} w_v}. \tag*{(15)}

The current implementation assigns larger view weights to capability, usage, example, and schema views than to content-section views:

wv={1.4,v=capability,1.2,v∈{usage,examples},1.1,v=schema,0.7,v=content section,1.0,otherwise.(16)w_v = \begin{cases} 1.4, & v = \mathrm{capability},\\ 1.2, & v \in\{\mathrm{usage},\mathrm{examples}\},\\ 1.1, & v = \mathrm{schema},\\ 0.7, & v = \mathrm{content\ section},\\ 1.0, & \text{otherwise}. \end{cases} \tag*{(16)}

Dense Multi-View Retrieval. To retrieve semantically related skills whose wording differs from the agent query, we embed query groups and corresponding skill views with a bge-base-en-v1.5 encoder. For each semantic group gg, we compute

sdeg(j)=Cos⁡(Enc⁡(qig),Enc⁡(vjg)).(17)s_{\mathrm{de}}^{g}(j) = \operatorname{Cos}\left(\operatorname{Enc}(q_i^{g}), \operatorname{Enc}(v_j^{g})\right). \tag*{(17)}

The aggregated dense score is

sde(j)=0.25sdedesc(j)+0.35sdecap(j)+0.20sdeuse(j)+0.10sdeschema(j)+0.10sdesec(j).(18)s_{\mathrm{de}}(j) = 0.25s_{\mathrm{de}}^{\mathrm{desc}}(j) + 0.35s_{\mathrm{de}}^{\mathrm{cap}}(j) + 0.20s_{\mathrm{de}}^{\mathrm{use}}(j) + 0.10s_{\mathrm{de}}^{\mathrm{schema}}(j) + 0.10s_{\mathrm{de}}^{\mathrm{sec}}(j). \tag*{(18)}

In our implementation, dense retrieval uses a local Hugging Face encoder with L2-normalized mean-pooled representations. The concrete model used in experiments is reported in the experimental setup.

Ranking Fusion and Candidate Recall

Each retrieval path produces a ranked list of skills. We combine the BM25 ranking, sparse-view rankings, and dense-view rankings using reciprocal rank fusion:

srrf(j)=∑ℓ∈L160+rank⁡ℓ(j)(19)s_{\mathrm{rrf}}(j) = \sum_{\ell\in\mathcal{L}} \frac{1}{60 + \operatorname{rank}_{\ell}(j)} \tag*{(19)}

where L\mathcal{L} contains all available retrieval rankings. The highest-ranked skills under srrfs_{\mathrm{rrf}} form an initial candidate pool. In addition, skills that explicitly overlap with requested capabilities or specified input/output types are added to the pool. This design prevents structured requirements from being discarded solely because they are not highly ranked by the general retrieval signals.

Compatibility-Aware Scoring

For each recalled candidate, SKILLGREP computes a final ranking score that combines retrieval relevance with compatibility penalties:

S(j)=αlexsˉlex(j)+αspssp(j)+αdesde(j)+αrrfsˉrrf(j)+αcapscap(j)+αusesuse(j)+αinsin(j)+αoutsout(j)−αpen(pcontra(j)+pneg(j)+phard(j)).(20)\begin{aligned} S(j) ={}& \alpha_{\mathrm{lex}}\bar{s}_{\mathrm{lex}}(j) + \alpha_{\mathrm{sp}}s_{\mathrm{sp}}(j) + \alpha_{\mathrm{de}}s_{\mathrm{de}}(j) \\ &+ \alpha_{\mathrm{rrf}}\bar{s}_{\mathrm{rrf}}(j) + \alpha_{\mathrm{cap}}s_{\mathrm{cap}}(j) + \alpha_{\mathrm{use}}s_{\mathrm{use}}(j) \\ &+ \alpha_{\mathrm{in}}s_{\mathrm{in}}(j) + \alpha_{\mathrm{out}}s_{\mathrm{out}}(j) \\ &- \alpha_{\mathrm{pen}}\left(p_{\mathrm{contra}}(j) + p_{\mathrm{neg}}(j) + p_{\mathrm{hard}}(j)\right). \tag*{(20)} \end{aligned}

Here, sˉlex\bar{s}_{\mathrm{lex}} and sˉrrf\bar{s}_{\mathrm{rrf}} are normalized lexical and fusion scores; scaps_{\mathrm{cap}} and suses_{\mathrm{use}} capture explicit overlaps with capability annotations and usage information; and sins_{\mathrm{in}} and souts_{\mathrm{out}} capture input/output type overlap. The three penalty terms have distinct roles. The contraindication penalty pcontrap_{\mathrm{contra}} is triggered when the query matches conditions under which a skill should not be used. The negative-signal penalty pnegp_{\mathrm{neg}} is triggered when a skill matches exclusions expressed in the retrieval intent. The hard-mismatch penalty phardp_{\mathrm{hard}} accounts for explicit conflicts, including missing required capabilities, incompatible input types, and violated readability or execution constraints.

Under the default configuration in our implementation, the final score uses

αlex=0.2,αsp=0.1,αde=10.0,\alpha_{\mathrm{lex}} = 0.2,\quad\alpha_{\mathrm{sp}} = 0.1,\quad\alpha_{\mathrm{de}} = 10.0,
αrrf=0.2,αpen=1.0,(21)\alpha_{\mathrm{rrf}} = 0.2,\quad\alpha_{\mathrm{pen}} = 1.0, \tag*{(21)}

while the direct additive weights for capability, usage, and type overlaps are set to zero:

αcap=αuse=αin=αout=0.(22)\alpha_{\mathrm{cap}} = \alpha_{\mathrm{use}} = \alpha_{\mathrm{in}} = \alpha_{\mathrm{out}} = 0. \tag*{(22)}

These structured signals are nevertheless used for candidate inclusion, compatibility diagnosis, and hard-mismatch detection.

Selection and Abstention

Candidates whose final scores do not exceed a configurable minimum threshold are removed, and the remaining candidates are sorted by S(j)S(j). SKILLGREP returns the top-kk ranked skill cards, including their identifiers, descriptions, matched capability signals, available sections, and score breakdowns. The full content associated with a retrieved skill is incorporated in the subsequent skill-use stage.

The tool abstains when no valid skill can satisfy an explicit hard requirement. In particular, abstention is triggered when the repository is empty, when all skills violate required input or interaction constraints, when all returned candidates miss required capabilities, or when no candidate remains above the score threshold. This mechanism allows SKILLBROWSER to avoid injecting a retrieved skill when the repository does not contain a suitable capability.

Evaluation Benchmarks

We evaluate on six subsets of SRA-Bench ((Su et al., 2026)): TheoremQA, LogicBench, CHAMP, MedCalcBench, BigCodeBench, and ToolQA.

SRA-Bench formulates each evaluation instance as a user query paired with one or more annotated gold skills. Each skill is a reusable capability artifact, including task-solving instructions, mathematical procedures, logical inference patterns, clinical calculation rules, or software-library usage guidance. Importantly, agents do not retrieve from a small task-specific library: the benchmark mixes gold skills with web-collected distractor skills, yielding a shared retrieval corpus of 26,262 candidate skills. This setting evaluates whether an agent can identify the capability needed for solving a task under a realistically noisy skill library.

Table 5 summarizes the five original benchmark subsets, which contain 3,970 source instances and 622 source gold Skills. These source counts are not the valid-prediction denominators for every model or paired comparison. The additional ToolQA evaluation contains 100 valid trajectories per backbone (500 model–instance trajectories across five backbones); we do not add these repeated evaluations to the source-instance total. The selected subsets cover both knowledge-oriented skills, such as theorem application, logical inference, mathematical procedures, and medical calculators, and action-oriented skills, represented by software-library usage in BIGCODEBENCH.

BenchmarkCapability Type# Inst.# SkillsEvaluation
TheoremQATheorem application747320Single, rule-based
LogicBenchLogical reasoning patterns76019Single, rule-based
CHAMPMathematical concepts22389Multi, rule-based
MedCalcBenchMedical calculators1,10055Single, rule-based
BigCodeBenchSoftware libraries1,140139Multi, execution-based
Subtotal–3,970622–

Table 5. Source statistics for the five original SRA-Bench subsets; ToolQA evaluation counts are reported separately. The complete retrieval corpus additionally contains web-collected distractor skills, resulting in 26,262 candidate skills in total.

TheoremQA

THEOREMqa evaluates the retrieval and application of reusable mathematical and scientific principles. Its questions span domains such as combinatorics, calculus, linear algebra, physics, probability, economics, and graph theory. Each instance is paired with a single gold skill describing the theorem, formula, or canonical procedure needed to solve the question. For example, an instance asking for the number of ways to divide a set of eight elements into five non-empty ordered subsets is paired with the skill Lah Numbers. This subset therefore measures whether the agent can retrieve an appropriate abstract principle rather than relying only on surface-level lexical overlap.

LogicBench

LOGICBENCH evaluates retrieval for deductive reasoning tasks. Each instance contains a collection of premises and several candidate conclusions, and the model must identify which conclusion logically follows from the premises. The associated skills represent reusable logical reasoning patterns rather than domain-specific facts. Since the benchmark uses single-skill annotations and rule-based answer checking, it provides a controlled setting for testing whether retrieved reasoning procedures can support symbolic inference.

CHAMP

CHAMP contains mathematical problem-solving instances that require applying one or more mathematical concepts or procedures. Compared with THEOREMQA, which is annotated with a single theorem-oriented skill, CHAMP is configured as a multi-skill benchmark in SRA-Bench. Its problems include combinatorial counting and other structured mathematical reasoning tasks. Consequently, this subset evaluates whether a retrieval method can recover multiple complementary skills when solving a single query requires composing several procedures.

MedCalcBench

MEDCALCBENCH evaluates retrieval of clinical calculation procedures. Each query describes patient attributes such as age, sex, laboratory measurements, or body weight, and asks for the result of a named or implied medical calculator. For example, a released instance requests estimated creatinine clearance for a 68-year-old female patient using the Cockcroft–Gault equation. The benchmark is especially relevant for skill retrieval because correct task execution depends on identifying the appropriate calculator, grounding its required variables, and applying the formula consistently. We use this benchmark only as a procedural calculation task and do not interpret model outputs as medical advice.

BigCodeBench

BIGCODEBENCH evaluates retrieval of software-library usage skills. Unlike the other selected subsets, its evaluation is execution-based: a generated solution is checked by running the associated tests rather than by comparing a normalized textual answer. SRA-Bench models this subset as multi-skill retrieval, reflecting the fact that a programming task may require combining several API or library capabilities. This benchmark therefore tests whether retrieved skills can support executable task completion, complementing the rule-based reasoning benchmarks above.

ToolQA

ToolQA adds multi-step tool interaction to the evaluation. A capability-oriented query can identify an intermediate tool protocol not well represented by the initial user request. We evaluate 100 valid trajectories per model and report accuracy, gold-Skill recall, search frequency, LLM calls, and resource use in Appendices § 11 and § 12.

Example Instances

Table 6 presents representative instances from the five SRA-Bench subsets used in our evaluation. The examples illustrate the diversity of capabilities covered by the benchmark: mathematical theorem application, logical reasoning, combinatorial problem solving, clinical calculation, and software-library usage. While THEOREMQA, LOGICBENCH, and MEDCALCBENCH associate each query with a single target skill, BIGCODEBENCH may require multiple complementary skills, as illustrated by its example involving both random and itertools.

BenchmarkQuery ExampleGold Skill Name
TheoremQAHow many ways are there to divide a set of 8 elements into 5 non-empty ordered subsets?Lah Numbers
LogicBenchIf an individual decides to take a temporary break from their professional responsibilities, it can contribute to their overall sense of rejuvenation. however, if they choose to burden themselves with additional tasks, they may find themselves feeling overwhelmed. in this scenario, we are aware that at least one of the following statements holds true: (1) mike takes a break from work, or (2) he do not experience overwhelming feelings. it is important to note that we lack knowledge regarding which one, or both, of these statements are accurate. In light of the context provided, what conclusion can be considered the most appropriate? choice_1: Luke takes a break from work and feels refreshed. choice_2: Mike takes on more tasks and feels overwhelmed. choice_3: Mike takes a break from work and feels overwhelmed. choice_4: he will feel refreshed or he doesn’t take on more tasksBidirectional Dilemma
CHAMPLet a string consist of digit 1, 2, 3. How many such strings of length 6 have adjacent digit differing by less than or equal to 1?Rule of Sum (Addition Principle)
BigCodeBenchCalculates the average of the sums of absolute differences between each pair of consecutive numbers for all permutations of a given list. Each permutation is shuffled before calculating the differences. Args: – numbers (list): A list of numbers. Default is numbers from 1 to 10. The function should output with: float: The average of the sums of absolute differences for each shuffled permutation of the list. You should write self-contained code starting with: import itertools from random import shuffle def task_func(numbers=list(range(1, 3))):random – Core API and Common Patterns; itertools – Iterator Building Blocks
BenchmarkQuery ExampleGold Skill Name

Table 6. Representative instances and their annotated gold skills from the five SRA-Bench subsets used in our evaluation. Complete queries are retained without truncation.

Full Results of Selective Skill Exposure Analysis

We provide the complete model–benchmark level results for the Selective Skill Exposure analysis. For each model–benchmark pair, we construct two subsets according to the outcomes under the no-Skill and gold-Skill reference conditions. An instance is skill-beneficial if the model answers incorrectly without external Skills but correctly when provided with the annotated gold Skill. An instance is skill-unnecessary if the model answers correctly under both conditions. This partition is constructed separately for each model–benchmark pair because the utility of external procedural support depends on the backbone model’s native capability.

We compare Meta-Skill, which denotes Meta-Skill-managed Skill access, with SkillGrep, which statically retrieves Skills through the same hybrid retrieval backend. On skill-beneficial instances, we report Beneficial Exposure Rate (BER), i.e., the percentage of instances on which retrieved Skill contents are exposed, together with downstream accuracy. On skill-unnecessary instances, we report Unnecessary Exposure Rate (UER), where lower values indicate less unnecessary procedural exposure.

Analysis. Table 7 and Table 8 provide a fine-grained view of how Meta-Skill-managed access affects Skill exposure. On skill-unnecessary instances, the advantage is highly consistent: Meta-Skill-managed access lowers unnecessary exposure relative to static SkillGrep retrieval in 19 of 20 model–benchmark pairs (with one tie), and improves downstream accuracy in 18 out of 20 pairs. Micro-aggregated across all settings, it reduces UER from 100.0% to 70.9% while improving accuracy from 93.2% to 97.9%. These results support the central motivation of Selective Skill Exposure: blindly injecting retrieved procedural contents can disrupt tasks already solvable without external assistance.

ModelBenchmark#Ben.BER ↑\uparrowAccuracy ↑\uparrow
Qwen3-8BCHAMP5959.3100.067.878.0
Qwen3-8BLOGICBENCH14477.8100.053.550.0
Qwen3-8BMEDCALCBENCH44464.0100.060.464.2
Qwen3-8BTHEOREMQA212100.0100.090.181.6
Qwen3.6-PlusCHAMP1526.7100.033.353.3
Qwen3.6-PlusLOGICBENCH12359.3100.052.864.2
Qwen3.6-PlusMEDCALCBENCH15097.3100.094.788.7
Qwen3.6-PlusTHEOREMQA4897.9100.091.783.3
GLM-5.1CHAMP3243.8100.065.678.1
GLM-5.1LOGICBENCH19563.6100.070.869.7
GLM-5.1MEDCALCBENCH245100.0100.097.682.4
GLM-5.1THEOREMQA84100.0100.090.578.6
GPT-5.4-miniCHAMP248.3100.062.570.8
GPT-5.4-miniLOGICBENCH704.3100.011.464.3
GPT-5.4-miniMEDCALCBENCH2254.5100.081.877.3
GPT-5.4-miniTHEOREMQA2993.1100.089.789.7
Gemini-3.1-Flash-LiteCHAMP120.0100.00.083.3
Gemini-3.1-Flash-LiteLOGICBENCH714.2100.02.866.2
Gemini-3.1-Flash-LiteMEDCALCBENCH37100.0100.081.181.1
Gemini-3.1-Flash-LiteTHEOREMQA2138.1100.023.885.7

Table 7. Full results on skill-beneficial instances. These instances are answered incorrectly without external Skills but correctly when the annotated gold Skill is provided. BER denotes Beneficial Exposure Rate, i.e., the percentage of instances on which retrieved Skill contents are exposed.

ModelBenchmark#Unn.UER ↓\downarrowAccuracy ↑\uparrow
Qwen3-8BCHAMP9036.7100.094.491.1
Qwen3-8BLOGICBENCH51772.9100.092.883.0
Qwen3-8BMEDCALCBENCH38145.4100.097.686.9
Qwen3-8BTHEOREMQA22899.1100.096.986.0
Qwen3.6-PlusCHAMP17331.2100.098.897.7
Qwen3.6-PlusLOGICBENCH56552.0100.098.689.4
Qwen3.6-PlusMEDCALCBENCH85990.6100.099.397.8
Qwen3.6-PlusTHEOREMQA57696.5100.099.398.6
GLM-5.1CHAMP14761.2100.091.294.6
GLM-5.1LOGICBENCH48768.4100.097.591.2
GLM-5.1MEDCALCBENCH71499.4100.098.995.8
GLM-5.1THEOREMQA50499.4100.0100.098.0
GPT-5.4-miniCHAMP14613.7100.099.395.9
GPT-5.4-miniLOGICBENCH1865.9100.097.888.7
GPT-5.4-miniMEDCALCBENCH22656.6100.099.194.2
GPT-5.4-miniTHEOREMQA20590.2100.099.095.6
Gemini-3.1-Flash-LiteCHAMP14710.2100.097.391.8
Gemini-3.1-Flash-LiteLOGICBENCH1927.3100.097.989.6
Gemini-3.1-Flash-LiteMEDCALCBENCH205100.0100.094.196.1
Gemini-3.1-Flash-LiteTHEOREMQA22844.3100.0100.096.1

Table 8. Full results on skill-unnecessary instances. These instances are answered correctly both without external Skills and with the annotated gold Skill. UER denotes Unnecessary Exposure Rate, i.e., the percentage of instances on which retrieved Skill contents are exposed although they are not necessary for correctness under the evaluated model.

On skill-beneficial instances, Meta-Skill-managed access exhibits a more task- and model-dependent pattern. It achieves strong gains on several MEDCALCBENCH and THEOREMQA settings, including improvements of 15.2 points on GLM-5.1/MEDCALCBENCH and 11.9 points on GLM-5.1/THEOREMQA. These results indicate that capability-oriented access can improve the utility of exposed Skills when the agent successfully articulates its need. However, substantial drops on GPT-5.4-mini and Gemini-3.1-Flash-Lite for LOGICBENCH and CHAMP show that some agents do not reliably invoke Skill access when external support would be beneficial. Overall, Meta-Skill management provides a robust mechanism for avoiding unnecessary Skill exposure, while improving the recognition of beneficial Skill use remains an important direction for future work.

Static Retrieval and Retriever Ablations

Full-corpus static comparison. Table 9 compares retrieval from the dataset task description over the same 26,262-Skill repository. We report GoldHit@5, GoldMRR@5, Recall@1/5, and nDCG@1/5 using the benchmark evaluation. SkillGrep leads all reported metrics, supporting its use as a strong static baseline for the exposure comparison.

RetrieverGoldHit@5GoldMRR@5Recall@1Recall@5nDCG@1nDCG@5
SKILLGREP0.620.500.400.590.430.51
SR-Agent BGE Retriever0.470.370.310.450.310.39
SR-Agent TF-IDF0.390.290.220.370.230.30
SR-Agent BM250.490.360.280.460.300.38
SR-Agent Contriever0.410.310.240.390.240.32

Table 9. Static retrieval over the full Skill corpus using original task descriptions as queries. Values are proportions, reported at the reported precision; bold marks the best result.

Leave-one-component-out ablation. Table 10 removes individual SkillGrep components for offline gold-Skill retrieval at the same k=5k = 5. Keeping the ranking cutoff fixed avoids comparing thresholded single-channel scores that require separate calibration. Removing dense retrieval or capability/type signals causes the largest GoldHit@5 drops; removing sparse views and the RRF score also reduces retrieval quality. The penalty has little measurable effect. This experiment evaluates retrieval, not downstream end-task accuracy.

VariantGoldHit@5GoldMRR@5Recall@1Recall@5nDCG@1nDCG@5
Full SKILLGREP0.6230.5000.4020.5900.4290.511
No Penalty0.6230.5000.4010.5900.4290.511
No RRF Score0.5780.4710.3810.5440.4080.477
No Sparse View0.5480.4460.3590.5140.3830.452
No Dense0.4630.4220.3640.4360.3920.413
No Capability/Type Signals0.4620.4310.3790.4360.4070.420

Table 10. Leave-one-component-out SkillGrep ablation. All values are proportions; bold marks the best results, including ties at the reported precision.

Capability/type signals participate in candidate inclusion and compatibility checks even though their direct additive score weights are zero in the default configuration (Appendix § 7). Thus, their ablation is not equivalent to setting those already-zero coefficients to zero. The “No RRF Score” variant is reported separately from the broader use of rankings for candidate recall.

ToolQA Retrieval and Interaction

Table 11 reports ToolQA retrieval behavior. Search is the fraction of trajectories invoking retrieval; Recall@5 is evaluated across all trajectories, and R@5/Search is the conditional rate among searching trajectories. Static methods always retrieve but obtain zero gold-Skill recall. SkillBrowser’s capability-oriented query yields conditional recall between 0.54 and 1.00 in the reported runs, with one retrieval call per searching trajectory. This supports alignment with intermediate tool-use needs without demonstrating iterative retrieval refinement.

ModelMethodAccuracyRecall@5SearchR@5/Search
Qwen3-8BStatic BM250.170.001.000.00
Static SKILLGREP0.170.001.000.00
SKILLBROWSER0.440.500.930.54
Gold Exposure0.51---
Qwen3.6-PlusStatic BM250.320.001.000.00
Static SKILLGREP0.270.001.000.00
SKILLBROWSER0.570.660.900.73
Gold Exposure0.76---
GLM-5.1Static BM250.370.001.000.00
Static SKILLGREP0.390.001.000.00
SKILLBROWSER0.510.340.341.00
Gold Exposure0.73---
GPT-5.4-miniStatic BM250.330.001.000.00
Static SKILLGREP0.320.001.000.00
SKILLBROWSER0.430.400.660.61
Gold Exposure0.71---
Gemini-3.1-Flash-LiteStatic BM250.170.001.000.00
Static SKILLGREP0.180.001.000.00
SKILLBROWSER0.610.881.000.88
Gold Exposure0.70---

Table 11. ToolQA accuracy and retrieval behavior (proportions), with 100 valid trajectories per model. Dashes indicate that search metrics do not apply to direct gold exposure.

For GLM-5.1, conditional recall is 1.00, but only 34% of trajectories search; high retrieval quality when invoked therefore coexists with missed access opportunities. All models remain below Gold Exposure in ToolQA accuracy. That gap is consistent with under-invocation, retrieval misses, and downstream execution failures, but these aggregate metrics do not identify a causal breakdown of the errors.

Resource Use and Latency

Retrieval calls. The five ToolQA runs contain 500 valid model–instance trajectories in total. They contain 383 SkillGrep calls (76.6% search rate, 0.766 calls per trajectory). Each searching trajectory makes one call and loads five candidate Skills, averaging 3.83 loaded Skills per trajectory. Of these calls, 278 retrieve a gold Skill (72.6%). The conditional aggregate is computed from counts, rather than averaging the five model-specific conditional rates.

LLM calls. Table 12 counts all LLM calls along the tool-interaction trajectory. SkillBrowser requires more calls than LLM Selection for four backbones and fewer for GLM-5.1. Its cost depends on both retrieval invocation and subsequent tool use; one SkillGrep call does not imply only one additional LLM call.

ModelSkillBrowserGold ExposureLLM Selection
Qwen3-8B8.664.305.30
Qwen3.6-Plus8.606.806.90
GLM-5.15.353.306.70
GPT-5.4-mini5.963.305.50
Gemini-3.1-Flash-Lite5.402.204.80

Table 12. Average total LLM calls per ToolQA instance.

Tokens and latency. Table 13 and Table 14 report average complete-trajectory input/output token counts and latency for GLM-5.1. Token counts include the trajectory’s repeated model interactions. rather than only the final answer. Combined token use is lower than LLM Selection on TheoremQA, MedCalcBench, and BigCodeBench, and higher on LogicBench, CHAMP, and ToolQA. Latency is higher on all six benchmarks. SkillBrowser’s online path includes query generation, retrieval, and Skill loading; Gold Exposure directly loads the annotated Skill, whereas LLM Selection starts from a precomputed BM25 top-50 set and excludes BM25 retrieval from its reported latency. These measurements characterize the evaluated configurations rather than equal-stage online latency. Input/output tokens provide a pricing-independent resource proxy, but not a universal monetary-cost estimate.

BenchmarkSkillBrowserGold ExposureLLM Selection
TheoremQA3014.1 / 947.71095.6 / 419.44035.1 / 411.9
LogicBench6014.4 / 1714.31392.1 / 527.34661.2 / 563.5
CHAMP3372.4 / 3850.11857.9 / 693.76319.6 / 879.3
MedCalcBench3395.4 / 797.61489.8 / 278.66120.9 / 293.6
ToolQA44569.1 / 798.516279.7 / 214.140386.3 / 982.5
BigCodeBench1627.2 / 627.74827.5 / 272.44492.0 / 301.9

Table 13. Average GLM-5.1 input / output tokens per instance over the complete trajectory.

BenchmarkSkillBrowserGold ExposureLLM Selection
TheoremQA23.3848.60110.055
LogicBench42.35614.20314.582
CHAMP63.43510.35716.785
MedCalcBench31.0639.88111.148
ToolQA36.93718.50033.139
BigCodeBench19.0505.6497.427

Table 14. Average GLM-5.1 latency in seconds per instance. LLM Selection excludes precomputed BM25 retrieval; SkillBrowser includes online retrieval and Skill loading.

Correctness Transitions Relative to Gold Exposure

To examine why SkillBrowser can exceed Gold Exposure in some settings, we compare per-instance correctness across six datasets and five models. Table 15 reports macro-averages across the 30 settings. The four transition proportions sum to 99.9% because of rounding. These equal-setting macro-averages differ from the valid-pair pooled statistics in Appendix H; in particular, 5.0%−9.9%5.0\% - 9.9\% is not the pooled accuracy difference.

Gold ExposureSkillBrowserShare (%)
IncorrectCorrect5.0
CorrectCorrect72.1
CorrectIncorrect9.9
IncorrectIncorrect12.9

Table 15. Correctness transitions, macro-averaged across 30 model–dataset settings.

Among Gold-incorrect/SkillBrowser-correct instances, the reported search and gold-exposure rates are 60.1% and 51.6%, respectively. For the reverse transition they are 22.9% and 14.8%. Improvements therefore often involve retrieval, rather than simply avoiding Skills, while losses more often co-occur with failure to search or expose a gold Skill. These are descriptive associations: they do not establish whether any particular search, retrieved Skill, or skipped exposure caused the correctness transition.

Paired Statistical Comparisons

For each comparator, paired analysis retains the intersection of valid predictions. Let bb count instances correct only for SkillBrowser and cc count instances correct only for the comparator. A two-sided exact McNemar test uses the binomial null b∣(b+c)∼Binomial⁡(b+c,1/2)b \mid(b+c) \sim\operatorname{Binomial}(b+c, 1/2). The discordant counts yield the pp-values in Table 16. Aggregate results favor SkillBrowser over both deployable baselines but favor Gold Exposure over SkillBrowser. Different valid intersections explain why SkillBrowser’s pooled accuracy differs between comparator rows.

ComparatorSB acc.Ref. acc.NNbbccpp
Static SkillGrep78.5974.6411,7361,1106471.46×10−281.46 \times10^{-28}
LLM Selection75.9372.82–6464404.41×10−104.41 \times10^{-10}
Gold Exposure78.5980.52–6929201.49×10−81.49 \times10^{-8}

Table 16. Pooled valid-pair accuracy (%) and two-sided exact McNemar tests. b/cb/c count exclusive SkillBrowser/comparator wins. Dashes denote paired sample sizes unavailable in the aggregate statistics; they must not be assumed equal across comparators.

The pooled analysis treats model–instance pairs as observations. Repeated tasks across backbones may violate independence, so the nominal pooled pp-values should not be interpreted as a hierarchical or cluster-adjusted analysis. Nor do they establish significance for every model–dataset setting. Per-setting sample counts and correctness outcomes are needed for 95% Wilson accuracy intervals and stratified tests; the reported rounded accuracies alone do not determine those intervals.

References

  1. [1]Norbert Braunschweiler, Rama Doddipatla, and Tudor-catalin Zorila. 2025. ToolReAGt: Tool retrieval for LLM-based complex task solution via retrieval augmented generation. In Proceedings of the 3rd Workshop on Towards Knowledgeable Foundation Models (KnowFM), pages 75–83, Vienna, Austria. Association for Computational Linguistics.
  2. [2]Yuxuan Cai, Wei Li, Jie Zhou, Qin Chen, Xin Li, Bo Zhang, and Liang He. 2026. Ask only when needed: Proactive retrieval from memory and skills for experience-driven lifelong agents. Preprint, arXiv:2604.20572.arxiv.org/abs/2604.20572
  3. [3]Chishui Chen, Jiaye Lin, Te Sun, Yi Yang, Junxi Wang, Cong Qin, Yangen Hu, Lu Pan, and Ke Zeng. 2026. Skill or skip? learning selective skill invocation in agentic tasks via dual-granularity preference learning. Preprint, arXiv:2606.00510.arxiv.org/abs/2606.00510
  4. [4]Hongcheol Cho, Ryangk yung Kang, and Young eun Kim. 2026. Skillret: A large-scale benchmark for skill retrieval in llm agents.arxiv.org/abs/2605.05726
  5. [5]Xiang Fei, Xiawu Zheng, and Hao Feng. 2025. Mcp-zero: Active tool discovery for autonomous llm agents. Preprint, arXiv:2506.01056.arxiv.org/abs/2506.01056
  6. [6]Shuang Guo, Xiaobo Sui, Fei Jiang, Ruixin Li, Manxiang Li, Rong Li, and Ziyang Ou. 2026. Towards strategy-level rsi for skill-augmented agents: Learning when to reuse skills from execution feedback. Preprint, arXiv:2609.26863.arxiv.org/abs/2609.26863
  7. [7]Tingxu Han, Yi Zhang, Wei Song, Chunrong Fang, Zhenyu Chen, Youcheng Sun, and Lijie Hu. 2026. Swe-skills-bench: Do agent skills actually help in real-world software engineering? Preprint, arXiv:2603.15401.arxiv.org/abs/2603.15401
  8. [8]Yanna Jiang, Delong Li, Haiyu Deng, Baihe Ma, Xu Wang, Qin Wang, and Guangsheng Wu. 2026. Sok: Agentic skills – beyond tool use in llm agents. Preprint, arXiv:2602.20867.arxiv.org/abs/2602.20867

Paper details

vlnc:W_fy4sbckk
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 1

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents