Large language model (LLM) agents can induce skills from completed tasks and reuse them later to grow more capable with experience. In practice, induced skills may transfer unreliably and can even harm the agent that retrieves them. When agent-induced skills transfer reliably across tasks remains an open question. We conduct a comprehensive and controlled study of how the way skills are induced shapes their transfer across tasks. Specifically, we compare task-level with subtask-level skill induction and text with code skill formats, the two axes along which existing methods differ. Task-level skills mostly reduce the agent's performance below its no-memory baseline while subtask-level skills raise it above on average, and text skills transfer better than code skills. To further understand our findings, we examine two complementary properties of the induced skills: specificity, which measures how closely a skill matches real tasks, and abstractness, which measures how evenly its relevance spreads across tasks. Neither property alone predicts task success, but their combined effect does, which we propose as a skill utility score. The score correlates consistently with task success when skills are transferred, and subtask-level and text skills score higher. Computing skill utility only needs the skills and task descriptions but not any task execution, so our score serves as a practical diagnostic of a skill memory before any new task runs.
Figures & tables
Figure 1: Different tasks share subtasks. A task-level skill summarizes the whole trajectory, so it stays tied to its source task and is not shared with the other task. Subtask-level induction yields one skill per subtask, and the skills of shared subtasks (amber) transfer between Task X and Task Y.
Work
Skill Induction Level
Skill Format
Domain
Instruction
Demonstration
Abstraction Rules
AutoManual ( Chen et al., 2024 )
Rule
Text
Household, Websites
✓
✓
✓
DynaSaur ( Nguyen et al., 2025 )
Step
Code
Assistance, Math, QA
✓
✓
✓
Reflexion ( Shinn et al., 2023 )
Task
Text
QA, Household, Code
✓
✓
×
ExpeL ( Zhao et al., 2024 )
Task
Text
QA, Household, Websites
✓
×
✓
CLIN ( Majumder et al., 2024 )
Task
Text
Science Simulation, Household
✓
×
✓
AWM ( Wang et al., 2025c )
Task
Text
Websites
✓
✓
✓
Table 1: Survey of skill-induction methods. Skill induction level is the span a skill is induced over, skill format is the representation of a stored skill, and domain lists the evaluation domains in each work’s experiments. The last three columns mark whether the induction prompt includes an instruction that states what to extract, a demonstration that shows one worked extraction, and abstraction rules that drop instance-specific detail. The prompt cells are read from each system’s released prompt files or paper appendix, and n/r means the prompt is not released.
Task-Level
Subtask-Level
Benchmark
Model
None
+Text
+Code
None
+Text
+Code
AppWorld
Qwen3-235B-A22B
7.4 [5.0, 10.1]
18.0 [14.4, 21.8]
14.4 [11.0, 18.0]
27.3 [23.0, 31.7]
35.5 [30.9, 40.0]
35.7 [31.2, 40.3]
GPT-OSS-120B
27.3 [23.3, 31.7]
17.0 [13.4, 20.6]
1.0 [0.2, 1.9]
26.4 [22.3, 30.5]
25.2 [21.1, 29.5]
23.7 [19.7, 27.8]
Nemotron-Super-120B
8.9 [6.2, 11.8]
4.3 [2.4, 6.2]
1.4 [0.5, 2.6]
17.7 [14.1, 21.6]
21.6 [17.7, 25.4]
18.5 [14.9, 22.3]
Qwen3-4B
0.0 [0.0, 0.0]
0.2 [0.0, 0.7]
0.0 [0.0, 0.0]
0.2 [0.0, 0.7]
0.7 [0.0, 1.7]
1.4 [0.5, 2.6]
Qwen3-8B
0.2 [0.0, 0.7]
0.0 [0.0, 0.0]
0.0 [0.0, 0.0]
2.2 [1.0, 3.6]
3.1 [1.7, 5.0]
1.9 [0.7, 3.4]
Table 2: Task success (%) of the task-level and subtask-level agents, without (None) or with induced skills as text notes (+Text) or code functions (+Code), on AppWorld, OfficeBench, and KramaBench. We show nine of the eleven models and defer the two weakest, Gemma-3-4B and Gemma-3-12B, to Tab. 3 in App. E.1 . Every Average row still covers all eleven models. Brackets are 95% task-bootstrap confidence intervals. On most models and benchmarks the highest success falls in a Subtask-level column, and adding skills mostly raises the success of the subtask-level agent while it lowers that of the task-level agent.
Figure 3: Task success rate within a per-task budget of dependency, i.e. the compute spent (left), and latency, i.e., the wall-clock time (right) per task (Sec. 4 ). We average over models and benchmarks for each skill format and skill induction level. The task-level agent wins only at the smallest budgets, and from moderate budgets on the subtask-level agent with skills solves more tasks at equal cost.
Figure 4: Task success of the six conditions by task difficulty, pooled over models with 95% task-bootstrap confidence intervals. In every stratum and under both formats, the subtask-level agent with skills stays above the task-level agent with skills. In nearly every stratum, the skills bring a larger gain to the subtask-level agent than to the task-level agent, and Text stays at or above Code within each induction level.
Figure 5: Skill utility against the results. (a): Each task is scored by the average utility of the agent-retrieved skills and ranked into equal-size bins per agent. Success rises from the lowest bin to the highest for both agents. (b): The subtask-level agent’s tasks are scored by one dimension alone and split into equal-size bins, and success rises and then falls on both dimensions. (c)–(e): The median skill utility of each induced memory, averaged over models, is no lower at the subtask level than the task level, and higher for Text than Code. Shaded bands are 95% CIs.
Figure 6: Transfer density. The task stream of each benchmark is cut into 50 bins in stream order, and a cell is colored when a skill induced in the earlier bin is retrieved in a later bin, darker when more of the runs do so. Blue upper triangles are the subtask-level agent and green lower triangles are the task-level agent, pooled over models and both skill formats, and the number in each triangle is its transfer density. The subtask-level agent reuses skills more densely than the task-level agent on all three benchmarks.
Appendix figures & tables27 assets
Supplementary material from the paper’s appendix.
Appendix
Figure 7: Execution core on AppWorld, the system prompt shared by both agents. Each subtask-level role appends its role block of Fig. 10 , and the task-level agent uses the core unchanged.
Figure 8: Execution core on OfficeBench, the system prompt shared by both agents. Each subtask-level role appends its role block of Fig. 11 , and the task-level agent uses the core unchanged.
Figure 9: Execution core on KramaBench, the system prompt shared by both agents. Each subtask-level role appends its role block of Fig. 12 , and the task-level agent uses the core unchanged.
Figure 10: Role blocks of the subtask-level agent on AppWorld. Each block is appended to the execution core of Fig. 7 to form the system prompt of its role.
Figure 11: Role blocks of the subtask-level agent on OfficeBench. Each block is appended to the execution core of Fig. 8 to form the system prompt of its role.
Figure 12: Role blocks of the subtask-level agent on KramaBench. Each block is appended to the execution core of Fig. 9 to form the system prompt of its role.
Figure 13: User messages of the three subtask-level roles. The progress summary starts as a fixed no-progress line, and the live action menu appears only on OfficeBench.
Figure 14: Framing wrapped around the text and code skills retrieved for the linear and subtask-level agent.
Figure 15: Text-skill induction prompt on AppWorld, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 16: Text-skill induction prompt on OfficeBench, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 17: Text-skill induction prompt on KramaBench, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 18: Code-skill induction prompt on AppWorld, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 19: Code-skill induction prompt on OfficeBench, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 20: Code-skill induction prompt on KramaBench, appended as a user message to the span being distilled. The same prompt serves both induction levels.
Figure 21: The task-level text skill induced from the example task. One workflow note spans the whole trajectory from login to order placement.
Figure 22: The task-level code skill induced from the same task. One function reproduces the whole trajectory and keeps the source task’s product keyword as its default argument.
Figure 23: The subtask-level text skills induced from the same task, one note per completed subtask.
Figure 24: The subtask-level code skills induced from the same task, one function per completed subtask.
Figure 25: Task success of the task-level agent retrieving its original task-level skills or the subtask-level agent’s skills, averaged over the Text and Code formats and pooled over Qwen3-235B-A22B and GPT-OSS-120B, with 95% task-bootstrap confidence intervals. Dashes mark the task-level agent without skill memory. With its original skills the task-level agent falls below the dashes on every benchmark, while with subtask-level skills it beats the original skills everywhere and returns to or above the dashes.
Figure 26: Subtask-level induction stays ahead of task-level induction at every induction-prompt level. Each point is one benchmark, skill format, and prompt level, where L3 is the deployed prompt and L1 and L2 are the reduced versions of Sec. 4 , averaged over the models that ran it. Panel (A) compares the task success of the two skill arms, and panel (B) compares each arm’s memory effect against its own no-memory baseline on the same tasks. Points above the dashed diagonal favor the subtask level, and the upper left quadrant of (B) holds the points where task-level memory hurts while subtask-level memory helps.
Figure 27: The tradeoff between the two terms of the skill utility score. Each panel bins the skills of one benchmark into equal-size abstractness deciles and plots mean specificity against mean abstractness for the four skill conditions. All conditions fall on nearly one frontier, and subtask induction trades a small loss in specificity for a large gain in abstractness, which raises the product.
Figure 28: Task success reachable within a per-task budget of dependency (left column) and latency (right column), one row per benchmark, pooled over models, with color the skill format and line style the induction level as in Fig. 3 . The crossover of the main text appears on every benchmark, where the task-level agent leads at small budgets and the subtask-level agent overtakes and saturates higher.
Task-level
Subtask-level
Benchmark
Model
None
+Text
+Code
None
+Text
+Code
AppWorld
Qwen3-235B-A22B
7.4 [5.0, 10.1]
18.0 [14.4, 21.8]
14.4 [11.0, 18.0]
27.3 [23.0, 31.7]
35.5 [30.9, 40.0]
35.7 [31.2, 40.3]
GPT-OSS-120B
27.3 [23.3, 31.7]
17.0 [13.4, 20.6]
1.0 [0.2, 1.9]
26.4 [22.3, 30.5]
25.2 [21.1, 29.5]
23.7 [19.7, 27.8]
Nemotron-Super-120B
8.9 [6.2, 11.8]
4.3 [2.4, 6.2]
1.4 [0.5, 2.6]
17.7 [14.1, 21.6]
21.6 [17.7, 25.4]
18.5 [14.9, 22.3]
Qwen3-4B
0.0 [0.0, 0.0]
0.2 [0.0, 0.7]
0.0 [0.0, 0.0]
0.2 [0.0, 0.7]
0.7 [0.0, 1.7]
1.4 [0.5, 2.6]
Qwen3-8B
0.2 [0.0, 0.7]
0.0 [0.0, 0.0]
0.0 [0.0, 0.0]
2.2 [1.0, 3.6]
3.1 [1.7, 5.0]
1.9 [0.7, 3.4]
Appendix
Table 3: Task success (%) of all eleven models, the full version of Tab. 2 with Gemma-3-4B and Gemma-3-12B included. Brackets are 95% task-bootstrap confidence intervals. Each in-block Average row is taken over the models on that benchmark, and the bottom row over all models and benchmarks.
Skill library
High-utility half
Low-utility half
Task-level
44.0 [36.7, 51.4]
42.9 [35.6, 50.0]
Subtask-level
48.4 [41.0, 55.7]
47.0 [39.1, 54.9]
Appendix
Table 4: Task success (%) of the task-level agent retrieving only the high-utility or only the low-utility half of the same skill library, split at the median skill utility, on KramaBench, averaged over the Text and Code formats and pooled over Qwen3-235B-A22B and GPT-OSS-120B, with 95% task-bootstrap confidence intervals. Both arms run the same tasks with the same number of retrieved skills per task, and the high-utility half wins for both libraries.
Benchmark
Difficulty
Task score
Retrieved utility
AppWorld
Level 1
0.215
0.250
Level 2
0.115
0.258
Level 3
0.082
0.257
OfficeBench
1 app
0.320
0.294
2 apps
0.353
0.286
3 apps
0.107
0.277
Appendix
Table 5: Mean task score and mean utility of the retrieved skills at each benchmark’s native difficulty levels, pooled over all models, both skill formats, and both agents. The task score varies severalfold across the levels while the utility of retrieved skills stays nearly constant.
Induction level
+Text
+Code
Task-level
75.6 [72.8, 78.3]
88.1 [86.2, 89.9]
Subtask-level
79.6 [78.1, 80.9]
86.1 [85.0, 87.2]
Appendix
Table 6: Self-retrieval rates on Qwen3-235B-A22B, Nemotron-Super-120B, and Qwen3-32B, pooled over the three benchmarks, with 95% task-bootstrap confidence intervals. A skill counts as self-retrievable if it ranks among the original skills retrieved for its source task or subtask. All conditions use the same retrieval configuration.
Artifacts/Models/Packages
Citation
Link
License
Benchmarks
AppWorld
Trivedi et al. (2024)
https://github.com/StonyBrookNLP/appworld
Apache-2.0 License
OfficeBench
Wang et al. (2024c)
https://github.com/zlwang-cs/OfficeBench
Apache-2.0 License
KramaBench
Lai et al. (2026)
https://github.com/mitdbg/Kramabench
MIT License (Code) and CC-BY-NC-4.0 (data)
Backbone Models
Qwen3 (4B, 8B, 14B, 32B, 235B-A22B)
Yang et al. (2025)
https://huggingface.co/collections/Qwen/qwen3
Apache-2.0 License
Appendix
Table 7: Benchmarks, backbone models, and major software packages used in our study, with their citations, links, and licenses. We will release the codebase and the induced skill libraries of this project under the MIT License to support open science and reproducibility.
Large Language Model (LLM) agents increasingly rely on domain-specific skills, yet manually authoring such skills does not scale, and skills generated purely from parametric knowledge often miss critical operational pitfalls. We introduce Trace2Skill, a framework that consolidates broad execution trajectories in parallel into a unified skill directory through inductive reasoning over agent experience. Trace2Skill supports both deepening existing human-written skills and creating useful skills from weak LLM-generated drafts. Experiments demonstrate the effectiveness of Trace2Skill across diverse domains, including office workflows, math reasoning, and vision QA. Importantly, the evolved skills are not merely memorized artifacts of the trajectories used to create them: they often transfer across model scales, across model families, and to out-of-distribution settings. For example, skills evolved from Qwen3.5-35B trajectories improve a Qwen3.5-122B agent by up to 57.65 percentage points on WikiTableQuestions. Further analyses show that Trace2Skill outperforms sequential skill editing and ReasoningBank-style retrieval memories, compresses recurring failures and workarounds into standard operating procedures (SoPs), and yields portable skills that can be reused without parameter updates or test-time retrieval.
Jingwei Ni, Yihao Liu, Xinpeng Liu +7
ETH Zürich · University of Zurich · Peking University +2
Skills have emerged as a practical and effective approach for enhancing LLM agents at inference time through structured packages of knowledge. However, existing evaluations largely measure whether skills improve aggregated task success, leaving a more fundamental question underexplored: When do skills help, why do they work, and where do they fail? Through controlled experiments across various benchmarks, agent harnesses and LLMs, we isolate the effects of representation, outcome annotation, retrieval difficulty, and cross-framework robustness of skills. To further answer this question, we design a contrastive study that combines controlled quantitative experiments with paired trajectory analysis. We normalize 8,135 trial records from controlled experiments and retain 238 valid unique labels from 240 open-coded records. We consolidate these observations into a taxonomy of three high-level categories and twelve skill-use modes: skills work when noisy trajectories become procedural anchors that stabilize execution. Skills improve over Workflow Memory by 6.06 points in matched comparisons. Procedural anchoring accounts for 65.7% of skill cases, versus 4.5% for explicit knowledge injection, showing that skills stabilize action rather than inject missing facts. Retrieval is a separate bottleneck: as pools grow from 5 to 100, actual-use precision falls from 29.6% to 3.3%. Confusable distractors impair offline identification, yet downstream success remains stable; exact ground-truth invocation is neither sufficient nor necessary. Skills fail under brittle assumptions, incompatible contexts, or insufficient adaptation. These findings move evaluation beyond aggregate success rates and guide reliable self-evolving agents.
Zhiyuan Jiang, Fangrui Huang, Hanwen Xing +6
Princeton University · Stanford University · University of Southern California +2
Large language model agents often encounter related yet distinct tasks that share reusable solution patterns. Yet standard agentic reinforcement learning treats tasks as independent episodes, while existing approaches to skill learning either focus on repeated attempts of one task or use pipelines with multiple stages that entangle extraction, retrieval, and execution. We introduce SkillRise, a unified reinforcement learning framework for learning skills across tasks. SkillRise organizes related instances into progressively challenging sequences and uses a single policy to alternate between task solving and curating an evolving skill document passed directly to the next task. Decoupled credit assignment across tasks supervises solving with the current task outcome and curation with discounted downstream outcomes. Experiments on ALFWorld, WebShop, and ScienceWorld show that SkillRise achieves the strongest Pass@1 performance among the compared methods, with gains over the strongest baseline ranging from 2.3 to 8.5 percentage points. Although trained across distinct tasks, its learned curation policy remains effective for repeated attempts on the same task. Further analysis reveals scaling at test time across tasks: performance improves with longer sequences of related tasks even when each task is attempted only once. This trend suggests that SkillRise reuses transferable skills across tasks rather than benefiting from repeated sampling of the same task. SkillRise further retains strong performance while substantially reducing the runtime overhead of skill learning pipelines with multiple stages. Together, these results provide a simple and efficient training paradigm for LLM agents to extract, refine, and reuse transferable skills across tasks.
Zhiyuan Yao, Yuxin Chen, Zhengxi Lu +13
1Zhejiang University · 2National University of Singapore · 3Shanghai Jiao Tong University +1