Break It Down, Pass It On: Cross-Task Skill Transfer in LLM Agents | AI Paper Digest

TL;DR Highlight

Inducing skills per subtask instead of per whole task made agents more successful, while whole-task skills hurt.

Who Should Read

A backend developer whose agent's accumulated experience memory is hurting rather than helping performance

Core Mechanics

Whole-task skills often hurt
- Across 11 models, average success fell from 22.1% with no memory to 20.9% with text and 18.0% with code skills.
- Skills stay tied to the source task's keywords, so they inject misaligned context into other tasks.
Subtask-level skills help
- With the same induction prompt, one skill per subtask reached 26.7% with text and 25.3% with code on average.
- Shared steps like login and cart filtering get reused across tasks.
Text beats code for skills
- Text skills beat code skills by 2.9 points at the task level and 1.4 at the subtask level.
- Code skills sometimes made the agent call one whole-task function and stop.
A utility score diagnoses a skill memory
- It multiplies specificity (closeness to real tasks) by abstractness (how evenly relevance spreads across tasks).
- It needs only skill and task descriptions, so no agent runs are required.

Evidence

Only subtask skills raised the average
- Averaged over 11 models, the task-level agent scored 22.1% with no memory, 20.9% with text, and 18.0% with code.
- The subtask-level agent scored 24.8% with no memory, 26.7% with text, and 25.3% with code.
Swapping skills alone flipped the result
- Giving the task-level agent subtask skills beat its own skills by 9.9 points on average and up to 17.2 on AppWorld.
- On AppWorld it ended 12.4 points above its no-memory baseline.
Utility tracks success almost monotonically
- Success rose from 14.0% to 24.5% for the task-level agent and from 22.8% to 31.0% for the subtask-level agent across utility bins.
- Spearman correlations over 10 bins were 0.98 and 0.95.
The high-utility half of a library wins
- Splitting the same library at median utility, the high-utility half won in all six cases.
- On AppWorld at task level, it scored 15.4% against 10.2% for the low half.

How to Apply

Split your skill memory by subtask
- Find where your agent summarizes a whole task into one stored note.
- Have a planner split tasks into subtasks and extract one skill after each subtask.
- Name skills by generalized procedure such as login or cart filtering.
Store skills as text notes first
Score your skills with the utility formula
Inject retrieved skills only as hints

Try It

copy & run

# Paste into Claude or ChatGPT (a simplified version of the paper's method: subtask-level text skill extraction)

Below is the execution log of a subtask the agent just finished.
{{subtask log}}

Write exactly one reusable experience note from this log.
- description: a generalized procedure name (e.g. "Place an order on Amazon"). Do not include specific names, products, or IDs.
- The first bullet must be "Procedure: step1 → step2 → ..." summarizing only the procedure just carried out.
- Other bullets: only surprising or non-obvious facts (parameter name mismatches, unexpected return keys, constraints).
- If it overlaps existing memory, do not write a new note; add only new facts.
- If there is nothing worth noting, leave description="".

Current skill memory:
{{existing skills}}

Try next: ask for a summary of the whole-task log instead of the subtask, then compare how reusable the two notes are on a different task.

Terminology

Skill inductionExtracting a reusable procedure note or function from a finished task trajectory and storing it in memory, like writing a post-task retrospective.

Subtask-level skillsSkills made by splitting a big task into steps like login, filtering, and ordering, with one skill per step.

SpecificityHow close a skill is to real tasks. A skill that is far from every task scores near zero.

AbstractnessHow evenly a skill's relevance spreads over many tasks instead of a few. A general utility function scores high.

ReAct loopA basic agent pattern where the model alternates actions and observations, appending each to its context.

Related Papers

Related Resources

Original Abstract (Expand)

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.