Paper deep dive

SkillX: Automatically Constructing Skill Knowledge Bases for Agents

Chenxi Wang, Zhuoyun Yu, Xin Xie, Wuguannan Yao, Runnan Fang, Shuofei Qiao, Kexin Cao, Guozhou Zheng, Xiang Qi, Peng Zhang, Shumin Deng

Year: 2026Venue: arXiv preprintArea: cs.CLType: PreprintEmbeddings: 93

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 94%

Last extracted: 4/10/2026, 2:55:45 AM

Summary

SkillX is an automated framework for constructing a hierarchical, plug-and-play skill knowledge base for LLM agents. It distills raw trajectories into planning, functional, and atomic skills, utilizing iterative refinement and exploratory expansion to improve agent performance, transferability, and execution efficiency across complex benchmarks like AppWorld, BFCL-v3, and τ²-Bench.

Entities (6)

SkillX · framework · 100%AppWorld · benchmark · 95%BFCL-v3 · benchmark · 95%GLM-4.6 · llm · 95%τ-bench · benchmark · 95%Qwen3-32B · llm · 90%

Relation Signals (3)

SkillX → constructs → Skill Knowledge Base

confidence 100% · SkillX, a fully automated framework for constructing a plug-and-play skill knowledge base

SkillX → evaluatedon → AppWorld

confidence 95% · evaluate its transferability on challenging long-horizon, user-interactive benchmarks, including AppWorld

SkillX → uses → GLM-4.6

confidence 95% · we instantiate SkillX with a strong agent backbone, GLM-4.6

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Learning from experience is critical for building capable large language model (LLM) agents, yet prevailing self-evolving paradigms remain inefficient: agents learn in isolation, repeatedly rediscover similar behaviors from limited experience, resulting in redundant exploration and poor generalization. To address this problem, we propose SkillX, a fully automated framework for constructing a \textbf{plug-and-play skill knowledge base} that can be reused across agents and environments. SkillX operates through a fully automated pipeline built on three synergistic innovations: \textit{(i) Multi-Level Skills Design}, which distills raw trajectories into three-tiered hierarchy of strategic plans, functional skills, and atomic skills; \textit{(ii) Iterative Skills Refinement}, which automatically revises skills based on execution feedback to continuously improve library quality; and \textit{(iii) Exploratory Skills Expansion}, which proactively generates and validates novel skills to expand coverage beyond seed training data. Using a strong backbone agent (GLM-4.6), we automatically build a reusable skill library and evaluate its transferability on challenging long-horizon, user-interactive benchmarks, including AppWorld, BFCL-v3, and $\tau^2$-Bench. Experiments show that SkillKB consistently improves task success and execution efficiency when plugged into weaker base agents, highlighting the importance of structured, hierarchical experience representations for generalizable agent learning. Our code will be publicly available soon at this https URL.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

92,908 characters extracted from source content.

Expand or collapse full text

SkillX: Automatically Constructing Skill Knowledge Bases for Agents Chenxi Wang * 1 2 Zhuoyun Yu * 1 2 Xin Xie 2 Wuguannan Yao 2 Runnan Fang 1 Shuofei Qiao 1 Kexin Cao 1 Guozhou Zheng 1 Xiang Qi 2 Peng Zhang 2 Shumin Deng 1 Abstract Learning from experience is critical for building capable large language model (LLM) agents, yet prevailing self-evolving paradigms remain inef- ficient: agents learn in isolation, repeatedly re- discover similar behaviors from limited experi- ence, resulting in redundant exploration and poor generalization. To address this problem, we pro- poseSkillX, a fully automated framework for constructing a plug-and-play skill knowledge base that can be reused across agents and en- vironments.SkillXoperates through a fully automated pipeline built on three synergistic in- novations: (i) Multi-Level Skills Design, which distills raw trajectories into three-tiered hierar- chy of strategic plans, functional skills, and atomic skills; (i) Iterative Skills Refinement, which automatically revises skills based on ex- ecution feedback to continuously improve library quality; and (i) Exploratory Skills Expansion, which proactively generates and validates novel skills to expand coverage beyond seed training data. Using a strong backbone agent (GLM- 4.6), we automatically build a reusable skill li- brary and evaluate its transferability on challeng- ing long-horizon, user-interactive benchmarks, including AppWorld, BFCL-v3, andτ 2 -Bench. Experiments show that SkillKB consistently im- proves task success and execution efficiency when plugged into weaker base agents, highlighting the importance of structured, hierarchical experi- ence representations for generalizable agent learn- ing. Our code will be publicly available soon at https://github.com/zjunlp/SkillX. 1. Introduction Large language model (LLM) based agents (OpenAI, 2025; DeepSeek-AI, 2025; Team et al., 2025b; Yang et al., 2025) 1 Zhejiang University 2 Ant Digital Technologies, Ant Group. Correspondence to: Shumin Deng <231sm@zju.edu.cn>. Preprint. April 7, 2026. Claude Skills Long-context progressively revealed Complex system environment Multi-round interaction ... SkillX(Ours) Multi-level skills stored as items Lightweight system environment Only need one-time loading Prompt 1x ... Adaption Figure 1. Claude Skills follow a long-context, progressively dis- closed format, which requires a complex sandboxing system and multiple interactions, thereby posing challenges to robust reason- ing. In contrast, SkillX adopts a hierarchical, itemized represen- tation that can be stored and retrieved via a lightweight retrieval module and injected into the system prompt in one time, making it easier to transfer across base models. have recently demonstrated remarkable progress in long- horizon decision making with tools, enabling complex be- haviors such as API calling (Trivedi et al., 2024; Patil et al., 2025; Li et al., 2025), web navigation (Yao et al., 2023; Zhou et al., 2024; Mialon et al., 2023), scientific discov- ery (Ou et al., 2025; Liu et al., 2025; Qiao et al., 2025; Novikov et al., 2025), and interactive assistants (Barres et al., 2025; Yao et al., 2024; He et al., 2025). Despite these advances, most agents still approach each new task largely from scratch, relying on direct reasoning or limited task- specific demonstrations. This paradigm is costly, brittle, and fundamentally at odds with how intelligent systems are expected to accumulate and reuse experience over time. A natural resolution is to enable agents to learn from ex- perience (Sutton, 2025). Recent work has explored self- evolving agents that iteratively reflect on past executions and improve their behavior over time (Wang et al., 2025c; Fang et al., 2025c; Zhao et al., 2024; Xu et al., 2025; Cao et al., 2025). While promising, these approaches often fail to deliver scalable and transferable gains. In practice, expe- rience learning typically suffers from three structural limita- tions. (1) Isolated Learning: agents execute the same tasks repeatedly and re-extract similar experiences independently, leading to substantial redundancy. (2) Weak Generalization of Experience: in complex environments, high-quality train- 1 arXiv:2604.04804v1 [cs.CL] 6 Apr 2026 SkillX: Automatically Constructing Skill Knowledge Bases for Agents ing data are scarce, so the mined experiences often transfer poorly to new tasks. (3) Model Capability Bottleneck: when experience is harvested solely through an agent’s own ex- ploration and reflection, what can be extracted is ultimately capped by the agent’s current capability frontier. These chal- lenges point to a more fundamental question: What form of experience can be broadly reusable across agents of varying capabilities and across diverse environments? Existing work has proposed multiple representations of ex- perience, such as insights (Cao et al., 2025; Ouyang et al., 2025), workflows (Wang et al., 2025c;b; Han et al., 2025), or trajectories (Zhao et al., 2024; Fang et al., 2025c). However, none of these representations simultaneously offer strong transferability, efficient retrieval, and direct executability. Inspired by Claude Skills (Anthropic, 2025), we argue that skills provide a more suitable abstraction: they encapsulate reusable competencies that directly support task execution. Nonetheless, prior skill-based designs often rely on long- context, progressive disclosure, which place heavy demands on reasoning and environment instrumentation, limiting ro- bustness and practical reuse, as illustrated in Figure 1. In this work, we introduceSkillX, a fully automated framework for constructing a plug-and-play skill knowl- edge base from agent experience. Our core insight is that transferable experience should be organized hierarchically, rather than as monolithic behaviors.SkillXtherefore represents experience at three complementary levels: (i) Planning Skills, which capture high-level task organiza- tion; (i) Functional Skills, which implement reusable, tool- based subroutines; and (i) Atomic Skills, which encode execution-oriented usage patterns and constraints. This multi-level design yields skills that are concise, composable, and robust to distributional shifts.SkillXbuilds such a skill library through a fully automated pipeline. A strong backbone agent first performs rollouts on training tasks and distills multi-level skills from successful trajectories. The extracted skills are then iteratively refined through con- solidation and validation, improving library quality over time. Finally,SkillXperforms experience-guided explo- ration to proactively expand the skill space by targeting under-utilized tools and failure-prone behaviors, enabling generalization beyond the initial training distribution. To build a reliable, plug-and-play skill library, we instantiate SkillXwith a strong agent backbone, GLM-4.6 (Team et al., 2025a), and pre-build a skill library on challenging, user-interactive, long-horizon benchmarks, including: Ap- pWorld (Trivedi et al., 2024), BFCL-v3 (Patil et al., 2025), andτ 2 -Bench (Barres et al., 2025). Our experiments show that this plug-and-play skill library can be directly plugged into base agents (e.g., Qwen3-32B (Yang et al., 2025)), yielding around a 10% performance improvement while also improving execution efficiency. We further demonstrate the advantages of our multi-level skill design for experience representation, and show that both iterative refinement and skill expansion provide additional gains. In a nutshell, we conclude our contributions as: •We propose a hierarchical skill representation that trans- forms raw trajectories into reusable planning, functional, and atomic skills. • We presentSkillX, a fully automated and extensible framework for pre-building plug-and-play skill libraries for LLM agents, featuring iterative refinement and skill expansion. •We release the resulting plug-and-play skill library and provide strong empirical evidence across multiple agent benchmarks that it can directly enhance the capabilities of weaker agents. 2. Preliminaries Agent DefinitionWe consider a general interactive setting where an agent solves tasks by acting in an environment. An environment is defined asE = (S,A,P), whereAis the set of executable actions,Sis the set of observable states, andP(s ′ | s,a)is the transition dynamics. At time stept, the agent receives an observationo t ∈Oand produces an actiona t ∈A. Following the ReAct style formulation, the agent therefore selects an actionˆa t ∈ ˆ Aconditioned on its context c t = (o 1 , ˆa 1 ,...,o t−1 , ˆa t−1 ,o t ): ˆa t ∼ π(·| c t ),ˆa t ∈ ˆ A.(1) Executingˆa t ∈Ayields a new observation via the environ- ment. The final trajectory is τ = (o 1 , ˆa 1 ,...,o T , ˆa T ). LLM Agent and Skill-Conditioned Execution. LetQ be the tasks set. We writeq ∈Qfor sampling a task, and let R(τ,q)∈0, 1be a task-dependent success indicator. We model the LLM agent as a policyπthat induces a trajectory distribution. Without external skills, the agent generates trajectories by direct reasoning: τ ∼ π(·| q), q ∈Q.(2) To reduce redundant exploration and improve task com- pletion, we equip the agent with a skills libraryD = s 1 ,...,s |D| and a skill retriever that recalls a set of rel- evant skills for the current task. Concretely, givenq ∈ Q, a retrieval function (typically implemented via semantic- similarity retrieval)ρ : Q → 2 D . returns a skill subset S q = ρ(q),S q ⊆ D. The LLM agent then generates a trajectory by conditioning on the retrieved skill set: τ ′ ∼ π(·|S q ,q), q ∈Q.(3) Our objective is to design the skills libraryDand the usage within π such that the expected success rate is improved: E q∈Q,τ ′ ∼π(·|S q ,q) R(τ ′ ,q) >E q∈Q,τ∼π(·|q) R(τ,q). (4) 2 SkillX: Automatically Constructing Skill Knowledge Bases for Agents 3. SkillX Design and Implementation 3.1. Multi-Level Skills Design In tool-centric agent scenarios, we structure the skills re- quired by the model into three levels (see Figure 2): D = S plan ⊕ S func ⊕ S atomic ,(5) corresponding to planning skills, functional skills, and atomic skills, respectively. In a given environmentE, let Tdenote the set of tool actions. (i) Atomic skills atomic is aligned with a single toolt ∈ Tand is modeled as an ex- tended semantic specification oft, e.g., as enriched descrip- tions, constraints, or usage patterns that refine the effective behavior oft. (i) Functional skills func abstracts a subtask and can be regarded as a macro-operation that accomplishes a sub-query. We assume each taskqadmits a decomposition intonsubtasks,q subtask,1 ,q subtask,2 ,...,q subtask,n and each s func corresponds to skills to accomplishq subtask,i . Specifi- cally,s func is grounded in a set of tool actions, which can be instantiated as a composition of toolsT func ⊆ T. (i) planning skills plan aligns with the organizational structure of the subtasks (e.g., ordering, dependencies, and branch- ing), specifying how functional skills should be composed to solveq. Next, we describe the extraction methods for the three skill levels. 3.2. Rollout and Skills Extraction Given a taskq, we first performm-sized rollouts, reusing the agent’s inference procedure to collect trajectories. We then extract the multi-level skills from these trajectories, with skill extractorf. Details of the inference procedure are provided in Section 4. Planning Skills Extraction.Given a successful trajectory, we extract the planning skills plan by compressing the tra- jectory into an ordered set of high-level steps. During this compression, we explicitly filter out non-essential transi- tions such as exploration, backtracking, and trial-and-error behaviors that are incidental to the final solution but detri- mental to skill reuse. Moreover, for excessively long or verbose environment feedback, we apply summarization to obtain compact state descriptions, which improves the stability and fidelity of the extracted high-level skills. Functional Skills Extraction.We leverage the previously extracted planning skills plan to guide the extraction of func- tional skills. Concretely, given a plan and its corresponding trajectory, we iteratively prompt the model to extract the functional skills func that aligns with the objective of each subtaskq subtask,i . Formally, eachs func is represented with three key fields:name(the skill name),document(a de- scription of inputs, outputs and usage notes), andcontent (the tool invocation pattern for completing subtaskq subtask,i ). Atomic Skills Extraction. Atomic skills are single tool specifications that extend the original tool schema with reusable, execution-oriented usage patterns. They serve as a low-level complement when higher-level functional skillss func are missing or incomplete. We prompt the model to distills atomic from trajectories the invocation patterns, typical parameter configurations, and practical notes, espe- cially constraints and common failure modes observed in real usage. The representation ofs atomic is unified withs func . 3.3. Iterative Skills Refinement With only a limited amount of seed training data, a key question is whether we can maximize the utility of the avail- able supervision to extract additional skills and continuously improve existing ones. Inspired by prior works (Cai et al., 2025b;a; Yuksekgonul et al., 2024), we adopt a text-based iterative optimization paradigm for the skill library. Con- cretely, atk-th iteration, we start from the current skill libraryD (k) , repeatedly rollouts from the training set, then extract multi-level skills. We subsequently apply a refine- ment operatorφ, including: Skills Merge and Skills Filter. Finally, we update the skill libraryD (k) with the refined skills to obtain skill libraryD (k+1) , including three update operations: add, modify or keep. Iterative Skills Library Construction.We construct the skill library in an iterative manner. LetD (0) = ∅be an initial empty library. In iterationk = 0, 1,..., we roll out the agent augmented with the current libraryD (k) on tasks sampled from the training setQ train to obtain a set of trajectories τ (k) ∼ π(·| ρ D (k) (q),q), q ∈Q train ,(6) and denoteK (k) = τ (k) 1 ,...,τ (k) N k . A skill extractorf produces a variable-size set of candidate skills from each trajectory,S (k) i = f(τ (k) i )and we aggregate all the skills extracted from the batch viaS (k) = S N k i=1 S (k) i . Addition- ally, we define a refinement operatorφto merge and filter the skills. The library is then updated as D (k+1) ≜D (k) ∪ φ S (k) =D (k) ∪ φ N k [ i=1 S (k) i ! . (7) LetQ test denote a test distribution. We aim to iteratively improve the library such that the performance of the induced skill-conditioned agent is maximized onQ test : max k E q∼Q test h E τ∼π(·|ρ D (k) (q),q) R(τ,q) i ,(8) and we stop the iteration when this test performance no longer improves. 3 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Skills Library Multi-Level Skills Design Task:Name the artist most recommended to me on Spotify. Planning Skills Functional Skills Atomic Skills Step 1: Authenticate with Spotify Step 2: Fetch all personalized song recommendations ...... Step 5: Return the most recommended artist's name Skill Name:spotifyauthenticate with stored credentials ---------------------------------------------------------------------------- Skill Document: Description:This skill handles the authentication ... Parameters:username : str,account_name: str, optional Outputs:str: The access token for the authenticated.... Notes: If the default 'account_name' is not specified... ----------------------------------------------------------------------------- Skill Content: passwords =apis.supervisor.show_account_passwords() spotify_password= None. ..... login_result= apis.spotify.login... Skill Name:List all APIs in an app ---------------------------------------------------------------------------- Skill Document: Description: Explore all APIs under a specific app Parameters:app_name: str Outputs:List: A list of APIs available within the app. Notes:1.Do not invent or assume APIs.... ---------------------------------------------------------------------------- Skill Content:apis.api_docs.show_api_descriptions... Skills Refinement Skills FilterSkills Merge General Filter Tool-Specific Filter Cluster Similar Skills MergeSkillClusters Decompose Complex Skills Skills Expansion Experience Guiding Exploration Synthesis Tasks Abstract Experience Summarize Task & Reference Trajectory Exploration Trajectory Rollout andSkillsExtraction Experience Guide Tasks Generate Modify & Add & Keep Skills Training Tasks Pseudo Plans Trajectory Retrieved Planning Skills Sample a task ExtractRollout Rewrite Retrieved Functional & Atomic Skills Figure 2.SkillXprovides an automated, iterative pipeline for constructing a skills library, integrating skills extraction. skills expansion and skills refinement. The skills library is organized into three levels: planning skills, functional skills, and atomic skills. Skills Merge.After extracting skills from each trajectory, we often obtain many functionally redundant skills that, de- spite surface differences, correspond to the same underlying skill pattern. How to update a single skill when multiple heterogeneous update directions are available? We merge skills from an optimization-based perspective. For a spe- cific skillswith current embedding, we first retrieve and cluster a set of semantically similar skills using cosine simi- larity. The resulting cluster can be interpreted as providing multiple complementary update directions for the same un- derlying skill, a multi-dimensional refinement ofs. Let Z(s) =1,...,z index the semantically similar skills as- sociated with skills. Each neighboriinduces a candidate update direction δ i , yielding a candidate updated state s ′ i = s + δ i , i∈Z(s).(9) We then aggregate these candidate directions into the final direction. The simplest form is to merge the directions: δ agg = P i∈Z(s) δ i . The final update is applied as s + = s + δ agg .(10) Specifically, we treat the semantically similar skills as multi- ple update views of the same skill, and we use the combined direction as the final update direction. Finally, we merge semantically similar skills into a single skill. If the merged skill becomes overly complex, we further decompose it into more modular, reusable skills. Skills Filter.We enforce skill quality via a strict two-stage filtering procedure. (1) General Filter. This stage removes skills that are unlikely to be portable or compositional, in- cluding those that depend on extraneous Python packages, expose overly idiosyncratic function-style definitions, or overly-encapsulated skills. (2) Tool-specific Filter. This stage mitigates tool-use hallucinations by validating each skill against the environment-provided tool schema, reject- ing skills that reference non-existent tools, invalid parame- ters, or schema-incompatible argument structures. Together, these filters maintain a high-precision skill library while pre- serving flexibility across heterogeneous agent benchmarks. Skills Library Update.After completing Skill Merge and Skill Filter, we perform concrete updates to the skill library D k for thek-th iteration, including three types:addnew skills,modifyexisting skills, andkeepskills unchanged. Furthermore, the entire pipeline can be executed iteratively over multiple rounds. Through this continual update process, the skill library progressively improves in coverage, quality, and compositional richness, enabling increasingly effective skill reuse for downstream agent tasks. 4 SkillX: Automatically Constructing Skill Knowledge Bases for Agents 3.4. Exploratory Skills Expansion While skills distilled from a seed training setQ train can already improve an agent’s performance, relying solely on scarce demonstrations is insufficient in complex environ- ments with large tool spaces (e.g., (Trivedi et al., 2024) exposes hundreds of APIs). Inspired by Zhai et al. (2025), we adopt an Experience Guiding Exploration scheme to broaden coverage beyond what is observed in the seed data, encouraging the agent to interact with the environment and exercise a wider range of tools. We guide exploration using experience collected from rollouts on the seed set (e.g., tools the agent already uses reliably, tools with high failure rates, and tools that are never invoked), thereby prioritizing under- explored or failure-prone tools to improve sample efficiency. After collecting exploratory trajectories, we synthesize new tasksQ syn from these interactions, and then rerun our skill acquisition and refinement pipeline on the resulting data to iteratively expand the skill library. Compared to the ran- dom exploration strategy (Zhai et al., 2025), our approach discovers a more diverse set of skills. 4. SkillX Usage Planning Skills Retrieval and Pseudo-Plan Rewriting. For a novel and complex agent taskq, directly retrieving past experiences based solely on task similarity may lead to a mismatch between retrieved experiences and the ac- tual execution trajectory. This issue becomes particularly pronounced in environments where execution dynamics are strongly influenced by user profiles, contextual constraints, or other external factors. To improve retrieval relevance, inspired by (Gao et al., 2022), we first retrieve high-level planning skills associated with similar tasksP(q) = ρ(q), whereρis a similarity retrieval function andP(q)is the retrieved planning skills. Then we prompt the model to self-rewrite a task-specific pseudo-plan conditioned on the current task ̃p(q) = LLM rewrite q, P(q) . This rewritten pseudo-plan serves as an intermediate retrieval query to bet- ter align subsequent skill retrieval with the current execution setting. To mitigate hallucination risks and prevent specula- tive content from affecting agent behavior, the pseudo-plan is not injected into the final system prompt. Functional and Atomic Skills Retrieve.Given the rewrit- ten pseudo-plan ̃p(q) =step 1 , step 2 ,..., step p , we treat each step as a retrieval query to retrieve functional and atomic skills. Forstep i , we first retrieve relevant skills S i = ρ(step i )and then remove duplicates across steps, S ′ = dedup S p i=1 S i . To keep the context concise and task-relevant, we further ask the LLM to self-filter the retrieved candidates and retain only applicable skills S q = LLMselect(q, ̃p(q),S ′ ), whereS q is the final skill set used for solving the query q. 5. Experiment 5.1. Experimental Settings Benchmarks and Metrics.We conduct the evaluation on complex, long-horizon, user-interactive agent benchmarks, including BFCL-v3 (Patil et al., 2025), AppWorld (Trivedi et al., 2024), andτ 2 -bench (Barres et al., 2025). For BFCL- v3, we use the base multi-turn category and randomly split it into 50 training instances and 150 test instances. AppWorld provides 90 training instances and the Test Normal category as test set.τ 2 -bench defines training and test splits for each sub-domain. Additional details are provided in the Appendix A.1. For AppWorld and BFCL-v3, we report Avg@4 and Pass@4, the average success rate over four independent runs and the probability of succeeding at least once across four runs, respectively. Following the (Barres et al., 2025) evaluation setup, we report Passˆ1, the pass rate over running four times. Models and Baselines. To assess the effectiveness of SkillX, we evaluate three Agentic base models that vary in model size and reasoning style (thinking and non- thinking), including Qwen3-32B (Yang et al., 2025), Kimi- K2-Instruct-0905 (Team et al., 2025b), and GLM-4.6 (Team et al., 2025a). Among them, GLM-4.6 has been reported to exhibit strong native agentic capabilities in agent mid- training, serving as a competitive backbone for our study. We compare against four representative baselines: (1) No- memory, which performs inference without retrieving any prior experience; (2) A-Mem (Xu et al., 2025), a system that dynamically manages structured episodic memories; (3) AWM (Wang et al., 2025c), which reuses modular work- flows distilled from historical trajectories; and (4) ExpeL (Zhao et al., 2024), which retrieves relevant past trajectories as few-shot demonstrations and incorporates distilled in- sights to improve LLM performance. For a fair comparison, all methods retrieve experience only based on the user’s initial query and insert the retrieved content into the system prompt following a unified protocol. Full baseline details are provided in the Appendix A.2. Implementation Details. To constructSkillX, we use GLM-4.6 (Team et al., 2025a) independently rollouts four times per training task, followed by skill extraction, skill refinement, and skill expansion. The maximum number of refinement iterations is set to 3. For efficiency, we limit environment exploration to one rollout per training task; the sampling temperature is 1.0 during exploration. We use Qwen3-Embedding-8B (Zhang et al., 2025d) for both skill deduplication and skill retrieval, with a minimum cosine similarity threshold of 0.45 for retrieval. During solving new tasks, we use the same model for both Pseudo-Plan rewriting and action execution. For the other baselines, we evaluate 5 SkillX: Automatically Constructing Skill Knowledge Bases for Agents ModelMethods BFCL-V3AppWorldτ 2 -Bench Avg@4Pass@4Avg@4Pass@4RetailAirlineTelecom Qwen3-32B No Memory ∗ 53.6773.3327.6847.6253.7538.7536.25 A-Mem ∗ 53.6773.0026.7950.5953.1238.7538.12 AWM ∗ 55.6776.0030.8055.9555.0040.0038.12 AWM ‡ 56.6776.3334.4556.2557.5041.2540.62 ExpeL ∗ 57.3377.6732.8758.9356.2542.5039.38 ExpeL ‡ 59.3378.8332.9458.7858.1243.7541.25 SkillX ‡ 63.6782.0035.1258.9366.8747.5043.75 Kimi-K2-Instruct-0905 No Memory ∗ 65.1778.0046.8870.2475.6251.2578.12 A-Mem ∗ 65.1776.6746.5872.6276.2552.5076.87 AWM ∗ 65.3379.0049.7076.1976.2553.7577.50 AWM ‡ 64.6779.1750.6076.4976.2553.7577.50 ExpeL ∗ 66.3379.3352.5378.5777.5055.5078.75 ExpeL ‡ 66.0079.6752.9878.8777.5056.2579.37 SkillX ‡ 66.8381.3356.4081.5578.1258.7582.50 GLM-4.6 No Memory ∗ 76.6783.3360.2783.3376.2570.0070.63 A-Mem ∗ 76.5083.0060.5783.9376.8870.0068.75 AWM ∗ 77.1784.0062.2084.5277.5071.2570.63 ExpeL ∗ 78.8385.3364.1485.1277.5072.5071.25 SkillX ∗ 79.5086.0064.8888.6982.5076.2571.88 Table 1. Main results ofSkillXon three benchmarks. Methods with∗mean that the experience extraction model is aligned with the inference model. Methods with‡mean that GLM-4.6 is used for experience extraction, while inference still relies on the original model. two settings: (1) Distillation paradigm: a strong agent (GLM-4.6) is used to extract experiences to build an expe- rience repository, and the execution model then performs inference; (2) Self-evolution paradigm: the experience ex- traction model is kept consistent to the execution model to enable self-extraction, following the original experimental protocol of each method. Additional implementation details are provided in the Appendix A.3. 5.2. Main Results SkillX Boost Agentic Performance of Base LLMs.As shown in Table 1,SkillXimproves the base model’s per- formance. In particular, Qwen3-32B gains roughly around 10 points across multiple benchmarks. For K2 (Kimi-K2- Instruct-0905), we observe a clear improvement on App- World, whereas the gains are modest on the other two tool call intensive benchmarks. We infer this is because K2 re- lies more heavily on the original tool schema and does not effectively leverage the additional contextual information. Multi-Level Skills Design Outperform Other Forms of Experience Representation. When the experience extraction model is aligned with the execution model, SkillXconsistently outperforms all baseline methods, as indicated by the methods with∗in Table 1. Among them, ExpeL retrieves past trajectories and uses them as few-shot demonstrations, which provides a more direct performance gain than the other baselines. However, the agent capabil- ity required for multi-level skill decoupling offers a more advantageous form of experience representation. Suboptimal Experience Representations Hinder Trans- fer Performance. We further evaluate the GLM-4.6 ex- tracted experience with AWM and ExpeL on the weaker models, see the results of methods with‡in Table 1. How- ever, the performance still lagged behind that ofSkillX. This indicates that distilling experience from a strong model is effective, but the form of experience represen- tation is even more critical. Consequently, suboptimal experience representation can hinder effective experience transfer. These results further demonstrate the advantage of SkillX in transferring experience across base models. SkillXcan Expand Base Model’s Capability Boundary. We observe that experience-based learning leads to substan- tial Pass@4 improvements for the weaker models, K2 and Qwen3-32B. This suggests that, in practice, the most direct way to extend the capability boundary of a base model is to distill knowledge from a stronger model (Yue et al., 2025). In contrast, for the stronger model GLM-4.6, neither the baseline norSkillXyields a significant gain in Pass@4. This indicates that stronger models already possess robust capabilities in exploration, planning, and tool use, leav- ing limited headroom for further capability expansion via experience-based augmentation. Nevertheless, the modest improvements still support the effectiveness of SkillX. 6 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Figure 3. Comprehensive Analysis ofSkillX. (a) Performance of Multi-skills: Models exhibit varying performance under different skill composition. (b) Execution efficiency of Multi-skills: Jointly composing all skills yields the best execution efficiency. (c) Iterative optimization: Iterative skill refinement further improves performance. (d) Skill expansion strategies: Experience-guided expansion achieves the best on scalability and performance gains. (e) Analysis of Input tokens: Properly balancing input tokens is crucial for controlling inference cost. (f) Analysis of Execution steps: Experience-based learning reduces the number of execution steps. 5.3. Analysis Which skill is more effective?We analyze the behaviors of our multi-level skill across models on AppWorld, and the results are shown in Figure 3 (a) and Figure 3 (b). (i) Planning skills consistently reduce the number of execu- tion steps across all models, with particularly pronounced gains for weaker models such as Qwen3-32B and K2, espe- cially when combined with Functional Skills. We attribute this to their limited exploration capability in complex en- vironments. Notably, for Qwen3-32B, adding Functional and Atomic Skills can even hurt performance, as the model tends to over-imitate retrieved skills rather than adapt them to novel tasks. For stronger models, pseudo-planning may fail to faithfully capture underlying environment dynamics in complex scenarios, and can therefore become counterpro- ductive. (i) Functional skills contribute the most to overall performance improvements: equipping K2 and GLM-4.6 with Functional and Atomic Skills alone already yields ob- servable gains, highlighting the advantage of skills as an effective representation of experience. (i) Atomic skills provide crucial clarifications for key APIs. When they are absent, performance drops substantially, further validating the need to supplement tool schemas and to cover tools miss- ing from Functional Skills. Finally, we find that GLM-4.6 benefits the most from using all skill types; K2 performs best with Functional + Atomic Skills; and Qwen3-32B achieves its best performance when only Planning Skills are enabled. This further demonstrates that multi-level skills can compre- hensively cover the capabilities required for diverse models to execute agent tasks. Iterative Refinement Strategies Further Enhances SkillXPerformance. We evaluate effectiveness of multi-round iterative refinement for the skill library of SkillXon AppWorld (Figure 3 (c)). Overall, multiple iterations further improve performance on both training and test sets. Leveraging existing training data, the process continually improves various aspects of skills, such as doc- umentation and content. Besides, it can slightly expand the size of the skill library ( Figure 3 (d)). However, when training data are limited, text-only optimization can lead to overfitting. Thus, selecting an appropriate number of update rounds is crucial to obtain a higher-quality skill library. Skill Expansion Strategies Improve Generalization. We compare two skill expansion strategies: random ex- ploration and experience-guided expansion. The results are as shown in Figure 3 (d). In terms of skill growth, the experience-guided strategy yields substantially more novel skills, as random exploration treats past executions in iso- lation and repeatedly rediscovers already identified skills. Empirically, the experience guided strategy yields perfor- mance improvement through skill expansion. Overall, our results indicate that in complex environments, particularly under scarce training data, skill expansion is a crucial com- ponent of experience learning. 7 SkillX: Automatically Constructing Skill Knowledge Bases for Agents SkillXEnhances Agent Execution Efficiency. Learn- ing from experience not only improves the performance of the base model, but also enhances the execution efficiency of the agent. Our experiments further corroborate this ef- fect (see Figure 3 (e) and Figure 3 (f)). Although we do not achieve the minimum number of execution steps or the fewest input tokens, we obtain the best overall performance (see Table 1). These results further highlight the advantages of our multi-level skill design and skills library construction. 6. Further Analysis 6.1. Evaluating SkillX Across Other Base Models We further evaluateSkillXon stronger base models, in- cluding DeepSeek-V3.2 and GPT-4.1, which are at least comparable to, and in some cases stronger than GLM- 4.6. We find thatSkillXprovides consistent performance gains, whether the skills are extracted by these stronger models themselves or constructed using GLM-4.6. Methods BFCL-v3Appworld Avg@4 Pass@4Avg@4 Pass@4 DeepSeek-V3.2 No Memory64.3381.3361.9084.08 SkillX GLM-Extract67.1783.3364.2886.90 Self-Extract67.8384.6765.4888.39 GPT-4.1 No Memory49.6658.3966.3782.74 SkillX GLM-Extract60.0069.3366.8284.52 Self-Extract50.6756.6768.6082.14 Table 2. Performance of SkillX on other base models. 6.2. Ablation Study on Three Components of SkillX We conduct ablation studies on the three key components ofSkillX, i.e., multi-level skills design, skills refinement, and skills expansion, as shown in Table 3. The results in Table 3 suggest thatSkillXis robust to its underlying experience representation, while iterative refinement and skill expansion can offer further improvements depending on the model and the particular combination of components. Please note that we do not perform ablations of skills itera- tion and skills expansion onτ 2 -Bench. This is becauseτ 2 - Bench is a user-interactive benchmark whose tool schemas are relatively simple in both number and dependency struc- ture, and its training set already covers many task patterns directly. More broadly, for user-centric benchmarks of this type (e.g., dialogue benchmarks), it remains an open question whether experience learning centered around tool- schema-based skills is the most appropriate formulation. Therefore, we believe that component studies on skill itera- tion and skill expansion are less suitable forτ 2 -Bench, and we do not include them in our ablation experiments. ModelMethods BFCL-V3AppWorld Avg@4Pass@4Avg@4Pass@4 GLM-4.6 No Memory76.6783.3360.2783.33 Vanilla-Iter178.5085.3362.3583.33 Vanilla-Iter279.5086.0064.2985.12 Vanilla-Iter378.8384.6761.4685.71 Expand-Iter178.5085.3364.5883.93 Expand-Iter278.8385.3364.8887.50 Expand-Iter378.8384.6764.8888.69 Table 3. Ablation results ofSkillXon three components. Specifically,Vanilla-Iter1uses only the multi-level skills design; Vanilla-Iter2andVanilla-Iter3additionally incorporate skills re- finement;Expand-Iter1uses the multi-level skills design together with skills expansion;Expand-Iter2andExpand-Iter3combine multi-level skills design, skills refinement, and skills expansion. 6.3. Case Study We also provide qualitative cases to illustrate how agents leverageSkillXand how retrieved skills shape their be- havior when solving unseen tasks. Detailed cases are pre- sented in Appendix B. These cases show that skill libraries help agents avoid common failures such as incorrect API call sequences, missing prerequisite checks, and the inabil- ity to handle conversational topic shifts. By framing domain knowledge as reusable skills, agents can complete complex multi-step tasks that the baseline method fails, reducing trial and error from multiple failed attempts to successful execution on the first attempt. 7. Related Work Encoding For Agent Experience. With the advent of the experience era (Sutton, 2025), agents can achieve self- evolving (Gao et al., 2025; Fang et al., 2025b; Xia et al., 2026) by encoding past experience and reusing it in con- text (Dou et al., 2026) to guide future behavior. Existing approaches to text token-level experience encoding (Zhang et al., 2025b; Hu et al., 2025) can be broadly grouped into three categories: (i) Case-based Experience: Agents directly store successful task-execution trajectories and retrieve them later as few-shot examples to new problem solving (Zhao et al., 2024; Zheng et al., 2024; Zhou et al., 2025). (i) Strategy-based Experience: By summarizing and contrast- ing successful versus failed trajectories, agents distill higher- level insights or workflows (Cao et al., 2025; Ouyang et al., 2025; Cai et al., 2025a; Wang et al., 2025c; Tang et al., 2025; Zhang et al., 2025a). (i) Skill-based Experience: Trajec- tories are segmented and distilled into modular, reusable skills, such as textual skills or programmatic skills (Wang et al., 2025b;a; 2024; Fang et al., 2025c; Han et al., 2025; 8 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Chen et al., 2026; Zheng et al., 2026; Wang et al., 2026a; Zhou et al., 2026a; Zhang et al., 2026b; Ni et al., 2026; Zhou et al., 2026b). However, it remains unclear which unified experience representation is both easily pluggable and consistently effective, especially in diverse and complex agentic tool-use scenarios (Trivedi et al., 2024; Yao et al., 2024; Patil et al., 2025; Barres et al., 2025; He et al., 2025; Li et al., 2025; Zheng et al., 2025; Jiang et al., 2026; Xing et al., 2026; Li, 2026; Li et al., 2026). In this work, we adopt a hybrid representation, high-level planning coupled with textual skills, which yields substantial improvements for the base model. Agent Experience Knowledge Base Construction.The construction pipeline of an experience knowledge base typi- cally consists of two steps: static construction and dynamic updating. (i) Static construction repeatedly attempts tasks on a training set or human-curated information sources, ex- tracts experience, and iteratively refines it until performance plateaus (Zhang et al., 2025c; Cai et al., 2025b; Anthropic, 2025; Wang et al., 2026b; Gallego, 2026; Yang et al., 2026a). (i) Dynamic updating updates the ExperienceKB immedi- ately after executing new tasks, enabling experience reuse in subsequent tasks (Latimer et al., 2025; Fang et al., 2025a; Cao et al., 2025; Du et al., 2025; Yang et al., 2026b; Yao et al., 2025; Zhang et al., 2026a; Liang et al., 2026). While dynamic updating is central to continual learning from experience, pre-building a strong static ExperienceKB remains necessary in practice. However, under the task- scarcity challenge in complex agent settings (Patil et al., 2025; Barres et al., 2025; He et al., 2025; Li et al., 2025), we further extend skills by combining task synthesis (Zhai et al., 2025; Mai et al., 2025; Shi et al., 2025; Ramrakhya et al., 2025; Guo et al., 2025) to construct more challenging tasks. To our knowledge, this is the first work to provide a directly reusable skill knowledge base together with an automated pipeline for skill construction. 8. Conclusion We introducedSkillX, an automated framework for build- ing a plug-and-play skill library for LLM-based agents. To enable more efficient experience transfer, we design a multi-level skills, including planning skills, functional skills, and atomic skills from the perspective of tool granularity. SkillXiteratively refines and expands the library through three core components: i) skills extraction, which rolls out an agent with the current library and extracts multi-level skills; i) skills refinement, which iteratively improves skills using execution feedback, while maintaining quality via skill merging and strict filtering; and i) exploratory skills expansion, which proactively broadens coverage beyond the seed training set. Our experiments demonstrate that SkillXtransfers effectively to other models and provides advantages in experience representation. Finally, we will re- lease the optimized skill library constructed bySkillXto facilitate further community exploration. Impact Statements This work advances generalizable agent learning by trans- forming isolated trial-and-error experience into a reusable, structured skill knowledge base that can be shared across agents and environments. By enabling weaker agents to benefit from skills distilled by stronger ones, the proposed framework reduces redundant exploration, improves sample efficiency, and lowers the computational and environmental costs of training LLM agents. The plug-and-play design pro- motes modularity and reproducibility, supporting broader adoption in long-horizon, user-interactive applications. Po- tential risks include over-reliance on pre-built skills and the propagation of biases present in source agents; however, the automated refinement and expansion mechanisms provide a pathway to mitigate stagnation and encourage continual adaptation. Limitations Cross-environment transfer.SkillXis currently most nat- urally applicable when skills can be grounded in a relatively stable tool environment. The extracted skills are associ- ated with specific tool schemas, which makes direct reuse across substantially different domains or tool ecosystems less straightforward. User-interactive settings. The current study focuses mainly on tool-using agent environments. More user interactive scenarios, particularly dialogue scenarios without function calls, are not yet the primary focus of this work. Acknowledgement This work was supported by the Yongjiang Talent Introduc- tion Programme (2021A-156-G), the Ant Group through CCF-Ant Research Fund (CCF-AFSG RF20250515), and Information Technology Center and State Key Lab of CAD&CG, Zhejiang University. This work was supported by Ant Group and Zhejiang University - Ant Group Joint Laboratory of Knowledge Graph. References Anthropic.skills.https://github.com/anthropics/skills, 2025. URLhttps://github.com/anthropics/ skills. GitHub repository. Barres, V., Dong, H., Ray, S., Si, X., and Narasimhan, K. τ 2 -bench: Evaluating conversational agents in a dual- control environment, 2025. URLhttps://arxiv. 9 SkillX: Automatically Constructing Skill Knowledge Bases for Agents org/abs/2506.07982. Cai, Y., Cai, S., Shi, Y., Xu, Z., Chen, L., Qin, Y., Tan, X., Li, G., Li, Z., Lin, H., Mao, Y., Li, K., and Sun, X.Training-free group relative policy optimization. CoRR, abs/2510.08191, 2025a. doi: 10.48550/ARXIV. 2510.08191. URL https://doi.org/10.48550/ arXiv.2510.08191. Cai, Z., Guo, X., Pei, Y., Feng, J., Chen, J., Zhang, Y., Ma, W., Wang, M., and Zhou, H. FLEX: continuous agent evolution via forward learning from experience. CoRR, abs/2511.06449, 2025b. doi: 10.48550/ARXIV. 2511.06449. URL https://doi.org/10.48550/ arXiv.2511.06449. Cao, Z., Deng, J., Yu, L., Zhou, W., Liu, Z., Ding, B., and Zhao, H. Remember me, refine me: A dynamic pro- cedural memory framework for experience-driven agent evolution, 2025. URLhttps://arxiv.org/abs/ 2512.10696. Chen, T., Li, Y., Solodko, M., Wang, S., Jiang, N., Cui, T., Hao, J., Ko, J., Abdali, S., Xu, L., Zheng, S., Fan, H., Cameron, P., Wagle, J., and Koishida, K. Cua-skill: Develop skills for computer using agent, 2026. URL https://arxiv.org/abs/2601.21123. DeepSeek-AI. Deepseek-v3.2: Pushing the frontier of open large language models. CoRR, abs/2512.02556, 2025. doi: 10.48550/ARXIV.2512.02556. URLhttps:// doi.org/10.48550/arXiv.2512.02556. Dou, S., Zhang, M., Yin, Z., Huang, C., Shen, Y., Wang, J., Chen, J., Ni, Y., Ye, J., Zhang, C., Xie, H., Hu, J., Wang, S., Wang, W., Xiao, Y., Liu, Y., Xu, Z., Guo, Z., Zhou, P., Gui, T., Wu, Z., Qiu, X., Zhang, Q., Huang, X., Jiang, Y.-G., Wang, D., and Yao, S. Cl-bench: A benchmark for context learning, 2026. URLhttps: //arxiv.org/abs/2602.03587. Du, X., Li, L., Zhang, D., and Song, L. Memr 3 : Memory retrieval via reflective reasoning for llm agents, 2025. URL https://arxiv.org/abs/2512.20237. Fang, J., Deng, X., Xu, H., Jiang, Z., Tang, Y., Xu, Z., Deng, S., Yao, Y., Wang, M., Qiao, S., Chen, H., and Zhang, N. Lightmem: Lightweight and efficient memory- augmented generation, 2025a. URLhttps://arxiv. org/abs/2510.18866. Fang, J., Peng, Y., Zhang, X., Wang, Y., Yi, X., Zhang, G., Xu, Y., Wu, B., Liu, S., Li, Z., Ren, Z., Aletras, N., Wang, X., Zhou, H., and Meng, Z. A comprehen- sive survey of self-evolving AI agents: A new paradigm bridging foundation models and lifelong agentic systems. CoRR, abs/2508.07407, 2025b. doi: 10.48550/ARXIV. 2508.07407. URL https://doi.org/10.48550/ arXiv.2508.07407. Fang, R., Liang, Y., Wang, X., Wu, J., Qiao, S., Xie, P., Huang, F., Chen, H., and Zhang, N. Memp: Exploring agent procedural memory. CoRR, abs/2508.06433, 2025c. doi: 10.48550/ARXIV.2508.06433. URLhttps:// doi.org/10.48550/arXiv.2508.06433. Gallego, V. Distilling feedback into memory-as-a-tool, 2026. URL https://arxiv.org/abs/2601.05960. Gao, H., Geng, J., Hua, W., Hu, M., Juan, X., Liu, H., Liu, S., Qiu, J., Qi, X., Wu, Y., Wang, H., Xiao, H., Zhou, Y., Zhang, S., Zhang, J., Xiang, J., Fang, Y., Zhao, Q., Liu, D., Ren, Q., Qian, C., Wang, Z., Hu, M., Wang, H., Wu, Q., Ji, H., and Wang, M. A survey of self- evolving agents: On path to artificial super intelligence. CoRR, abs/2507.21046, 2025. doi: 10.48550/ARXIV. 2507.21046. URL https://doi.org/10.48550/ arXiv.2507.21046. Gao, L., Ma, X., Lin, J., and Callan, J. Precise zero-shot dense retrieval without relevance labels, 2022. URL https://arxiv.org/abs/2212.10496. Guo, J., Yang, L., Chen, P., Xiao, Q., Wang, Y., Juan, X., Qiu, J., Shen, K., and Wang, M. Genenv: Difficulty- aligned co-evolution between llm agents and environment simulators, 2025. URLhttps://arxiv.org/abs/ 2512.19682. Han, D., Couturier, C., D ́ ıaz, D. M., Zhang, X., R ̈ uhle, V., and Rajmohan, S. Legomem: Modular procedu- ral memory for multi-agent LLM systems for work- flow automation. CoRR, abs/2510.04851, 2025. doi: 10.48550/ARXIV.2510.04851. URLhttps://doi. org/10.48550/arXiv.2510.04851. He, W., Sun, Y., Hao, H., Hao, X., Xia, Z., Gu, Q., Han, C., Zhao, D., Su, H., Zhang, K., Gao, M., Su, X., Cai, X., Cai, X., Yang, Y., and Zhao, Y. Vitabench: Benchmarking llm agents with versatile interactive tasks in real-world ap- plications, 2025. URLhttps://arxiv.org/abs/ 2509.26490. Hu, Y., Liu, S., Yue, Y., Zhang, G., Liu, B., Zhu, F., Lin, J., Guo, H., Dou, S., Xi, Z., Jin, S., Tan, J., Yin, Y., Liu, J., Zhang, Z., Sun, Z., Zhu, Y., Sun, H., Peng, B., Cheng, Z., Fan, X., Guo, J., Yu, X., Zhou, Z., Hu, Z., Huo, J., Wang, J., Niu, Y., Wang, Y., Yin, Z., Hu, X., Liao, Y., Li, Q., Wang, K., Zhou, W., Liu, Y., Cheng, D., Zhang, Q., Gui, T., Pan, S., Zhang, Y., Torr, P., Dou, Z., Wen, J.-R., Huang, X., Jiang, Y.-G., and Yan, S. Memory in the age of ai agents, 2025. URLhttps://arxiv.org/ abs/2512.13564. 10 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Jiang, G., Su, Z., Qu, X., and Fung, Y. R. Xskill: Contin- ual learning from experience and skills in multimodal agents, 2026.URLhttps://arxiv.org/abs/ 2603.12056. Latimer, C., Boschi, N., Neeser, A., Bartholomew, C., Sri- vastava, G., Wang, X., and Ramakrishnan, N. Hind- sight is 20/20: Building agent memory that retains, re- calls, and reflects, 2025. URLhttps://arxiv.org/ abs/2512.12818. Li, J., Zhao, W., Zhao, J., Zeng, W., Wu, H., Wang, X., Ge, R., Cao, Y., Huang, Y., Liu, W., Liu, J., Su, Z., Guo, Y., Zhou, F., Zhang, L., Michelini, J., Wang, X., Yue, X., Zhou, S., Neubig, G., and He, J. The tool decathlon: Benchmarking language agents for diverse, realistic, and long-horizon task execution, 2025. URLhttps:// arxiv.org/abs/2510.25726. Li, X. When single-agent with skills replace multi-agent systems and when they fail. CoRR, abs/2601.04748, 2026. doi: 10.48550/ARXIV.2601.04748. URLhttps:// doi.org/10.48550/arXiv.2601.04748. Li, X., Chen, W., Liu, Y., Zheng, S., Chen, X., He, Y., Li, Y., You, B., Shen, H., Sun, J., Wang, S., Zeng, Q., Wang, D., Zhao, X., Wang, Y., Chaim, R. B., Di, Z., Gao, Y., He, J., He, Y., Jing, L., Kong, L., Lan, X., Li, J., Li, S., Li, Y., Lin, Y., Liu, X., Liu, X., Lyu, H., Ma, Z., Wang, B., Wang, R., Wang, T., Ye, W., Zhang, Y., Xing, H., Xue, Y., Dillmann, S., and Lee, H. Skillsbench: Benchmarking how well agent skills work across diverse tasks. CoRR, abs/2602.12670, 2026. doi: 10.48550/ ARXIV.2602.12670. URLhttps://doi.org/10. 48550/arXiv.2602.12670. Liang, Y., Zhong, R., Xu, H., Jiang, C., Zhong, Y., Fang, R., Gu, J.-C., Deng, S., Yao, Y., Wang, M., Qiao, S., Xu, X., Wu, T., Wang, K., Liu, Y., Bi, Z., Lou, J., Jiang, Y. E., Zhu, H., Yu, G., Hong, H., Huang, L., Xue, H., Wang, C., Wang, Y., Shan, Z., Chen, X., Tu, Z., Xiong, F., Xie, X., Zhang, P., Gui, Z., Liang, L., Zhou, J., Wu, C., Shang, J., Gong, Y., unyu Lin, Xu, C., Deng, H., Zhang, W., Ding, K., Zhang, Q., Huang, F., Zhang, N., Pan, J. Z., Qi, G., Wang, H., and Chen, H. Skillnet: Create, evaluate, and connect ai skills, 2026. URL https://arxiv.org/ abs/2603.04448. Liu, Z., Cai, Y., Zhu, X., Zheng, Y., Chen, R., Wen, Y., Wang, Y., E, W., and Chen, S. Ml-master: Towards ai-for-ai via integration of exploration and reasoning. CoRR, abs/2506.16499, 2025. doi: 10.48550/ARXIV. 2506.16499. URL https://doi.org/10.48550/ arXiv.2506.16499. Mai, S., Zhai, Y., Chen, Z., Chen, C., Zou, A., Tao, S., Liu, Z., and Ding, B. Cues: A curiosity-driven and environment-grounded synthesis framework for agentic rl, December 2025. URLhttps://arxiv.org/abs/ 2512.01311. Mialon, G., Fourrier, C., Swift, C., Wolf, T., LeCun, Y., and Scialom, T. Gaia: a benchmark for general ai as- sistants, 2023. URLhttps://arxiv.org/abs/ 2311.12983. Ni, J., Liu, Y., Liu, X., Sun, Y., Zhou, M., Cheng, P., Wang, D., Zhao, E., Jiang, X., and Jiang, G. Trace2skill: Distill trajectory-local lessons into transferable agent skills, 2026.URLhttps://arxiv.org/abs/ 2603.25158. Novikov, A., Vu, N., Eisenberger, M., Dupont, E., Huang, P., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J. R., Mehrabian, A., Kumar, M. P., See, A., Chaudhuri, S., Holland, G., Davies, A., Nowozin, S., Kohli, P., and Balog, M. Alphaevolve: A coding agent for scientific and algorithmic discovery. CoRR, abs/2506.13131, 2025. doi: 10.48550/ARXIV.2506.13131. URLhttps:// doi.org/10.48550/arXiv.2506.13131. OpenAI. System Card for o3-mini, 2025. URLhttps:// openai.com/index/o3-mini-system-card/. Accessed on December 11, 2025. Ou, Y., Luo, Y., Zheng, J., Wei, L., Qiao, S., Zhang, J., Zheng, D., Chen, H., and Zhang, N. Automind: Adap- tive knowledgeable agent for automated data science. CoRR, abs/2506.10974, 2025. doi: 10.48550/ARXIV. 2506.10974. URL https://doi.org/10.48550/ arXiv.2506.10974. Ouyang, S., Yan, J., Hsu, I., Chen, Y., Jiang, K., Wang, Z., Han, R., Le, L. T., Daruki, S., Tang, X., Tirumalashetty, V., Lee, G., Rofouei, M., Lin, H., Han, J., Lee, C., and Pfister, T. Reasoningbank: Scaling agent self-evolving with reasoning memory. CoRR, abs/2509.25140, 2025. doi: 10.48550/ARXIV.2509.25140. URLhttps:// doi.org/10.48550/arXiv.2509.25140. Patil, S. G., Mao, H., Cheng-Jie Ji, C., Yan, F., Suresh, V., Stoica, I., and E. Gonzalez, J. The berkeley func- tion calling leaderboard (bfcl): From tool use to agentic evaluation of large language models. In Forty-second International Conference on Machine Learning, 2025. Qiao, S., Zhao, Y., Qiu, Z., Wang, X., Zhang, J., Bin, Z., Zhang, N., Jiang, Y., Xie, P., Huang, F., and Chen, H. Scaling generalist data-analytic agents. CoRR, abs/2509.25084, 2025. doi: 10.48550/ARXIV. 2509.25084. URL https://doi.org/10.48550/ arXiv.2509.25084. 11 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Ramrakhya, R., Szot, A., Attia, O., Yang, Y., Nguyen, A., Mazoure, B., Gan, Z., Agrawal, H., and Toshev, A. Scal- ing synthetic task generation for agents via exploration. CoRR, abs/2509.25047, 2025. doi: 10.48550/ARXIV. 2509.25047. URL https://doi.org/10.48550/ arXiv.2509.25047. Shi, D., Cao, J., Chen, Q., Sun, W., Li, W., Lu, H., Dong, F., Qin, T., Zhu, K., Liu, M., Yang, J., Zhang, G., Liu, J., Zhang, C., Wang, J., Jiang, Y. E., and Zhou, W. Taskcraft: Automated generation of agentic tasks. CoRR, abs/2506.10055, 2025. doi: 10.48550/ARXIV. 2506.10055. URL https://doi.org/10.48550/ arXiv.2506.10055. Sutton, Richard S., D. S. Welcome to the Era of Experience, April 2025. Tang, X., Qin, T., Peng, T., Zhou, Z., Shao, D., Du, T., Wei, X., Xia, P., Wu, F., Zhu, H., et al. Agent kb: Leveraging cross-domain experience for agentic problem solving. arXiv preprint arXiv:2507.06229, 2025. URLhttps: //arXiv.org/abs/2507.06229. Team, ., Zeng, A., Lv, X., Zheng, Q., Hou, Z., Chen, B., Xie, C., Wang, C., Yin, D., Zeng, H., Zhang, J., Wang, K., Zhong, L., Liu, M., Lu, R., Cao, S., Zhang, X., Huang, X., Wei, Y., Cheng, Y., An, Y., Niu, Y., Wen, Y., Bai, Y., Du, Z., Wang, Z., Zhu, Z., Zhang, B., Wen, B., Wu, B., Xu, B., Huang, C., Zhao, C., Cai, C., Yu, C., Li, C., Ge, C., Huang, C., Zhang, C., Xu, C., Zhu, C., Li, C., Yin, C., Lin, D., Yang, D., Jiang, D., Ai, D., Zhu, E., Wang, F., Pan, G., Wang, G., Sun, H., Li, H., Li, H., Hu, H., Zhang, H., Peng, H., Tai, H., Zhang, H., Wang, H., Yang, H., Liu, H., Zhao, H., Liu, H., Yan, H., Liu, H., Chen, H., Li, J., Zhao, J., Ren, J., Jiao, J., Zhao, J., Yan, J., Wang, J., Gui, J., Zhao, J., Liu, J., Li, J., Li, J., Lu, J., Wang, J., Yuan, J., Li, J., Du, J., Du, J., Liu, J., Zhi, J., Gao, J., Wang, K., Yang, L., Xu, L., Fan, L., Wu, L., Ding, L., Wang, L., Zhang, M., Li, M., Xu, M., Zhao, M., Zhai, M., Du, P., Dong, Q., Lei, S., Tu, S., Yang, S., Lu, S., Li, S., Li, S., Shuang-Li, Yang, S., Yi, S., Yu, T., Tian, W., Wang, W., Yu, W., Tam, W. L., Liang, W., Liu, W., Wang, X., Jia, X., Gu, X., Ling, X., Wang, X., Fan, X., Pan, X., Zhang, X., Zhang, X., Fu, X., Zhang, X., Xu, Y., Wu, Y., Lu, Y., Wang, Y., Zhou, Y., Pan, Y., Zhang, Y., Wang, Y., Li, Y., Su, Y., Geng, Y., Zhu, Y., Yang, Y., Li, Y., Wu, Y., Li, Y., Liu, Y., Wang, Y., Li, Y., Zhang, Y., Liu, Z., Yang, Z., Zhou, Z., Qiao, Z., Feng, Z., Liu, Z., Zhang, Z., Wang, Z., Yao, Z., Wang, Z., Liu, Z., Chai, Z., Li, Z., Zhao, Z., Chen, W., Zhai, J., Xu, B., Huang, M., Wang, H., Li, J., Dong, Y., and Tang, J. Glm-4.5: Agentic, reasoning, and coding (arc) foundation models, 2025a. URL https://arxiv.org/abs/2508.06471. Team, K., Bai, Y., Bao, Y., Chen, G., Chen, J., Chen, N., Chen, R., Chen, Y., Chen, Y., Chen, Y., Chen, Z., Cui, J., Ding, H., Dong, M., Du, A., Du, C., Du, D., Du, Y., Fan, Y., Feng, Y., Fu, K., Gao, B., Gao, H., Gao, P., Gao, T., Gu, X., Guan, L., Guo, H., Guo, J., Hu, H., Hao, X., He, T., He, W., He, W., Hong, C., Hu, Y., Hu, Z., Huang, W., Huang, Z., Huang, Z., Jiang, T., Jiang, Z., Jin, X., Kang, Y., Lai, G., Li, C., Li, F., Li, H., Li, M., Li, W., Li, Y., Li, Y., Li, Z., Li, Z., Lin, H., Lin, X., Lin, Z., Liu, C., Liu, C., Liu, H., Liu, J., Liu, J., Liu, L., Liu, S., Liu, T. Y., Liu, T., Liu, W., Liu, Y., Liu, Y., Liu, Y., Liu, Y., Liu, Z., Lu, E., Lu, L., Ma, S., Ma, X., Ma, Y., Mao, S., Mei, J., Men, X., Miao, Y., Pan, S., Peng, Y., Qin, R., Qu, B., Shang, Z., Shi, L., Shi, S., Song, F., Su, J., Su, Z., Sun, X., Sung, F., Tang, H., Tao, J., Teng, Q., Wang, C., Wang, D., Wang, F., Wang, H., Wang, J., Wang, J., Wang, J., Wang, S., Wang, S., Wang, Y., Wang, Y., Wang, Y., Wang, Y., Wang, Y., Wang, Z., Wang, Z., Wang, Z., Wei, C., Wei, Q., Wu, W., Wu, X., Wu, Y., Xiao, C., Xie, X., Xiong, W., Xu, B., Xu, J., Xu, J., Xu, L. H., Xu, L., Xu, S., Xu, W., Xu, X., Xu, Y., Xu, Z., Yan, J., Yan, Y., Yang, X., Yang, Y., Yang, Z., Yang, Z., Yang, Z., Yao, H., Yao, X., Ye, W., Ye, Z., Yin, B., Yu, L., Yuan, E., Yuan, H., Yuan, M., Zhan, H., Zhang, D., Zhang, H., Zhang, W., Zhang, X., Zhang, Y., Zhang, Y., Zhang, Y., Zhang, Y., Zhang, Y., Zhang, Y., Zhang, Z., Zhao, H., Zhao, Y., Zheng, H., Zheng, S., Zhou, J., Zhou, X., Zhou, Z., Zhu, Z., Zhuang, W., and Zu, X. Kimi k2: Open agentic intelligence, 2025b. URL https://arxiv.org/abs/2507.20534. Trivedi, H., Khot, T., Hartmann, M., Manku, R., Dong, V., Li, E., Gupta, S., Sabharwal, A., and Balasubramanian, N. Appworld: A controllable world of apps and people for benchmarking interactive coding agents. In Ku, L., Mar- tins, A., and Srikumar, V. (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Lin- guistics (Volume 1: Long Papers), ACL 2024, Bangkok, Thailand, August 11-16, 2024, p. 16022–16076. As- sociation for Computational Linguistics, 2024. doi: 10. 18653/V1/2024.ACL-LONG.850. URLhttps://doi. org/10.18653/v1/2024.acl-long.850. Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., and Anandkumar, A. Voyager: An open-ended embodied agent with large language models. Trans. Mach. Learn. Res., 2024, 2024. URLhttps: //openreview.net/forum?id=ehfRiF0R3a. Wang, J., Yan, Q., Wang, Y., Tian, Y., Mishra, S. S., Xu, Z., Gandhi, M., Xu, P., and Cheong, L. L. Reinforce- ment learning for self-improving agent with skill library. CoRR, abs/2512.17102, 2025a. doi: 10.48550/ARXIV. 2512.17102. URL https://doi.org/10.48550/ arXiv.2512.17102. Wang, J., Ming, Y., Ke, Z., Joty, S., Albarghouthi, A., and Sala, F. Skillorchestra: Learning to route agents via skill 12 SkillX: Automatically Constructing Skill Knowledge Bases for Agents transfer. CoRR, abs/2602.19672, 2026a. doi: 10.48550/ ARXIV.2602.19672. URLhttps://doi.org/10. 48550/arXiv.2602.19672. Wang, Q., Cheng, Z., Zhang, S., Liu, F., Xu, R., Lian, H., Wang, K., Yu, X., Yin, J., Hu, S., Hu, Y., Zhang, S., Liu, Y., Chen, R., and Wang, H. Memgovern: Enhancing code agents through learning from governed human ex- periences, 2026b. URLhttps://arxiv.org/abs/ 2601.06789. Wang, Z. Z., Gandhi, A., Neubig, G., and Fried, D.Inducing programmatic skills for agentic tasks. CoRR, abs/2504.06821, 2025b. doi: 10.48550/ARXIV. 2504.06821. URL https://doi.org/10.48550/ arXiv.2504.06821. Wang, Z. Z., Mao, J., Fried, D., and Neubig, G. Agent workflow memory. In Forty-second International Con- ference on Machine Learning, ICML 2025, Vancou- ver, BC, Canada, July 13-19, 2025. OpenReview.net, 2025c. URLhttps://openreview.net/forum? id=NTAhi2JEEE. Xia, P., Chen, J., Yang, X., Tu, H., Liu, J., Xiong, K., Han, S., Qiu, S., Ji, H., Zhou, Y., Zheng, Z., Xie, C., and Yao, H. Metaclaw: Just talk – an agent that meta-learns and evolves in the wild, 2026. URLhttps://arxiv. org/abs/2603.17187. Xing, H., Zhuang, H., Zhao, X., Huang, Y., Tang, Z., and Zhang, X. Recipes for agents: Understanding skills and their open questions. Preprint, ResearchGate. doi, 10, 2026. Xu, W., Liang, Z., Mei, K., Gao, H., Tan, J., and Zhang, Y. A-mem: Agentic memory for llm agents, 2025. URL https://arxiv.org/abs/2502.12110. Yang, A., Li, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Gao, C., Huang, C., Lv, C., Zheng, C., Liu, D., Zhou, F., Huang, F., Hu, F., Ge, H., Wei, H., Lin, H., Tang, J., Yang, J., Tu, J., Zhang, J., Yang, J., Yang, J., Zhou, J., Zhou, J., Lin, J., Dang, K., Bao, K., Yang, K., Yu, L., Deng, L., Li, M., Xue, M., Li, M., Zhang, P., Wang, P., Zhu, Q., Men, R., Gao, R., Liu, S., Luo, S., Li, T., Tang, T., Yin, W., Ren, X., Wang, X., Zhang, X., Ren, X., Fan, Y., Su, Y., Zhang, Y., Zhang, Y., Wan, Y., Liu, Y., Wang, Z., Cui, Z., Zhang, Z., Zhou, Z., and Qiu, Z. Qwen3 technical report, 2025. URLhttps: //arxiv.org/abs/2505.09388. Yang, C., Sun, Z., Wei, W., and Hu, W. Beyond static summarization: Proactive memory extraction for llm agents, 2026a. URLhttps://arxiv.org/abs/ 2601.04463. Yang, Y., Li, J., Pan, Q., Zhan, B., Cai, Y., Du, L., Zhou, J., Chen, K., Chen, Q., Li, X., Zhang, B., and He, L. Autoskill: Experience-driven lifelong learning via skill self-evolution, 2026b. URLhttps://arxiv.org/ abs/2603.01145. Yao, S., Chen, H., Yang, J., and Narasimhan, K. Web- shop: Towards scalable real-world web interaction with grounded language agents, 2023.URLhttps:// arxiv.org/abs/2207.01206. Yao, S., Shinn, N., Razavi, P., and Narasimhan, K.τ-bench: A benchmark for tool-agent-user interaction in real-world domains, 2024. URLhttps://arxiv.org/abs/ 2406.12045. Yao, Y., Qin, J., Zhang, N., Xu, H., Zhu, Y., Yu, Z., Wang, M., Tang, Y., Gu, J.-C., Deng, S., Peng, N., and Chen, H. Rethinking knowledge editing in reasoning era. Au- thorea Preprints, 2025. URLhttps://doi.org/10. 36227/techrxiv.176240454.46531513/v1. Yue, Y., Chen, Z., Lu, R., Zhao, A., Wang, Z., Yue, Y., Song, S., and Huang, G. Does reinforcement learn- ing really incentivize reasoning capacity in llms beyond the base model?, 2025. URL https://arxiv.org/ abs/2504.13837. Yuksekgonul, M., Bianchi, F., Boen, J., Liu, S., Huang, Z., Guestrin, C., and Zou, J. Textgrad: Automatic ”differen- tiation” via text, 2024. URLhttps://arxiv.org/ abs/2406.07496. Zhai, Y., Tao, S., Chen, C., Zou, A., Chen, Z., Fu, Q., Mai, S., Yu, L., Deng, J., Cao, Z., Liu, Z., Ding, B., and Zhou, J. Agentevolver: Towards efficient self-evolving agent sys- tem, 2025. URLhttps://arxiv.org/abs/2511. 10395. Zhang, G., Fu, M., Wan, G., Yu, M., Wang, K., and Yan, S. G-memory: Tracing hierarchical memory for multi-agent systems, 2025a. URLhttps://arxiv.org/abs/ 2506.07398. Zhang, G., Ren, H., Zhan, C., Zhou, Z., Wang, J., Zhu, H., Zhou, W., and Yan, S. Memevolve: Meta-evolution of agent memory systems, 2025b. URLhttps://arxiv. org/abs/2512.18746. Zhang, H., Fan, S., Zou, H. P., Chen, Y., Wang, Z., Zhou, J., Li, C., Huang, W.-C., Yao, Y., Zheng, K., Liu, X., Li, X., and Yu, P. S. Evoskills: Self-evolving agent skills via co-evolutionary verification, 2026a. URLhttps: //arxiv.org/abs/2604.01687. Zhang, H., Long, Q., Bao, J., Feng, T., Zhang, W., Yue, H., and Wang, W. Memskill: Learning and evolving memory skills for self-evolving agents. CoRR, abs/2602.02474, 13 SkillX: Automatically Constructing Skill Knowledge Bases for Agents 2026b. doi: 10.48550/ARXIV.2602.02474. URLhttps: //doi.org/10.48550/arXiv.2602.02474. Zhang, Q., Hu, C., Upasani, S., Ma, B., Hong, F., Kamanuru, V., Rainton, J., Wu, C., Ji, M., Li, H., Thakker, U., Zou, J., and Olukotun, K. Agentic context engineering: Evolv- ing contexts for self-improving language models, 2025c. URL https://arxiv.org/abs/2510.04618. Zhang, Y., Li, M., Long, D., Zhang, X., Lin, H., Yang, B., Xie, P., Yang, A., Liu, D., Lin, J., Huang, F., and Zhou, J. Qwen3 embedding: Advancing text embed- ding and reranking through foundation models. arXiv preprint arXiv:2506.05176, 2025d. URLhttps:// arxiv.org/abs/2506.05176. Zhao, A., Huang, D., Xu, Q., Lin, M., Liu, Y., and Huang, G. Expel: LLM agents are experiential learners. In Wooldridge, M. J., Dy, J. G., and Natarajan, S. (eds.), Thirty-Eighth AAAI Conference on Artificial Intelligence, AAAI 2024, Thirty-Sixth Conference on Innovative Appli- cations of Artificial Intelligence, IAAI 2024, Fourteenth Symposium on Educational Advances in Artificial Intelli- gence, EAAI 2014, February 20-27, 2024, Vancouver, Canada, p. 19632–19642. AAAI Press, 2024. doi: 10.1609/AAAI.V38I17.29936. URLhttps://doi. org/10.1609/aaai.v38i17.29936. Zheng, D., Du, L., Su, J., Tian, Y., Zhu, Y., Zhang, J., Wei, L., Zhang, N., and Chen, H. Knowledge augmented complex problem solving with large language models: A survey. CoRR, abs/2505.03418, 2025. doi: 10.48550/ ARXIV.2505.03418. URLhttps://doi.org/10. 48550/arXiv.2505.03418. Zheng, L., Wang, R., Wang, X., and An, B. Synapse: Trajectory-as-exemplar prompting with memory for com- puter control. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URLhttps: //openreview.net/forum?id=Pc8AU1aF5e. Zheng, Y., Zhang, Z., Ma, C., Yu, Y., Zhu, J., Wu, Y., Xu, T., Dong, B., Zhu, H., Huang, R., and Yu, G. Skillrouter: Skill routing for llm agents at scale, 2026. URLhttps: //arxiv.org/abs/2603.22455. Zhou, H., Chen, Y., Guo, S., Yan, X., Lee, K. H., Wang, Z., Lee, K. Y., Zhang, G., Shao, K., Yang, L., and Wang, J. Memento: Fine-tuning llm agents without fine-tuning llms, 2025. URLhttps://arxiv.org/ abs/2508.16153. Zhou, H., Guo, S., Liu, A., Yu, Z., Gong, Z., Zhao, B., Chen, Z., Zhang, M., Chen, Y., Li, J., Yang, R., Liu, Q., Yu, X., Zhou, J., Wang, N., Sun, C., and Wang, J. Memento-skills: Let agents design agents, 2026a. URL https://arxiv.org/abs/2603.18743. Zhou, S., Xu, F. F., Zhu, H., Zhou, X., Lo, R., Sridhar, A., Cheng, X., Ou, T., Bisk, Y., Fried, D., Alon, U., and Neubig, G. Webarena: A realistic web environment for building autonomous agents, 2024. URLhttps: //arxiv.org/abs/2307.13854. Zhou, T., Liu, D., Yuan, L., Shao, J., and Hu, X.Colleague.skill:Automated ai skill gener- ation via expert knowledge distillation,2026b. URLhttps://github.com/titanwings/ colleague-skill/blob/main/colleague_ skill.pdf. 14 SkillX: Automatically Constructing Skill Knowledge Bases for Agents A. Detailed Experiments Settings A.1. Benchmark Details BFCL-v3 Berkeley Function Calling Leaderboard V3 (BFCL-v3) (Patil et al., 2025) is a benchmark for evaluating function calling and tool use in large language models. It emphasizes multi-turn interaction and multi-step reasoning. The benchmark contains over 1,800 test instances and supports multiple programming languages, including Python, Java, and JavaScript. Models are required to generate valid API calls and handle non-trivial interaction patterns. Evaluation considers both structural validity and functional correctness. We first check whether the generated code is syntactically valid using Abstract Syntax Tree analysis, and then execute it to verify that the outputs match the expected results. A task is considered successful only when the agent produces all required function calls with correct syntax and returns the correct computational outcomes. In this work, we report Avg@4, which measures the average task success rate across four independent trials, and Pass@4, which measures the probability that at least one of the four trials succeeds. Appworld AppWorld (Trivedi et al., 2024) is a benchmark suite for evaluating function calling agents and interactive coding systems in realistic application environments. It simulates an ecosystem of nine widely used applications, such as email services, music streaming platforms, and payment systems, and provides 457 API endpoints together with activity data from around 100 virtual users. Tasks in AppWorld are typically long-horizon and require executing extended sequences of interdependent actions. Many tasks involve discovering appropriate APIs rather than directly reusing familiar patterns, which places additional demands on exploration and planning. The benchmark also exhibits a noticeable distribution gap between training and test sets, where API usage patterns and task structures in the test set differ from those observed during training. In addition, task execution is tightly coupled with the evolving environment state. Intermediate actions modify the system state and influence future decisions, which increases sensitivity to planning errors and makes robust multi-step reasoning more difficult. Evaluation is based on state-driven unit tests that assess task completion from multiple aspects. AppWorld provides both task-level and scenario-level metrics. In this work, we use Task Goal Completion as the primary measure of performance. Following the standard protocol, we report Avg@4 and Pass@4 across four independent trials. τ 2 -Bench τ 2 -Bench (Barres et al., 2025) evaluates tool use in conversational agent settings, with a strong emphasis on user-agent interaction. The benchmark simulates multi-turn dialogues between a user and an agent, aiming to reflect realistic conversational behavior. Agents must track dialogue context across turns, interpret user requests, select and invoke APIs appropriately, and follow domain-specific business rules. The tasks cover domains such as airline customer service and retail customer service. The interactive nature of the benchmark requires agents to respond to user feedback, maintain coherent dialogue flow, and coordinate tool use with the ongoing conversation. Performance is assessed based on task completion accuracy, correctness of tool use, and compliance with policies. In this work, we conduct four independent trials per task and report Pass@1 on each of the three domains. A.2. Baseline Details A-Mem A-Mem (Xu et al., 2025) is an agentic memory framework that equips LLM-based agents with the ability to maintain and utilize long-term knowledge over extended interactions. The method organizes accumulated experiences into a memory-centric structure, enabling agents to selectively retain, retrieve, and revise stored information according to task objectives and observed outcomes. Rather than treating memory as a passive log, A-Mem emphasizes autonomous memory management driven by the agent’s goals and interaction context. In our experiments, we reproduce A-Mem based on its publicly available implementation, with minor prompt adaptations to support memory writing and organization during task interactions. AWM AWM (Agent Workflow Memory) (Wang et al., 2025c) is a memory-augmented agent framework that focuses on discovering reusable workflow patterns from past task executions. The method stores completed task trajectories as episodic experiences and derives higher-level procedural knowledge by analyzing multiple successful examples. Experience retrieval follows a lightweight lexical matching strategy. Textual representations of task queries and stored experiences are mapped to sparse term-based vectors, and relevance is measured using cosine similarity. A small set of highly relevant experiences is selected for downstream analysis, with subsampling applied when multiple candidates exhibit comparable similarity. Workflow induction is performed by prompting a language model to analyze the retrieved successful trajectories and summarize recurring action patterns. Rather than relying on explicit symbolic rules or predefined workflow schemas, AWM captures reusable procedural structures directly from empirical task executions. Retrieved experiences are incorporated 15 SkillX: Automatically Constructing Skill Knowledge Bases for Agents as conversational message objects (e.g.,HumanMessageandAIMessage), enabling the language model to process exemplar interactions naturally within the dialogue context. ExpeL ExpeL (Zhao et al., 2024) is an experience-driven learning framework that improves agent performance by reflecting on past successes and failures. The method stores task execution trajectories and generates experiential knowledge by contrasting successful and unsuccessful outcomes for the same task. In our experiments, we reproduce ExpeL by collecting both successful trajectories (reward≥ 1.0) and failed trajectories (reward< 1.0). For each successful example, a small number of failed trajectories from the same task type are selected for comparative analysis. A large language model is prompted to analyze the paired trajectories and generate natural-language critiques that highlight key decision differences and improvement suggestions. These critiques are retained as unstructured textual experiences and reused as guidance in subsequent tasks. A.3. Implementation Details Skills Extraction.During the experience extraction stage, which comprises both reasoning and experience extraction, we employ GLM-4.6 with a temperature of 0.9. For each task in the training set, we independently sample four trajectories. Environment feedback exceeding 1500 tokens is summarized. We cluster the extracted skills using DBSCAN (Density-Based Spatial Clustering of Applications with Noise) with a cosine similarity threshold of 0.9. For each cluster, we truncate the skill set to at most 15 skills. Skill updates are performed with up to three iterative refinement rounds. During the skill expansion stage, we set the exploration model temperature to 1.0 and perform 1 time to explore environment for each training task. Skills Usage. We build a skill semantic vector store using FAISS with an HNSW index under cosine similarity (via L2-normalized embeddings and inner-product search). At query time, we first perform a broad retrieval of the Top-100 nearest skills. Candidates are then filtered by a hybrid relevance threshold: we keep only results whose cosine similarity is at least 0.45, and also within 0.08 of the best match for that query, ensuring both a minimum quality floor and adaptive selectivity. To reduce near-duplicate skills, we apply semantic deduplication by removing items whose pairwise cosine similarity exceeds 0.95, retaining the higher-scoring representative. Finally, we return up to 8 skills after applying Maximal Marginal Relevance (MMR) for diversity-aware selection, using a relevance–diversity trade-off weight of 0.75 to emphasize relevance while mitigating redundancy. 16 SkillX: Automatically Constructing Skill Knowledge Bases for Agents B. Case Study For SkillX We present case studies across three diverse benchmarks: AppWorld (Trivedi et al., 2024), BFCL (Patil et al., 2025), and τ 2 -bench (Barres et al., 2025). These cases show that skill libraries help agents avoid common failures such as incorrect API call sequences, missing prerequisite checks, and the inability to handle conversational topic shifts. By framing domain knowledge as reusable skills, agents can complete complex multi-step tasks that the baseline method fails, reducing trial and error from multiple failed attempts to successful execution on the first attempt. Figure 4. AppWorld benchmark case study: Updating Spotify playlist based on roommates’ suggestions.SkillXsuccessfully handles API call sequences (pagination pattern for playlist retrieval) and cross-app integration (integrating Spotify and Phone APIs), while the baseline without multi-level skills fails due to incorrect API call sequences and inability to complete cross-app integration tasks. 17 SkillX: Automatically Constructing Skill Knowledge Bases for Agents Figure 5. BFCL benchmark case study: Vehicle engine start safety check and Twitter posting.SkillXfollows prerequisite sequences (lock doors→press brake pedal→start engine) and properly authenticates before posting tweets, while the baseline without multi-level skills fails by calling APIs without prerequisites and encountering tool calling errors. Figure 6.τ 2 -bench case study: Requesting delay flight compensation in airline domain.SkillXhandles topic shifts, retrieves user reservations without reservation numbers, verifies flight delays, and executes the compensation workflow, while the baseline without multi-level skills fails to recognize topic shifts and cannot retrieve reservation details. 18 SkillX: Automatically Constructing Skill Knowledge Bases for Agents C. Main Prompt Use For SkillX In this section, we provide the prompts of SkillX used for skill extraction, planning, filtering, and merging operations. C.1. General Filter Prompt General Filter Prompt You are a coding expert. Given a predefined skill, evaluate whether its quality is good or bad. Evaluation guidelines: 1. Domain specificity: Check whether the skill includes domain-specific library names APIs, e.g.,api. 2. Over-encapsulation: Check whether the skill’s implementation merely calls a single other skill (i.e., it is just a thin wrapper). 3. No-Python-libraries: Check whether additional Python libraries are introduced in the skill. 4. Reusability: Check whether the parameters are specific. 5. No-Functional style: Check whether a functional style is being used (e.g., the presence of return). Bad Example1 example Bad Example2 example Good Example example Only return ”good” or ”bad”. Don’t return any other words. Table 4. Prompt for filtering skills based on quality criteria. C.2. Tool Summary Prompt Tool Summary Prompt You are an AI assistant specialized in analyzing agent trajectories. Your task is to summarize a single interaction: based on the environment feedback from the current step, extract and summarize the key information in no more than 50 words. Inputs Description 1. The AI assistant’s reasoning and action 2. The resulting environment feedback after the action Summary Guidelines 1. Summarize what the environment feedback conveys in light of the AI assistant’s intent. 2. Preserve details that are tightly relevant to the intent verbatim when possible; compress other redundant information. 3. Summarize only factual content from the environment feedback—do not invent anything. 4. Write the summary in the tone of the environment feedback. Output Format <feedback> Your summary of the environment feedback </feedback> Table 5. Prompt for summarizing environment feedback from agent interactions. 19 SkillX: Automatically Constructing Skill Knowledge Bases for Agents C.3. Tool Schema Filter Prompt Tool Schema Filter Prompt You are a tool-invocation expert. Based on the tool specifications, verify whether the provided tool invocations are correct. Input 1. Tool invocation content: may include one or multiple tool calls. 2. Tool specifications: including tool description, parameters, return schema, and other usage notes. Judging Guidelines 1.Parameter validation: Check whether the invocation parameters comply with the specifications (e.g., missing required parameters, unsupported/nonexistent parameters, wrong types or formats, invalid values, etc.). 2. Call dependency: For multiple tool calls, verify that their order does not violate logical dependencies. If there is no dependency between the calls, ignore this check. 3. Comment–function alignment: Ensure the logic described in any comments matches what the tool is designed to do. 4. Output Format: Provide your reasoning and conclude with either ’correct’ or ’fail’, wrapped in <answer></answer>. Table 6. Prompt for validating tool invocations against specifications. C.4. Plan Extract Prompt Plan Extract Prompt You are a Planning Expert. Your job is to analyze an agent’s API interaction history and the user’s task, then distill them into a concise, reusable plan. This plan should serve as a reference for handling similar tasks more effectively in the future. OBJECTIVES 1. Understand Capabilities • Analyze the recorded API calls to identify the actual functional capabilities demonstrated. 2. Abstract into a Plan • For each feasible task supported by those capabilities, produce a concise, reusable step-by-step plan that can be applied to similar tasks. Planning Creation Rules 1. Focus • Do not simply restate each API function step-by-step using technical jargon. Instead, describe the underlying sub-goal behind each action segment. 2. Remove Non-Essential Steps • Exclude capability exploration, debugging, and failed steps. 3. Reusability • The plan must be precise enough for other models to reuse. 4. Conciseness • Merge steps from the interaction history that share the same objective into a single sub-step in the plan. • Use a compact writing style for each sub-step, while listing the key APIs involved in that step (one or more). • Do not omit any critical, potentially required API keys. OUTPUT FORMAT For each task, output exactly one plan and follow this format strictly: <plan> # step 1: A natural, specific, concise sub-task goal; key APIs used (one or more). # step 2: ... ... </plan> GOOD EXAMPLES examples CHECKLIST BEFORE FINALIZING ✓ Reusability — Ensure no critical steps are missing, and the step order is correct. ✓ Conciseness — Confirm there are no redundant or unnecessary steps. ✓ Agent-centered — Make sure the plan reads like actionable instructions that other models can reliably follow. Table 7. Prompt for extracting reusable plans from agent trajectories. 20 SkillX: Automatically Constructing Skill Knowledge Bases for Agents C.5. Merge Prompt Merge Prompt You are a code expert. Your task is to analyze a list of skills, merge skills that are meaningfully similar, and decompose complex skills into smaller atomic skills while preserving behavior and intent. Input Description The user will provide a list of skills. Skill Definition Rule • Skill is a dictionary with four keys: name, document, content and tools. 1. name: the skill’s name. 2. document: the skill’s functionality, the key parameters, the final output of the skill, and any important notes. 3. content: the concrete implementation of the skill. 4. tools: the key tools used in the skill (list). • The skill is abstract, modular, and reusable. Specifically, the skill name must be generic under one application (e.g.,good exampleinstead ofbad example. The skill must use parameters instead of hard-coded values (e.g., specific email addressemail address). The skill body must be self-contained. •Explicitly declare the key parameters and the final output data types using type hints. Example:Parameters: param: str; Outputs: output: list[dict]: • Include a detailed description of the skill with input and output explanation. • The skill should not be similar to the existing skills in the skills library. • The skill must involve multiple processing steps. Simply using the result of an API call without additional logic does not qualify as a valid skill. • Never call other skills from the skills library or any previously defined skills. • Do not import any Python packages. • Avoid a functional style; there’s no need to use return. Good skill: ```json ”name”: name, ”document”: document, ”content”: content, ”tools”: tools ``` Focus 1. Focus on skills with similar names and similar skillality. 2. Carefully analyze the concrete implementation differences between similar skills. Merge Guidelines 1. Generality: Merge skills that have similar names and similar skillality. The merged skill should use a generic name, and its Notes and implementation should cover all plausible variants and edge cases. 2.Atomicity: If skills have a containment relationship (one skill’s skillality subsumes or builds on another), follow the skill definitions to preserve atomicity and avoid merging. 3. Merge Constraints: Any merged skill must comply with the skill definition rules, especially atomicity and reusability, and should avoid being tied to a specific task or scenario. Decompose Guidelines 1.Atomicity: Only decompose skills whose skillality is overly complex (e.g., they include skillality already covered by other provided skills) into smaller sub-skills. 2.Generality: The decomposed skills must follow the skill-definition rules and remain reusable—avoid coupling them to any specific task or scenario. Output Format Output a list containing the skills (with one or multiple skills) from merging and/or decomposing the skills in the input skill list as follows: <skill> [ ”skill 1”, ... ] </skill> Note: You don’t necessarily need to both merge and decompose. You may choose to only merge them into a single skill. Table 8. Prompt for merging and decomposing skills. 21 SkillX: Automatically Constructing Skill Knowledge Bases for Agents C.6. Atomic Skill Extract Prompt Atomic Skill Extract Prompt An agent system is provided with a skills library and has tried to solve the task multiple times with a successful solution. Review the task-solving attempt and extract generalizable skills. 1. Inputs Description • User Task • Trajectory: A record of an agent’s interactions successfully with the environment as it attempts to complete a user task. • skills library: A collection of all currently available skills that can be directly reused. • Specific-Tool: Given a specific tool, extract only one reusable skill for the specified tool. 2. Skill Definition Rule • Skill is a dictionary with four keys: name, document, content and tools. 1. name: the specific tool’s name. 2. document: the tool’s functionality, the key parameters, the final output of the skill, and any important notes. 3. content: the tool’s usage examples, and examples of combining it with other tools (if applicable). 4. tools: the key tools used in the content (list). • The skill is centered around a specific tool, describing its core functionality, important notes, and common usage examples. • Explicitly declare the key parameters and the final output data types using type hints. Example:Parameters: param: str; Outputs: output: dict: • Include a detailed description of the skill with input and output explanation. • The skill should not be similar to the existing skills in the skills library. • The parameters used incontentmust be reusable instead of hard-coded values (e.g., specific email address ”jay@gmail.com”) • The usage examples of content may involve one or more tool uses. • The document must clearly and thoroughly document all relevant details of the specific tool use. • Never call other skills from the skills library or any previously defined skills. • Do not import any Python packages. • Avoid a functional style and Python code style; there’s no need to use return. 3. Update Existing Skills Your goal is to ensure the system retains actionable skills that help it behave correctly in the future. You have three options: [modify, add, keep] • modify: revise an existing skill to make it more effective (e.g., improving documents). Only changecontentwhen necessary, and ensure the resulting skill remains broadly general-purpose. • add: introduce a new skill only when the existing skills library is missing the specified tool. • keep: Preserve the skill unchanged when there are no clear issues. Common actions: • add a new skill • update a skill’s usage instructions/documentation • revise a skill’s variable/parameter definitions to make it more generalizable • keep a skill unchanged 4. Requirements for each skill that is modified or added. • Avoid duplication: If a skills library is provided, do not add new skills that are similar to existing ones—use keep or modify instead. • Ensure domain specificity: The skill must contain domain-specific tool. • Specific-Tool guided extraction: Only focus on the specified tool in the trajectory when extracting skills. 5. Good Skill Example example 6. Output Format You will finish by returning in this JSON format as follows: ```json [ ”option”: ”modify”, ”skill”: ”the modified skill”, ”modified from”: ”spotify get all user playlists” # specify the skill name of existing skills that is modified , ”option”: ”add”, ”skill”: ”the added skill”, , 22 SkillX: Automatically Constructing Skill Knowledge Bases for Agents ”option”: ”keep”, ”skillname”: ”the kept skill name”, , ... ] ``` Note that your updated skills may not need to cover all the options. You can only use one type of updates or choose to remain all skills unchanged. 7. CHECKLIST BEFORE FINALIZING ✓ Reusability — Ensure no critical steps are missing, each skill is modular, all parameters are abstract rather than specific. ✓ Optimality — Ensure each skill meets the required definition standards. ✓ Agent-centered — Add helpful notes in each skill to guide other models in using it correctly. ✓ Specific-Tool focus — Whether the extracted skill doesn’t center around this Tool? Table 9. Prompt for atomic skill extraction based on specific tools. C.7. Functional Skill Extract Prompt Functional Skill Extract Prompt An agent system is provided with a skills library and has tried to solve the task multiple times with a successful solution. Review the task-solving attempt and extract generalizable skills. 1. Inputs Description • User Task • Trajectory: A record of an agent’s interactions successfully with the environment as it attempts to complete a user task. • skills library: A collection of all currently available skills that can be directly reused. • Specific-step: Given a concrete step, extract only one reusable skill for the specified step. 2. Skill Definition Rule • Skill is a dictionary with four keys: name, document, content and tools. 1. name: the skill’s name. 2. document: the skill’s functionality, the key parameters, the final output of the skill and any important notes. 3. content: the concrete implementation of the skill. 4. tools: the key tools used in the skill (list). • The skill is abstract, modular, and reusable. Specifically, the skill name must be generic under one application (e.g.,spotify get songs by genreinstead ofget pop songs). The skill must use parameters instead of hard-coded values (e.g., specific email address ”jay@gmail.com”). The skill body must be self-contained. •Explicitly declare the key parameters and the final output data types using type hints. Example:Parameters: param: str; Outputs: output: list[dict]: • Include a detailed description of the skill with input and output explanation. • The skill should not be similar to the existing skills in the skills library. • The skill must involve multiple processing steps. Simply using the result of an API call without additional logic does not qualify as a valid skill. • Never call other skills from the skills library or any previously defined skills. • Do not import any Python packages. • Avoid a functional style; there’s no need to use return. 3. Update Existing Skills Your goal is to ensure the system retains actionable skills that help it behave correctly in the future. You have three options: [modify, add, keep] • modify: revise an existing skill to make it more effective (e.g., improving documents). Only changecontentwhen necessary, and ensure the resulting skill remains broadly reusable/general-purpose. • add: introduce a new skill only when existing skills cannot support a critical step, in order to improve future performance. • keep: Preserve the skill unchanged when there are no clear issues. Common actions: • add a new skill • update a skill’s usage instructions/documentation • revise a skill’s variable/parameter definitions to make it more generalizable • if a skill is overly complex, refactor it into more modular skills (involving both modify and add) • keep a skill unchanged 23 SkillX: Automatically Constructing Skill Knowledge Bases for Agents 4. Requirements for each skill that is modified or added. •Avoid duplication: If a skills library is provided, do not add new skills that are similar to existing ones—use keep or modify instead. • Exclude non-solution behavior: Do not include capability exploration, debugging activities, or any failed/incorrect steps. • Ensure domain specificity: The skill must reference domain-specific libraries/APIs, e.g.,api. •Avoid over-wrapping: Verify the implementation is not merely a thin wrapper around another skill (i.e., not just calling a single underlying skill without meaningful additional logic). • Specific-step guided extraction: Only focus on the specified step in the trajectory when extracting skills. 5. Good Skill Example example 6. Output Format You will finish by returning in this JSON format as follows: ```json [ ”option”: ”modify”, ”skill”: ”the modified skill”, ”modified from”: ”spotify get all user playlists” # specify the skill name of existing skills that is modified , ”option”: ”add”, ”skill”: ”the added skill”, , ”option”: ”keep”, ”skill name”: ”the kept skill name”, , ... ] ``` Note that your updated skills may not need to cover all the options. You can only use one type of updates or choose to remain all skills unchanged. 7. CHECKLIST BEFORE FINALIZING ✓ Reusability — Ensure no critical steps are missing, each skill is modular, all parameters are abstract rather than specific. ✓ Optimality — Ensure each skill meets the required definition standards. ✓ Agent-centered — Add helpful notes in each skill to guide other models in using it correctly. ✓ Specific-step focus — Whether the extracted skill includes any content that does not belong to this step? Table 10. Prompt for functional skill extraction based on specific steps. 24

Instant research discovery