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, so our score serves as a lightweight diagnostic of a skill memory for practitioners.
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.