SkillReducer Framework

• SkillReducer Framework is a systematic approach for debloating LLM agent skills by compressing routing descriptions and restructuring bodies to significantly reduce token usage.
• It employs a two-stage, training-free pipeline that leverages adversarial delta debugging and taxonomy-driven classification to isolate and retain only actionable content.
• Empirical results demonstrate up to 43.2% overall token reduction and improved agent performance, validating the framework’s efficiency and cost-saving potential.

LLM–based agents rely on skills: pre-packaged instruction sets extending agent capabilities by bundling a routing description, a main body, and optional reference files. Each token of skill content injected into the agent’s context window incurs monetary cost ($0.03–$0.15 per 10,000 tokens per invocation) and attention dilution, potentially distracting the model from core tasks. Systemic inefficiencies—skill bloat—are widespread. Empirical analysis of 55,315 publicly available skills reveals that 26.4% lack routing descriptions or have under-informed ones, over 60% of body content is non-actionable, and reference files can inject millions of rarely relevant tokens per invocation. The SkillReducer framework addresses these inefficiencies via a two-stage, training-free optimization pipeline built to reduce token costs while maintaining or even improving agent functionality (Gao et al., 31 Mar 2026).

1. Problem Formalization and Motivation

A skill is formalized as a tuple $s = (s.d, s.b, s.R)$: routing description $s.d$, body $s.b$, and reference set $s.R = \{r_1, ..., r_m\}$. The total invocation cost is

$$\mathrm{Cost}(s) = |s.d| + |s.b| + \sum_{r\in s.R} |r|$$

where each term is measured in tokens. Unoptimized skills exhibit three main forms of bloat:

• Omitted, missing, or verbose routing descriptions (26.4% of skills)
• Excessive non-actionable content in bodies (background, examples, boilerplate: over 60% of body content)
• Massive and rarely relevant reference files (can exceed tens of thousands of tokens per invocation)

These inefficiencies prompt the need for debloating skills for both economic and functional reasons, as token bloat increases costs and can dilute attention over irrelevant context, impacting agent performance.

2. Two-Stage SkillReducer Framework

SkillReducer operates in two principal optimization stages:

Stage 1: Routing Layer Optimization

The framework compresses each skill’s routing description using adversarial delta debugging. The routing description is split into semantic clauses; the system seeks a 1-minimal subset that is sufficient for a routing oracle $\mathcal{O}$ (real or simulated) to correctly select the skill. If the description is too short (≤40 tokens) or missing, an LLM is used to extract primary capability, trigger conditions, and unique identifiers for description generation. The ddmin procedure is applied for minimality, and retained clauses are paraphrased down. Real environment agent validation ensures the compressed or synthesized routing description preserves functional routing equivalence.

Stage 2: Skill Body Restructuring

The main body is split at the paragraph level and classified by an LLM classifier (DeepSeek-V3, $T=0$), producing categories: core_rule (actionable instructions), example (snippets), background (explanations), template (boilerplate), and redundant (duplicate). Only actionable core_rules remain in the new compact core $b^*$; other components are separated as on-demand modules or dropped if redundant. This taxonomy-driven progressive disclosure reduces attention dilution and context overhead by loading supplementary content only as needed. Reference files are deduplicated, summarized, and pruned for overlap with the core.

The restructuring is validated in two phases: (1) Gate 1 faithfulness checks ensure all operational concepts are preserved across the compact core and modules; (2) Gate 2 task evaluation tests functional retention. If failures are detected, a feedback loop promotes missing content back into the core, iterating up to two times.

3. Methodological Details

The implementation relies on several LLMs at different stages:

• DeepSeek-V3: description segmentation, body classification, compression
• DeepSeek-R1: simulated routing oracle
• Qwen3.5: task generation, scoring (at $T=0$)
• Claude Code CLI: real environment routing validation

Taxonomy creation involved 15,107 paragraphs from a stratified sample of 90 skills, verified via LLM classification and GMM clustering ($s = (s.d, s.b, s.R)$0, silhouette 0.393) to empirically support the class taxonomy. Missing descriptions are LLM-generated and validated using the routing oracle with sampled real-environment checks.

Evaluation is conducted on 600 diverse skills (SkillHub official, community, wild) plus the SkillsBench suite (87 tasks over 229 skills, pytest verifiers). Metrics include compression ratios, pass rates, improvement rates, retention, bootstrap 95% CIs, Wilcoxon signed-rank, and effect size analysis.

4. Experimental Results and Empirical Insights

Token Reduction:

• Mean routing description reduced by 48.0% (95% CI [45.2, 50.8])
• Mean body reduction by 39.0% (95% CI [36.2, 41.8]), saving ≈1,000 tokens per skill
• On SkillsBench: 75.0% body compression
• End-to-end, expected body tokens drop to 0.568× original (with core ratio 0.383 and reference-loading rate 0.30), for overall invocation cost reduction of up to 43.2%

Functional Quality:

• 100% routing preservation across 536 non-obsolete skills
• In 600-skill evaluation: Condition A (original) score 0.722; C (compressed) 0.742; D (no skill) 0.684
• Pass rate (C ≥ A): 86.0% (95% CI [83.1, 88.7])
• Compressed skills outperform originals on average (+2.8%)
• Improvement: C > A in 25.3% of skills, C < A in only 14.0% (p=0.002, Cohen’s d=0.107)
• On baselines at equivalent token budgets (50 skills): SkillReducer retention 0.949 vs LLMLingua 0.820, LLM direct 0.918, truncation 0.845, random removal 0.750

Component Analysis:

• Taxonomy-driven classification critical: dropping it yields 0.919 retention (–6.8pp)
• Reference deduplication (C3) alone yields 1.000 retention (+0.5% over A)
• Feedback loop recovers 81.6% of initial compression failures within two iterations
• Retention remains stable (0.910–0.956) across compression strata (<20% to >80%)

Generalization:

• Cross-model (30 skills × 5 tasks): mean retention 0.965 across five major LLM families (GLM-5, DeepSeek-V3, Qwen3-max, GPT-OSS-120B, Qwen2.5-7B)
• Cross-compressor evaluation: re-compression with Qwen3-max/Qwen2.5-7B gives 0.885–0.897 retention, indicating pipeline structure is more impactful than compressor strength
• Cross-framework (OpenCode v1.2.27): retention 0.944
• Skill obsolescence: 10.7% of skills failed to trigger in original, D scored 98.9% on SkillsBench, suggesting need for lifecycle management

5. Impact, Limitations, and Future Directions

SkillReducer demonstrates that structured, training-free debloating of LLM agent skills yields substantial token savings—48% on routing descriptions, 39% on bodies—while preserving or enhancing performance (pass rate 86.0%, +2.8% functional quality). The pipeline adapts adversarial delta debugging and program slicing to natural-language artifacts, with principled faithfulness checks and a self-correcting feedback loop.

Key insights include the “less-is-more” effect, where removing non-essential content not only saves cost but reduces attention dilution, improving agent accuracy. Retention and performance generalize across models and agent frameworks.

Limitations include reliance on the accuracy of taxonomy classification and the finite coverage of skill task evaluation. Examples embedding implicit core rules can sometimes cause failures in progressive disclosure. Future work may extend to dynamic skill lifecycle management, more granular content taxonomies, and integration with other agent platforms.

Broader implications underscore the value of context-aware prompt and artifact compression for maintaining cost-effective and distraction-free LLM agent ecosystems (Gao et al., 31 Mar 2026).