LLM agents increasingly rely on external skill libraries — modular natural-language instruction packages — to extend their capabilities beyond pre-trained knowledge. As these libraries scale from dozens to tens of thousands of skills, a fundamental tension emerges: agents need access to relevant procedural knowledge, but injecting all available information simultaneously degrades rather than improves performance. Full-library injection on tau2-bench collapses pass rate to 24.8% — worse than the 40.2% no-skill baseline [2605.29794]. This "more skills = worse" paradox drives the central question of this topic: how should agents decide what context to show, in what form, and at what moment?
The problem spans at least two disciplinary categories. From the agent perspective, it manifests as a context-window management challenge — routing, selection, compression, and injection must jointly minimize attention dilution while preserving operational completeness [2602.12430]. From the algorithm perspective, the multi-dimensional nature of skill quality (correctness vs. compliance vs. token cost) demands formal optimization frameworks that can navigate non-convex trade-off surfaces [2605.19330].
The progressive disclosure paradigm — originally articulated as a three-layer architecture (metadata → instructions → resources) for minimizing context window consumption [2602.12430] — has spawned a cluster of eight works in early 2026 that collectively map the full pipeline from routing through rendering. This topic synthesizes their converging and diverging conclusions about how to present the right information to agents at the right time.
| Category | Paper count | Representative work |
|---|---|---|
| agent | 7 | SkillReducer (2603.29919), SkillsInjector (2605.29794), SkillRouter (2603.22455), Agent Skills Architecture (2602.12430), SSL (2604.24026), Skill-as-Pseudocode (2605.27955), Skill Comprehension (2605.19362) |
| algorithm | 1 | MOCHA (2605.19330) |
The overwhelming concentration in the agent category reflects the practical engineering nature of this challenge — progressive disclosure is primarily a system design problem concerning how agent runtimes manage skill context. The algorithm contribution (MOCHA) addresses the upstream question of how to optimize skill content itself across multiple quality dimensions before disclosure decisions are made.
| Date | Entity | Contribution |
|---|---|---|
| 2025-02 | Agent Skills Architecture (2602.12430) | First systematic articulation of the three-layer progressive disclosure architecture; defines the skill-as-directory paradigm and Level 1/2/3 loading hierarchy [2602.12430] |
| 2025-03 | SkillRouter (2603.22455) | Demonstrates that skill body text is indispensable for routing accuracy — hiding body drops Hit@1 by 31–44pp in ~80K pools [2603.22455] |
| 2025-03 | SkillReducer (2603.29919) | Operationalizes progressive disclosure via taxonomy-driven body restructuring; achieves 48% description + 39% body compression with 2.8% quality improvement [2603.29919] |
| 2025-04 | SSL (2604.24026) | Introduces three-layer typed graph representation, showing structured evidence improves retrieval +0.080 MRR@50 while full documents cause dilution [2604.24026] |
| 2025-05 | MOCHA (2605.19330) | Formalizes skill optimization as multi-objective Pareto search, revealing that correctness gains inevitably trade against compliance constraints [2605.19330] |
| 2025-05 | Skill Comprehension (2605.19362) | Audits user-facing disclosure quality; only 2.3% of skills provide all four comprehension anchors [2605.19362] |
| 2025-05 | Skill-as-Pseudocode (2605.27955) | Replaces prose with typed pseudocode bundles; +74% relative win rate while reducing tokens 23% [2605.27955] |
| 2025-05 | SkillsInjector (2605.29794) | Reframes skill injection as per-task context construction with execution-grounded utility scoring and adaptive budgeting [2605.29794] |
The lineage reveals two distinct evolutionary paths diverging from the foundational architecture:
These paths converge at SkillReducer, which operationalizes both insights by restructuring content based on actionability classification.
SkillRouter demonstrates that the cross-encoder allocates 98.1% attention to body text at the final layer, and removing body drops accuracy 31–44pp [2603.22455]. Yet SkillReducer proves that 61.5% of body content is non-actionable (background, example, template, redundant) and removing it improves agent performance by 2.8% [2603.29919]. This apparent contradiction dissolves once the pipeline stages are separated: routing should consume full text for accurate matching, while execution should receive only compressed actionable content [2603.22455].
SkillReducer classifies examples as non-core content (12.9% of body) and moves them to on-demand reference modules [2603.29919]. But Skill Comprehension finds that examples are the rarest (19.0% coverage) yet most critical anchor for user verification — the sole skill with an example in the DNS/C2 subset required zero code inspection for first-check construction [2605.19362]. SkillReducer's 4.7% true regression rate traces precisely to "example-as-specification" failures — examples that implicitly define expected behavior becoming inaccessible after compression [2605.19362].
SkillReducer performs skill-centric, build-time compression independent of any specific task [2603.29919]. SkillsInjector performs task-centric, inference-time context construction that adapts the injected skill set and descriptions per task [2605.29794]. The approaches address different temporal scales but can conflict: SkillReducer's renderer-less compression may strip content that SkillsInjector's set-aware renderer would have exploited for disambiguation [2603.29919].
MOCHA reveals that optimizing skill correctness inevitably degrades body compliance (from 0.83 to 0.33) [2605.19330]. This algorithmic finding directly constrains agent architecture: if skills are optimized for correctness, downstream compression becomes necessary to restore compliance. The pipeline ordering emerges naturally — optimize content (MOCHA) → compress to compliance (SkillReducer) → route to appropriate tasks (SkillRouter/SkillsInjector) [2605.19330].
1. More information strictly hurts beyond a quality threshold.
All eight works converge on this principle through independent experiments:
2. Content classification quality — not compression ratio — determines success.
SkillReducer's ablation is definitive: removing taxonomy classification drops retention by 6.8pp (0.987 → 0.919), while the compression ratio is identical [2603.29919]. SSL's parallel finding — structured typed representation outperforms raw full text — confirms that structure-aware processing of skill content is the load-bearing insight across the cluster [2603.29919].
3. Per-task adaptive budgeting outperforms fixed allocation.
SkillsInjector's adaptive threshold admits variable-size skill sets per task (from zero to full candidate pool) [2605.29794]. Removing adaptive budget costs 4.9–10.9pp on tau2-bench [2605.29794]. The budget distribution exhibits a consistent three-part structure — tasks intrinsically differ in how much skill context they can exploit [2605.29794].
1. Whether examples are core or peripheral content.
SkillReducer classifies 12.9% of body content as examples and treats them as safely deferrable to on-demand loading [2603.29919]. Skill Comprehension demonstrates that examples are the single anchor enabling spec-only verification by users, present in only 19.0% of skills and critical when present [2605.19362]. The disagreement stems from different optimization targets: functional correctness (SkillReducer) vs. human comprehensibility (Skill Comprehension) [2605.19362].
2. Surface similarity vs. execution utility as the routing signal.
SkillRouter achieves 74.0% Hit@1 via embedding similarity over full skill text [2603.22455]. SkillsInjector surpasses it by +6.1pp on SkillsBench using execution-grounded utility $\Delta(t,s)$ derived from agent rollouts [2605.29794]. The insurance-keyword case study directly refutes similarity-sufficiency: a topically matched skill with $\Delta = -0.20$ would be ranked highly by SkillRouter but correctly rejected by SkillsInjector [2605.29794]. However, SkillRouter operates at 80K scale while SkillsInjector validates only at ≤82 skills — they address fundamentally different scale regimes.
3. Whether skill optimization should preserve or modify semantics.
SkillReducer's faithfulness constraint requires that all operational concepts be preserved somewhere in the output [2603.29919]. MOCHA explicitly changes skill semantics to improve correctness, accepting body compliance collapse from 0.83 to 0.33 [2605.19330]. One compresses without changing meaning; the other rewrites meaning to optimize outcomes [2605.19330].
Execution-grounded utility ($\Delta$ signals) produces the best selection quality [2605.29794], but computing it requires $N_{\text{skills}} \times M_{\text{tasks}} \times K_{\text{seeds}}$ agent rollouts — 20,500 rollouts for just 82 skills in one domain [2605.29794]. SkillRouter's pool reaches 80K skills [2603.22455]; at that scale, execution-grounded labels require ~20M rollouts. No current approach bridges this gap between "best signal" and "affordable signal" at production scale. Partial attempts — using embedding similarity as a cheap proxy, or computing $\Delta$ only for SkillRouter's top-20 recall set — remain unvalidated [2603.22455].
Required collaboration: agent systems (to define scalable rollout infrastructure) + algorithm research (to develop sample-efficient utility estimation or transfer learning for $\Delta$ across domains).
Estimated horizon: 2–3 years for practical solutions at 10K+ skill scale.
The entire progressive disclosure paradigm depends on correctly classifying what is "core" vs. "deferrable." SkillReducer's GMM clustering achieves only silhouette 0.393 — moderate separation with fuzzy boundaries [2603.29919]. The dominant failure mode is "example-as-specification" — examples that implicitly define expected behavior being incorrectly classified as non-core [2603.29919]. SSL's constrained vocabulary (7 scene types, 12 act types, 8 resource scopes) forces consistent classification but sacrifices expressiveness [2604.24026], and its normalizer achieves only 83% source-tracing accuracy [2604.24026].
This is not merely an engineering gap — it reflects a fundamental ambiguity in natural-language instructions where the same text can serve multiple functions simultaneously (an example both illustrates and specifies). No current approach offers a principled resolution.
Required collaboration: agent (classification engineering) + algorithm (formal characterization of function-ambiguous text).
Estimated horizon: Unknown — may require new theoretical frameworks for instruction semantics.
SkillReducer's cross-model retention ranges from 0.939 (Qwen2.5-7B) to 0.986 (GLM-5) [2603.29919]. MOCHA validates only on a single backbone (Claude Haiku 4.5) [2605.19330]. SkillsInjector's planner is supervision-bottlenecked and uses per-domain thresholds that don't transfer [2605.29794]. The field lacks any formal bound on how progressive disclosure decisions transfer across model families, sizes, or versions. As agent backbones evolve rapidly, compression/routing decisions optimized for one generation may degrade on the next.
Required collaboration: agent (multi-backbone evaluation protocols) + algorithm (formal transferability bounds).
Estimated horizon: 1–2 years for empirical characterization; 3–5 years for theoretical guarantees.
SkillReducer optimizes for agent functional correctness; Skill Comprehension reveals that user verification requires different disclosure priorities — particularly examples that agents may not need but humans require for first-check construction [2605.19362]. A progressive disclosure system must simultaneously serve two audiences (agent and human user) with potentially conflicting information needs. Only 2.3% of current skills satisfy all four comprehension anchors [2605.19362], and no existing system jointly optimizes for both machine execution quality and human understandability.
Required collaboration: agent + usable-security research (controlled user studies measuring comprehension impact of different disclosure strategies).
Estimated horizon: 2–3 years for initial frameworks; requires controlled user studies currently missing from the literature.
Overall maturity: Research-frontier, approaching early production for individual components.
Evidence for frontier status:
Evidence against production-readiness of the integrated pipeline:
Trend direction: Accelerating. Eight papers in four months (Feb–May 2026) addressing different pipeline stages, with clear convergence on core principles and identified integration opportunities. The shift from "more skills = better" to "precise disclosure = better" represents a maturing paradigm that is ready for systems integration work.
| Adjacent topic | Boundary | Potential evolution |
|---|---|---|
| Agent security/governance | Progressive disclosure intersects security at the trust-level ↔ loading-level mapping (T1 = Level 1 only, T3/T4 = Level 3 access) [2602.12430]. Comprehension audit adds a non-adversarial governance dimension [2605.19362]. | May merge if trust levels become the primary mechanism for disclosure decisions |
| Agent serving/scheduling | Progressive disclosure decisions have latency implications — SkillRouter achieves 496ms end-to-end [2603.22455], while SkillsInjector adds 8B model inference. Token budget management directly affects serving throughput. | May blur as real-time disclosure decisions become integrated into serving infrastructure |
| Retrieval-augmented generation | Skill injection is structurally similar to RAG (retrieve relevant context → inject into prompt), but skills modify agent capabilities rather than providing factual grounding. SSL's typed graph approach [2604.24026] bridges toward structured RAG. | Topics may partially merge as RAG systems adopt adaptive budgeting and progressive disclosure principles |
| Prompt optimization | MOCHA's multi-objective optimization of skill text [2605.19330] is effectively prompt optimization applied to skill artifacts. The boundary between "optimizing a skill" and "optimizing a prompt" is thin. | Likely to remain distinct — skills have lifecycle/governance concerns absent from ephemeral prompts |
| Entity | Categories | Role in topic | Key contribution |
|---|---|---|---|
| [2602.12430] | agent | Paradigm definition | Three-layer progressive disclosure architecture; skill-as-directory abstraction |
| [2603.29919] | agent | Compression methodology | Taxonomy-driven body restructuring; less-is-more effect quantification |
| [2605.29794] | agent | Dynamic context construction | Execution-grounded adaptive selection; set-aware rendering |
| [2603.22455] | agent | Routing at scale | Full-text retrieve-and-rerank; body-access necessity proof |
| [2605.19330] | algorithm | Multi-objective optimization | Chebyshev scalarization for correctness-compliance Pareto front |
| [2604.24026] | agent | Structured representation | Three-layer typed graph; evidence interface for retrieval and risk |
| [2605.27955] | agent | Execution interface | Typed pseudocode contracts; deterministic verification pipeline |
| [2605.19362] | agent | User comprehension | Four-anchor comprehension framework; disclosure quality measurement |
| [2603.29919] | agent | Pipeline integration | Build-time positioning; cross-paper lifecycle mapping |
| [2605.29794] | agent | Paradigm shift | Context construction vs. retrieval paradigm articulation |
| [2603.22455] | agent | Competitive analysis | SkillRouter as incremental improvement vs. paradigm changers |
| [2605.19330] | algorithm | Integration opportunities | MOCHA × SkillReducer optimization-compression pipeline |
| [2604.24026] | agent | Representation comparison | SSL vs SaP as evidence-interface vs execution-interface |
| [2605.27955] | agent | Methodology contrast | Compression (delete) vs restructuring (transform) approaches |
| [2605.19362] | agent | Governance gap | User comprehension as orthogonal quality dimension |