PaperlayerView exact revision on arXiv

Source-linked AI summary

A Comprehensive Survey on Agent Skills: Taxonomy, Techniques, and Applications

Yingli Zhou, Wang Shu, Yaodong Su, Wenchuan Du, Yixiang Fang, Xuemin Lin

arXiv:2605.07358v3cs.IR

TL;DR

As agents undertake increasingly complex tasks, systems need reusable procedural knowledge beyond raw tools and from-scratch reasoning. This survey defines agent skills, organizes research across their lifecycle, and reviews acquisition, retrieval, evolution, ecosystems, applications, and open challenges. It presents complementary acquisition routes and argues that robust skill ecosystems are likely to combine them while jointly managing retrieval, execution, and evolution.

  • Problem

    As skill repositories grow heterogeneous and agents face complex tasks, the central challenge shifts from whether skills exist to surfacing and activating the right skill at the right moment.

  • Method

    The survey defines skills as reusable procedural artifacts and organizes the literature around representation, acquisition, retrieval and selection, and evolution.

  • Results

    The survey concludes that human-, experience-, task-, and corpus-derived acquisition routes are complementary and that robust ecosystems are likely to combine them.

  • Takeaways & Limitations

    Skills should be treated as first-class operational building blocks that externalize, activate, and maintain procedural knowledge in agent systems.

Abstract

from arXiv · show

Large language model (LLM)-based agents that reason, plan, and act through tools, memory, and structured interaction are emerging as a promising paradigm for automating complex workflows. Recent systems such as OpenClaw and Claude Code exemplify a broader shift from passive response generation to action-oriented task execution. Yet as agents move toward open-ended, real-world deployment, relying on from-scratch reasoning and low-level tool calls for every task become increasingly inefficient, error-prone, and hard to maintain. This survey examines this challenge through the lens of \emph{agent skills}, which we define as reusable procedural artifacts that coordinate tools, memory, and runtime context under task-specific constraints. Under this view, agents and skills play complementary roles: agents handle high-level reasoning and planning, while skills form the operational layer that enables reliable, reusable, and composable execution. Skills are therefore central to the scalability, robustness, and maintainability of modern agent systems. We organize the literature around four stages of the agent skill lifecycle -- representation, acquisition, retrieval, and evolution -- and review representative methods, ecosystem resources, and application settings across each stage. We conclude by discussing open challenges in quality control, interoperability, safe updating, and long-term capability management. All related resources, including research papers, open-source data, and projects, are collected for the community in \textcolor{blue}{https://github.com/JayLZhou/Awesome-Agent-Skills}.

I. INTRODUCTION

LLM-based agents are emerging for complex-task automation, but low-level tool access and from-scratch procedural reasoning create a bottleneck as tasks become longer and more heterogeneous. This survey frames reusable agent skills as the operational layer between high-level planning and reliable execution, organizing research across a four-stage lifecycle and related ecosystems.

  • LLM-based agents perceive context, reason over goals, and execute actions through planning, tool use, memory retrieval, and structured interaction.
  • Tool access alone does not specify invocation timing, multi-tool coordination, failure handling, or output validation, leaving agents to infer procedures at runtime.This procedural gap produces brittleness, latency, and unreliability for long-horizon, heterogeneous tasks.
  • Agent skills are reusable procedural artifacts that coordinate tools, memory, and runtime context, while agents handle intent interpretation and goal decomposition.Skills translate abstract plans into robust low-level execution by externalizing procedural know-how.
  • The survey organizes fragmented research around skill representation, acquisition, retrieval, and evolution, while reviewing representative methods within each lifecycle stage.The literature spans acquisition from expertise, traces, tasks, and corpora; retrieval from heterogeneous libraries; runtime selection and composition; and post-deployment revision and governance.
  • The survey also covers ecosystem resources, application scenarios, open challenges, and future research directions for agent skills.Its stated challenges include quality control, safety, cost, interoperability, maintenance, and long-term capability governance.

B. Agent Knowledge and the Procedural Gap

Agent systems combine passive model knowledge with active runtime knowledge, but access to tools and resources does not specify how capabilities should be selected, sequenced, or validated. The survey frames agent skills as reusable procedural artifacts that bridge this gap and support storage, retrieval, orchestration, and revision.

  • Knowledge types: Passive knowledge provides general but static and often weakly specialized procedural priors, while active knowledge is obtained dynamically through runtime interaction.Active knowledge includes retrieved documents, tools, APIs, MCP servers, external skills, and observed outcomes.
  • Skills as the operational layer: Agent skills package procedural knowledge into reusable artifacts that specify when and how external capabilities should be applied.They can be stored, retrieved, revised, and governed across tasks rather than treating tool calls as isolated operations.
  • The procedural gap: Tool access exposes capabilities but does not specify when to use them, how to sequence them, or how to validate their outputs.This orchestration burden falls back on the LLM at inference time and becomes a source of brittleness as task complexity grows.
  • Skill formalization: A skill is modeled as S = (M, R, C), combining a root instruction document, auxiliary resources, and applicability conditions.M guides the agent, R contains references, templates, scripts, or domain artifacts, and C governs retrieval and application through metadata, descriptions, or embeddings.
  • Skill formalization: Skills differ from raw tools and MCP servers by encoding situated procedural knowledge such as triggers, sequencing, fallbacks, and pitfalls in bounded reusable artifacts.They may also be cognitive rather than tool-centric, including review checklists and analysis workflows.

E. The Ecosystem of Agent Skills

The survey presents agent skills as components of an ecosystem in which they are created, indexed, retrieved, executed, and later revised or retired. Skills are packaged around instruction documents, optional resources, and trigger conditions, with three resource configurations: text-based, code-based, and hybrid.

  • Ecosystem lifecycle: Agent skills move through an ecosystem lifecycle spanning creation, repository indexing, constrained retrieval, execution, validation, revision, and retirement.The stages are tightly coupled, so incomplete skills, weak retrieval signals, and stale dependencies can propagate errors.
  • Survey organization: The taxonomy organizes existing studies from the skill lifecycle perspective.The cited taxonomy is presented in Fig. 3, while the ecosystem includes representative platforms listed in Table I.
  • Skill packaging: Each skill consists of an instruction-based main document M, optional auxiliary resources R, and trigger conditions C.M is the primary human-readable representation, while R and C extend capabilities and govern applicability.
  • Resource configurations: The survey classifies skills by their auxiliary resources into text-based, code-based, and hybrid configurations.Text resources provide references, examples, templates, rubrics, or schemas without executable dependencies.

1) Text-backed skills:

Agent skills can be represented with textual, executable, or hybrid resources and applied as multi-step reusable procedures. Skill acquisition is organized by whether skills come from human expertise, experience, tasks, or external corpora.

  • Code-backed skills: Executable resources support repeatable subtasks and stronger operational determinism, but require ongoing versioning, testing, and dependency management.Examples include scripts, helper functions, notebooks, and wrappers.
  • Hybrid skills: Hybrid configurations combine textual and executable artifacts to preserve interpretability while supporting deterministic execution, at the cost of greater coordination burden.Consistency must be maintained across documents, code, and their bindings.
  • Procedural examples: Illustrative skills are reusable multi-step procedures whose steps may involve reasoning, tool invocation, or interaction with external resources.Examples include literature review and code repair workflows that query, extract, diagnose, patch, test, and revise.
  • Acquisition sources: Skill acquisition is grouped into human-derived, experience-derived, task-derived, and corpus-derived families according to the direct source of the skill.These sources include expert knowledge, past executions, current task requirements, and external documents, repositories, or interface traces.

A. Human-Derived Acquisition

Human-derived acquisition converts expert knowledge and professional experience into explicit, reusable procedures, offering semantic precision but limited scalability. Experience-derived acquisition instead processes prior executions through selection, abstraction, memory organization, and procedural packaging to create transferable skills.

  • Human-derived acquisition: Human-derived acquisition converts domain expertise into explicit procedural artifacts that agents can inspect, reuse, and adapt.Experts may encode scope, supporting materials, usage constraints, tacit judgment, and safety-critical rules.
  • Human-derived acquisition: Manual curation provides fine semantic control but is slow to scale and maintain, so human-authored skills often seed more automated acquisition.The survey links this trade-off to the growth and diversification of skills in agent platforms.
  • Experience-derived acquisition: Experience-derived acquisition constructs skills from execution traces, exemplars, interaction histories, and feedback rather than leaving experience as transient memory.It is described as the most heavily studied acquisition family, with many concrete mechanisms and systems.
  • Experience-derived acquisition: Experience-processing pipelines select useful episodes, abstract lessons, organize structured memory, and package know-how into workflows, APIs, or executable modules.A single pipeline may chain several operations before producing a reusable skill artifact.
  • Experience-derived acquisition: Experience-derived methods differ mainly in how prior execution material is processed, spanning reusable exemplars, compact lessons, structured memory, workflows, and executable artifacts.These forms represent a spectrum of skill artifacts rather than a single required output.

C. Task-Derived Acquisition

Task-derived acquisition constructs candidate skills from current task requirements, then validates, revises, retains, or discards them. Across the broader ecosystem, task-derived, corpus-derived, experience-derived, and human-derived routes are presented as complementary ways to build robust skill libraries.

  • Task-derived acquisition: Task-derived acquisition generates candidate workflows, scripts, tool wrappers, or other artifacts directly from the current task requirements.The defining feature is task-conditioned construction followed by post-hoc retention or refinement.
  • Task-derived acquisition: CREATOR, ToolMakers, Cradle, and CodeAct illustrate task-derived construction for callable tools, reusable skills, immediate control, and procedural action.These systems show that task requirements can induce operational procedures rather than only final answers.
  • Corpus-derived acquisition: Corpus-derived acquisition distills documentation, repositories, datasets, interface traces, and knowledge bases into reusable procedural skills.Examples include extracting interface procedures, compiling API guidance, and mining competition write-ups for recurring solution patterns.
  • Complementary acquisition routes: LLMs lower the authoring cost of human-derived skills and expand corpus-derived skill supply by transforming external artifacts into explicit procedural guidance.This extends candidate skills beyond what agents have personally experienced.
  • Complementary acquisition routes: Experience-derived acquisition remains the richest route, while task-derived acquisition supports novel requirements through on-demand construction, validation, and retention.The survey treats these routes as complementary rather than exclusive.
  • Complementary acquisition routes: The four acquisition families contribute complementary strengths: semantic precision, behavioral grounding, responsiveness, and scalable cold-start coverage.The survey presents their combination as a basis for robust skill ecosystems, with LLMs lowering creation and maintenance costs.

A. Skill Retrieval

Skill retrieval reduces large repositories to candidate sets through semantic, lexical, generative, or structure-aware mechanisms. Dense retrieval is a common entry point for varied natural-language tasks, but applicability constraints and retrieval–calling coupling motivate later refinement.

  • Retrieval strategies: Skill retrieval narrows a large repository to candidate skills using dense semantic, sparse lexical, generative, or structure-aware signals.The surveyed approaches differ in whether they use embeddings, explicit metadata, identifier generation, or internal library organization.
  • Dense embedding retrieval: Dense retrieval maps tasks and skills into a shared embedding space and retrieves candidates by vector similarity.It is used for textual descriptions, workflow summaries, programmatic skills, structured records, experiential lessons, and reasoning memories.
  • Dense embedding retrieval: Dense retrieval is a natural entry point for varied task formulations, but semantic nearest neighbors may not be the most applicable skills.Later stages can refine candidates with metadata, structure, or execution-aware checks.
  • Sparse retrieval: Sparse retrieval matches explicit symbolic fields and metadata, making it narrower but often more trustworthy for stable names, interface fields, and trigger cues.Its lexical evidence degrades when requests are paraphrastic or underspecified, so it commonly sharpens a broader pool.
  • Generative retrieval: Generative retrieval produces skill or tool identifiers during decoding instead of consulting a separate retrieval index.This removes the boundary between candidate recall and action generation but complicates coverage, identifier validity, and retrieval-quality assessment.
  • Structure-aware retrieval: Structure-aware retrieval uses hierarchical narrowing or dependency constraints to exploit organization within skill libraries.It treats internal structure as a guide for recall rather than viewing all candidates as a flat pool.

5) discussion:

Skill retrieval and selection are complementary policy problems rather than one-shot relevance matching. Effective systems balance semantic flexibility, symbolic precision, structure, context, cost, composition, and execution feedback.

  • Dense, sparse, generative, and structure-aware retrieval trade off semantic flexibility, symbolic precision, identifier control, and compositional structure.The literature is moving toward multi-signal, execution-aware candidate recall.
  • Context-aware dynamic selection: Context-aware selection revises skill choices online as observations, subgoals, and interaction histories change.This treats selection as an evolving decision process rather than a fixed ranking.
  • Skill composition: Skill composition assembles multiple reusable skills into ordered or connected workflows, introducing interface, ordering, and error-propagation constraints.Composition therefore typically requires planning or structural guidance rather than simple top-k ranking.
  • Cost- and utility-aware selection: Cost- and utility-aware selection considers expected benefit alongside computation, latency, risk, or side effects, but lacks a shared formal objective.The survey presents it as an emerging design criterion rather than a mature standalone family.
  • Feedback-driven reranking: Feedback-driven reranking uses historical execution outcomes to reorder future skill preferences, especially for long-running agents.It commonly operates as an augmentation layer because feedback is entangled with memory editing or policy adaptation.
  • Together, these dimensions shift skill selection from static relevance choice toward sequential, execution-aware policy decisions.Practical systems may combine context, composition, cost, and feedback perspectives.

C. Design Dimensions in Retrieval and Selection

Retrieval and selection depend on how skills expose semantics, execution structure, applicability, and granularity. Evaluation must connect candidate quality with execution success, cost efficiency, and adaptation rather than relying on retrieval metrics alone.

  • Representation: Skill representation exposes the signals used downstream: hybrid skills combine semantic descriptions with execution structure for easier retrieval and constraint.Pure code skills often require names, signatures, docstrings, or summaries to become retrievable and rankable.
  • State and applicability: State and applicability determine whether retrieved skills remain usable under observations, environment conditions, prerequisites, and execution failures.Precondition and dependency checks can filter candidates before and during selection.
  • Granularity: Granularity determines whether selection routes one primitive skill or assembles workflows, executable modules, or groups of composable skills.Larger retrieved objects shift the problem from candidate choice toward executable-structure assembly.
  • Objectives and feedback: Objectives and feedback jointly shape selection by determining optimization targets and updating which candidates are preferred, suppressed, or refined.Selection may account for utility, reliability, and execution burden, not relevance alone.
  • Evaluation: Standard top-k recall does not measure final execution success or positive net utility, so evaluation must connect retrieval, incorporation, execution, cost, and adaptation.SRA-Bench separates retrieval, skill incorporation, and final task execution, while the survey calls for a more integrated framework.
  • Skill evolution: Skill evolution proceeds through refinement and reuse, with updates revised, validated, indexed, retrieved, executed, and governed.The lifecycle distinguishes artifact-changing revision from later validation, repository propagation, and runtime control.

A. Skill Revision

Skill revision changes persistent artifacts in response to feedback, while validation determines whether changes survive. The broader evolution process couples artifact updates with policy adaptation and durable reuse under explicit survival conditions.

  • Skill revision: Skill revision modifies a persistent skill object and decides whether the proposed change should survive.EvoSkill materializes accepted changes as structured folders containing triggers, instructions, and helper scripts.
  • Skill revision: Deployment-time revision can use unit-test gates and rollback to make updates reversible before rewriting reusable prompts or programs.Memento-Skills attributes failures before rewriting the skill guidance that will be reused later.
  • Skill revision: Longitudinal systems preserve skill identity by adding, merging, discarding, removing, or refining persistent artifacts across later use.AutoSkill and XSkill update named skill documents rather than merely storing new traces.
  • Scope of evolution: Skill evolution requires feedback to change a named, reusable artifact that remains available after an update, with revision, validation, versioning, or later reuse providing the evidence.The survey distinguishes this criterion from trajectory-driven skill construction alone.
  • Skill validation: Validation turns revision into a survival decision, using tests, executability checks, failure localization, maturity gates, rollback, or verifier evidence.The strength of validation varies: passing tests may only establish immediate execution success, whereas replayable evidence provides stronger support.
  • Policy coupling: Policy coupling makes the skill substrate part of controller training, so policy updates and skill-bank changes influence later failures, gaps, and rollouts.SkillRL and ARISE integrate retrieval, evolution, rewards, validation, and library updates into agent state.
  • Scope boundary: Policy coupling is narrower than general continual learning: policy optimization must change the skill substrate and later alter the policy’s action space or rollout distribution.CASCADE is treated as a boundary case because its central mechanism is continuous learning and self-reflection rather than RL-style cooptimization.

D. Repository Evolution

Repository evolution scales accepted skill changes from individual artifacts to shared, structured substrates. Its practical scope includes grounding, refinement, synchronization, retrieval, and trust, while long-horizon causal attribution remains unresolved.

  • Repository expansion: Uni-Skill expands a hierarchical robotic repository when planning detects missing skills and requests grounded supplementary descriptions.Its evolution claim concerns repository expansion and grounding rather than mature autonomous evolution.
  • Repository refinement: SkillX refines and filters multi-level skill knowledge, while SkillNet organizes shared repositories through dynamic ontology and infrastructure.These approaches improve repository structure and coverage through experience-guided processes.
  • Collective evolution: Collective evolution requires synchronization control: SkillClaw validates updates in user environments before propagating accepted changes to a shared repository.Shared repositories must manage duplicate skills, inconsistent relations, weak coverage, and propagation quality.
  • Runtime retrieval: Runtime retrieval remains necessary after refinement because selectors must find the changed artifact rather than an obsolete or superficially similar skill.SkillRouter exposes this retrieve-and-rerank layer for large skill pools.
  • Runtime governance: Governance separates executability from runtime trust by requiring evidence, validation, or propagation controls for evolved and shared skills.Audited Skill-Graph uses replayable evidence, while PoisonedSkills illustrates the risk of malicious trusted guidance.
  • Discussion: The strongest evolution evidence combines durable substrate changes with survival checks, but repository-scale autonomy still lacks long-horizon causal attribution across interacting systems.The survey identifies boundary cases involving cumulative growth, routing, trust, and internalized skills.
  • Open challenges: Open challenges include abstraction quality, trigger specification, resource drift, and admission quality at scale.These issues can leave skills too local, poorly routed, stale, or accumulated faster than libraries can validate and curate them.

B. Skill Retrieval

Agent-skill retrieval is increasingly a lifecycle and control problem rather than simple relevance matching. The survey identifies gaps in scalable library management, constraint-aware composition, multi-objective selection, execution-centered evaluation, personalization, recovery, and governance.

  • Skill libraries lack a general mechanism for synchronizing indexes, metadata, and priorities as skills are added, merged, revised, or deprecated.
  • Finding relevant skills is insufficient when prerequisites and execution-path constraints remain modeled through system-specific abstractions.
  • Selection still lacks a common objective combining success, cost, latency, safety, risk, and user preference.
  • Retrieval recall and selection accuracy cannot establish end-to-end execution gains, cost savings, recovery quality, or downstream effects.
  • Robust skill use requires personalization, adaptive recovery, and joint modeling of retrieval, execution, and library evolution.
  • Future directions include unified schemas, resource-aware optimization, lifecycle-safe updates, multimodal benchmarks, and causal diagnosis of skill failures.

IX. APPLICATION SCENARIOS

Agent skills span diverse application settings and encode domain-specific workflows, interaction routines, behavioral units, and procedural knowledge. The survey situates these applications within broader tool-use, retrieval, memory, and agent-skill research, using a lifecycle framework for reusable execution.

  • The survey organizes application scenarios into eight categories with domain-specific skill formats and acquisition strategies.Figure 10 illustrates these scenarios.
  • Software-engineering skills package recurring coding workflows, while web and GUI skills encode multistep interaction and recovery routines.
  • Game and social-simulation skills support reusable, composable behavior during long-horizon tasks under interaction and coordination constraints.
  • The survey positions agent skills alongside tool use, RAG, and agent memory while treating procedural artifacts as first-class lifecycle-managed building blocks.
Loading 2605.07358v3…