Skill retrieval 30 papers

Corpus2Skill turns a document corpus into something an agent walks instead of queries. An offline compile pass embeds every document, clusters them hierarchically with K-Means, and has an LLM write a summary at each level, producing a tree of SKILL.md and INDEX.md files plus a cross-branch entity index — the same filesystem format and progressive disclosure mechanism used for procedural agent skills , repurposed here to describe what a corpus contains rather than how to do a task. At serve time the agent is preloaded with only skill names and one-line descriptions, then drills from a top-level summary through progressively finer INDEX.md files down to a specific document, backing out of branches that turn out thin. Five baselines take the comparison on WixQA, an enterprise customer-support benchmark of 6,221 support articles and 200 expert-written queries with gold answers: BM25, dense embedding retrieval, hybrid retrieval, RAPTOR-style hierarchical retrieval, and an agentic RAG agent with search tools.

Graph-of-Skills (GoS) builds a typed skill graph offline over a local skill library, linking skills through four edge types: dependency, workflow, semantic, and alternative. Dependency edges come free — induced deterministically from I/O schema overlap between skills, no LLM involved — while the other three relation types are filled in by a sparse, top-k LLM validation pass rather than an exhaustive pairwise check. At query time, GoS blends semantic and lexical retrieval scores to seed the graph, then runs a reverse-aware Personalized PageRank diffusion so upstream prerequisites — a parser here, a format converter there — accumulate relevance even when they share no vocabulary with the query. A final rerank-and-hydrate step packs the top-scoring skills into a token-budgeted bundle.

Agent skills are supposed to make agents cheaper and more capable, not the reverse. An audit of 55,315 publicly available skills finds the opposite happening at scale. 26.4% carry no routing description at all, and another slice sit under 20 tokens — both break or blunt the mechanism an agent uses to pick the right skill before it even reads the body. Once a skill is selected, the body doesn't fare much better: only 38.5% of its content qualifies as actionable core instruction. The rest is background prose and examples the agent didn't need, plus templates it never used. Reference files make the problem worse — a 100-skill sample alone carries 1.67M tokens across 505 files, all of it inherited on a single invocation whether or not the task touches it. SkillReducer's answer isn't a blunt compressor but a two-stage pipeline. Stage 1 rewrites routing descriptions, and generates them where missing, using delta debugging against a simulated routing oracle plus real-agent validation. Stage 2 classifies body content into core rules, background, examples, templates, and redundant material, then applies progressive disclosure : everything but the core rules moves into modules loaded only on demand, gated by a faithfulness check and a feedback loop that restores content if cutting it hurts task performance.

EffiSkill treats recurring slow-to-fast code rewrites as reusable agent skills instead of one-off prompts. Stage I mines Operator Skills (concrete transformation mechanics) and Meta Skills (diagnosis, retrieval, and composition logic) from 900 Python and 900 C++ slow/fast program pairs, compiling a portable skill library. Stage II applies that library to unseen programs through an execution-free pipeline: diagnose the bottleneck, retrieve matching skills, compose a plan, generate candidates — no compiling or running the program during inference.

LLM agent skill catalogs are heading into the same problem search ran into decades ago: too many candidates to hand a model all at once. The standard fix is progressive disclosure — a router picks a skill from just its name and description, and only the winner's full implementation body ever enters the agent's context. Zheng et al. test whether that shortcut holds once a registry gets large and crowded with near-duplicates. They built an approximately 80,000-skill benchmark derived from SkillsBench, split into an Easy tier and a Hard tier salted with 780 LLM-generated distractor skills engineered to look right while doing the wrong thing. Then they ran the same skill routing test twice across both encoder-only retrieval and retrieve-and-rerank baselines — once with the skill body visible to the router, once with it hidden.

A nineteen-institution team spanning Zhejiang University, Alibaba, Tencent, Ant Group, and UCLA built SkillNet , infrastructure that creates, grades, and connects agent skills at scale instead of just hosting them. Skills get pulled from execution trajectories, GitHub repositories, PDFs and slide decks, and raw natural-language prompts through an LLM-driven pipeline, then run through deduplication (directory-structure and MD5 comparison) plus rule-based and model-based filtering before landing in one of ten functional categories. The distinguishing piece is a three-layer skill ontology : a taxonomy of categories and tags, a relation graph linking individual skills via similar_to, compose_with, belong_to, and depend_on edges, and a package library for modular deployment. Skills here aren't vetted one at a time and left to sit — they're wired into a queryable network.

CUA-Skill turns human computer-use know-how into 478 atomic, parameterized skills across 17 Windows applications — File Explorer, Excel, Word, Chrome, VS Code, PowerPoint, and more. Each skill pairs a natural-language intent with an argument pool and a parameterized execution graph , a directed graph whose nodes are control states and edges are base GUI actions gated by UI predicates. A separate composition graph encodes which skills can legally follow which, turning a flat skill list into a navigable map of higher-level tasks. Built on top, CUA-Skill Agent handles the runtime work: hybrid lexical-and-semantic skill retrieval (Qwen3-Embedding-0.6B, top-5 candidates) narrows the catalog to candidates, argument instantiation treats enumerable and open-ended inputs differently, and a memory log of past attempts drives failure recovery — falling back to raw primitive actions when nothing cataloged fits.

Multi-agent systems split a task across several specialized agents that talk to each other, and that coordination is expensive — every hand-off costs tokens and latency. Compile the same pipeline into a single agent backed by a library of skills , with each former agent's behavior turned into one skill the agent selects from, and the inter-agent messages disappear. That's the substitution tested here, across GSM8K, HotpotQA, and HumanEval, then pushed two ways: the skill library grows from a handful of entries to dozens, and separately gets seeded with near-duplicate competitor skills to see what actually breaks selection.

SkillFlow treats skill selection as a search problem, not a context-stuffing problem. Given a task, it runs dense retrieval over roughly 36,000 community-contributed SKILL.md files scraped from GitHub, pulling back about 1,000 candidates with a bi-encoder. Two rounds of cross-encoder reranking narrow that further: a shallow pass on truncated text cuts to around 100 candidates, then a deep pass on full content cuts to about 10, before an LLM makes the final call and keeps five skills or fewer. The pipeline is evaluated on two coding benchmarks: SkillsBench, where 87 tasks come paired with 229 known oracle-matched skills, and Terminal-Bench, 89 tasks with no matched-skill ground truth at all.

STEVE is an embodied agent for Minecraft built from three linked modules: a vision encoder (EfficientFormer) that tokenizes what the agent sees, a LLaMA-2-13B instruction core split into four roles (planner, critic, curriculum generator, describer), and a code-action module that never writes new code. Instead, it matches each planned step against a fixed library of 210 skill scripts spanning eight categories — collecting and crafting among them — via skill retrieval , using cosine similarity between the step description and each script's embedding. Training runs in two stages: offline supervised fine-tuning on the STEVE-21K dataset (600 first-person gameplay clips across six terrains, 20K Minecraft QA pairs), then online fine-tuning inside the MineDojo/Mineflayer simulator across 5,000 episodes, with GPT-4 standing in as the expert supervisor.