Break It Down, Pass It On: Cross-Task Skill Transfer in LLM Agents

Abstract: 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.

• The paper shows that subtask-level skill induction improves agent success by 1.9 points with text skills and 0.5 points with code skills, while task-level skills reduce success by 1.2 and 4.1 points, respectively.
• The study evaluates six skill-memory conditions across AppWorld, OfficeBench, and KramaBench using 11 models, controlling prompts, retrieval, memory rules, and efficiency budgets to isolate induction level and format.
• The paper introduces a skill utility score combining specificity and abstractness, which predicts success without task execution and identifies higher-value memories for both task-level and subtask-level agents.

Motivation and central question

LLM agents that induce skills from completed tasks and store them in a skill memory promise continual improvement with experience, but in practice induced skills often transfer unreliably and can even degrade the agent that retrieves them. The paper asks when agent-induced skills transfer reliably across tasks, and answers it with a controlled factorial study along two axes on which existing skill-induction methods differ: the skill induction level (whether a skill summarizes a whole task trajectory or a single subtask) and the skill format (text note versus code function). Prior evidence for the benefits of subtask-level induction was narrow, covering limited domains, few models, and text-only formats; this work provides the first systematic comparison under identical conditions.

Experimental design

The study formalizes cross-task skill transfer as an agent solving a stream of tasks against a shared memory, writing one skill after each task or subtask and retrieving relevant skills before each. Two agents are compared: a flat ReAct loop (task-level) and a planner–executor–summarizer decomposition agent (subtask-level), where the task-level agent is a special case of the subtask-level agent with the whole task as its single subgoal. Both share identical induction prompts, retrieval (embedding-based top-5 over skill descriptions using all-MiniLM-L6-v2), and memory maintenance rules, so each contrast isolates exactly one axis. Crossing the two levels with three format options yields six conditions, evaluated on AppWorld (417 tasks), OfficeBench (300 tasks), and KramaBench (92 deterministically graded tasks), across eleven models spanning MoE architectures (Qwen3-235B-A22B, GPT-OSS-120B, Nemotron-Super-120B), dense Qwen3 and Gemma-3 models at multiple scales, and Gemini-3.1-Pro. Each agent with skills is measured against the same agent without skills, so differences between the two agents cancel out.

Skills help at the subtask level but harm at the task level

The headline result is stark: applying the same induction prompt at different levels produces opposite effects. Task-level skills lower the task-level agent's average success relative to its no-memory baseline — by 1.2 points with text skills and 4.1 points with code skills, up to 7.4 points per benchmark — while subtask-level skills raise average success by 1.9 points (text) and 0.5 points (code). Text skills help on all three benchmarks at the subtask level; code skills help on two of three and lose 1.4 points on KramaBench. These effects hold across all difficulty strata, survive reduced induction prompts (instruction-only and instruction-plus-demonstration ablations), and persist under matched per-task budgets of latency and dependency: the task-level agent wins only at the smallest budgets, after which the subtask-level agent overtakes under every format and saturates higher.

Two controls rule out confounds. First, equipping the task-level agent with the subtask-level agent's skills beats its own task-level skills on every benchmark (by 9.9 points on average, up to 17.2 on AppWorld), showing the effect travels with the skills rather than the agent architecture. Second, both levels induce from solved and unsolved source tasks at nearly identical rates (roughly 75% of skills come from unsolved tasks in all conditions), so the divergence is not explained by differential distillation of failed experience. Retrieval-quality checks similarly show self-retrieval rates are statistically indistinguishable across levels, and code skills actually self-retrieve better than text skills despite transferring worse.

Text transfers better than code

At fixed induction level, text skills beat code skills by 2.9 points (subtask-level) and 1.4 points (task-level) averaged over models, and this ranking holds within every difficulty stratum and at every efficiency budget. Notably, code skills are retrieved as often as or more often than text skills on five of six benchmark-format combinations yet yield smaller gains — an observation the authors use to argue that raw reuse counts measure retrieval frequency, not breadth of applicability, and therefore cannot substitute for a proper utility measure.

A skill utility score balancing specificity and abstractness

To explain these patterns, the paper defines two complementary properties computed purely from skill descriptions and benchmark task instructions via the retrieval embedder. Specificity measures how closely a skill matches real tasks, operationalized as the probability that the skill's nearest-task similarity exceeds the similarity between two random tasks. Abstractness measures how evenly relevance spreads across tasks, operationalized as the perplexity of a temperature-scaled softmax over task similarities, normalized by the task count. The two properties trade off along a shared frontier for all four skill conditions, and neither alone predicts success: binned success rises then falls as either dimension increases individually. Their product — the skill utility score — does predict success monotonically, rising from 14.0% to 24.5% across bins for the task-level agent and from 22.8% to 31.0% for the subtask-level agent.

The score is consistent with the main results: subtask-level skills have higher median utility than task-level skills on almost every benchmark and format, and text skills exceed code skills at both levels on every benchmark. It also matches observed behavior: transfer density (the share of ordered stream-bin pairs carrying at least one actual cross-bin retrieval) is higher for the subtask-level agent on all three benchmarks. Two additional analyses strengthen the causal claim: retrieved-skill utility stays nearly constant across native difficulty levels while success falls steeply, and utility still predicts success within fixed difficulty strata (Spearman $\rho = +0.095$ and $+0.075$, both $p < 10^{-10}$); and splitting a library at its median utility and rerunning the same tasks with only one half shows the high-utility half wins for both task-level (44.0% vs. 42.9%) and subtask-level (48.4% vs. 47.0%) libraries. Because computing the score requires only skills and task descriptions — no task execution — it serves as an execution-free diagnostic of a skill memory before any new task runs.

Limitations and open questions

The authors are explicit about scope. All conclusions rest on three benchmarks scored by final environment state; other agentic settings such as computer use, agentic coding, and web search may exhibit different transfer behavior, and studying them was blocked by the root-Docker access their sandboxes require. The skill memory uses fixed induction, retrieval, and deduplication rules, excluding systems where agents revise stored skills over time. Grading by final state precludes step-level analysis of intermediate decisions, which would require a judge model. One further tension remains unresolved: text skills' low self-retrieval rates stem from highly abstract descriptions that drop topical words, which hurts retrievability yet improves cross-task transfer — how to reconcile description abstraction with retrieval quality is left open, as is detecting maliciously injected skills, which the reuse mechanism would propagate as readily as beneficial ones.

Conclusion

This paper establishes, through a controlled comparison across three long-horizon benchmarks and eleven models, that the skill induction level determines whether induced skills help or harm an agent — subtask-level induction lifts performance above the no-memory baseline while task-level induction drives it below — and that text skills transfer more reliably than code skills at both levels. The proposed skill utility score, requiring joint specificity and abstractness, correlates with task success, ranks the winning conditions higher, matches observed reuse, and can be computed without executing any task, making it a practical pre-deployment diagnostic for skill memories.