Pith.

Artificial Intelligence · arXiv:2608.20274 v2 · submitted 20 Aug 2026

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

Yiyang Feng, Biddut Sarker Bijoy, Niranjan Balasubramanian, Jiawei Zhou

The paper says

“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.”

more of the abstract

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.

from the abstract

Pith says

Machine review · deepseek-v4-flash · 27 Aug 2026 · of version 1 of the paper; version 2 is newer · what was read was not recorded · not checked by a person

It can be wrong. Challenge this review or reply to it.

Holds up, with conditions. Subtask-level induction genuinely helps and task-level hurts — that result is solid — but the second headline, text skills beat code skills, is confounded by different retrieval instructions in App. A Fig. 14 that no experiment controls. This line is wrong

2 major objections · 8 minor

How often objections from reviews like this one are right: not yet measured

Are you an author? What you can do.

Not checked: figures, code, what the references say.

The paper says, at 5.2; App. A, Fig. 14

The review did not quote this passage.

Pith says: Objection 1 of 2 · major

Section 5.2 and Appendix A (Fig. 14): the text-versus-code comparison is not a controlled comparison of skill representation because the two arms receive different retrieval framings. Text skills are framed as 'HINTS, not ground truth ... Adapt or ignore,' while code skills are framed as 'REFERENCE, not ground truth ... write your OWN code for THIS task.

more of objection 1

Do NOT blindly call a stored function.' The code framing instructs the agent to discount the very content being tested, so the observed ranking (text ahead by 1.4 points on the task-level agent and 2.9 points on the subtask-level agent in Tab. 2) could be an artifact of instruction wording rather than of the text versus code representation. The paper's own validations do not close this gap: App. E.6 (Tab. 6) shows code skills self-retrieve at least as well as text skills, which rules out retriever quality, but a skill that is retrieved and then deliberately bypassed because the framing says to write one's own code would produce exactly the observed pattern; and App. E.5 shows code skills are retrieved as often or more often yet help less, which is equally consistent with framing-induced discounting. Since this format ranking is a headline takeaway and also feeds the utility-score explanation in Sec. 6.2, I would ask for a condition that holds the framing fixed while varying only the skill body, or a crossed-framing condition (text skills delivered under the code framing and vice versa).

The paper says, at 6.1-6.2; App. E.4

The review did not quote this passage.

Pith says: Objection 2 of 2 · major

Sections 6.1-6.2 and App. E.4 (Tab. 4): the skill utility score, presented as a predictive diagnostic, is fitted and evaluated on the same data in ways that overstate its standing. Specificity and abstractness are computed under the retrieval embedder (all-MiniLM-L6-v2), the same model that decides which skills enter the agent's context, so the monotone bin relationship in Fig. 5a and …

more of objection 2

… the near-flat utility across difficulty levels in Tab. 5 may partly reflect the retriever's own ranking rather than an independent property of the skills. The product form is introduced after the tradeoff in Fig. 27 is observed, and the temperature tau=0.1 is a free parameter with no sensitivity analysis, so the reported correlation is a post-hoc fit on the same data. The causal split in App. E.4 (Tab. 4) yields differences of 1.1-1.4 points with heavily overlapping 95% confidence intervals, weaker than the surrounding text implies. To support the abstract's claim that the score is a practical diagnostic, I would ask for a sensitivity analysis of tau (e.g., 0.02, 0.05, 0.2, 0.5), an evaluation in which the score is computed with an embedder different from the retriever's, or a held-out regression comparing specificity, abstractness, and their product.

8 minor objections

The paper says, at 6.2, first paragraph

Pith says: minor objection 1 of 8

Section 6.2 opens with 'We examine whether skill utility explains accounts for the results of Sec. 5'; the duplicated verb 'explains accounts' should be repaired.

The paper says, at 5.1; App. E.3

Pith says: minor objection 2 of 8

In Sec. 5.1 and App. E.3 the shares of skills induced from unsolved tasks are called 'close rates,' but for Code they differ by 7.2 points (83.0% vs 75.8%); since the worst-performing condition (Task+Code) is the one with more failed sources, the claim that source outcomes cannot explain the level effect should be qualified or tested.

show 6 more

The paper says, at Tab. 2 caption; Fig. 4 caption

Pith says: minor objection 3 of 8

The captions of Tab. 2 and Fig. 4 make absolute cross-agent statements ('the highest success falls in a Subtask-level column'; 'the subtask-level agent with skills stays above the task-level agent with skills') that are not protected by the within-agent cancellation argument of Sec. 3.3; either mark these as systems-level comparisons or restrict them to within-agent memory effects.

The paper says, at 3.2, Skill retrieval

Pith says: minor objection 4 of 8

In Sec. 3.2 the subtask-level agent 'queries at each subtask with the task instruction or the subtask text'; please specify which query string is embedded, since retrieval is part of the treatment.

The paper says, at 6.1

Pith says: minor objection 5 of 8

The utility score is computed from the natural-language description only, not from the skill body; state this explicitly, since the term 'skill utility' could be read as scoring the body.

The paper says, at 6.3, Fig. 6

Pith says: minor objection 6 of 8

Transfer density in Sec. 6.3 is reported as a single pooled number per benchmark without confidence intervals or per-model spread; please report the variance across the eleven models.

The paper says, at Tab. 2

Pith says: minor objection 7 of 8

Per-model heterogeneity is large (e.g., Qwen3-235B-A22B improves from 7.4 to 18.0 on AppWorld with task-level Text skills while GPT-OSS-120B drops from 27.3 to 17.0), so the headline 'task-level skills mostly reduce performance' rests entirely on averages; a per-model interaction plot or breakdown would help readers gauge the consistency of the effect.

The paper says, at 6.2, Tab. 5

Pith says: minor objection 8 of 8

The difficulty-stratified analysis in Sec. 6.2 is described as supporting a 'causal effect of skill utility,' but it is correlational; only the median-split replay in App. E.4 is an intervention, and its confidence intervals overlap (see major comment 2).

What would settle it

Swap the two framing blocks in App. A Fig. 14 while keeping the skill bodies and retrieval identical: present code skills under the text framing ('HINTS, not ground truth; adapt or ignore') and text skills under the code framing ('write your OWN code; do not blindly follow'). Run the format comparison on at least two representative models (e.g., Qwen3-32B and Gemini-3.1-Pro) on OfficeBench, the benchmark with the largest text-vs-code gap. If text still beats code under both framings, the representation claim is robust. If the ranking flips, shrinks, or collapses, the headline format result is caused by the instruction prompt, not by the skill format.

from the skeptic's reading

How the review went

4 readings by deepseek-v4-flash · 27 Aug 2026

  1. Reader holds up, with conditions confidence moderate
  2. Skeptic agrees 47 s · 39,856 tokens read, 5,078 written
  3. Editor wrote the verdict above 54 s · 40,625 tokens read, 6,528 written
  4. Referee major revision: 2 major objections, 8 minor 2 min 39 s · 40,153 tokens read, 18,451 written

Not run on this paper: the simulated authors' defence.

Pith did not check this review's objections against the paper.

The review in full

The review in brief, machine-written

The one thing to know: the subtask-level skill induction result is real and well supported; the second headline, that text skills transfer better than code skills, rides on a confound the authors never controlled.

What's new: prior subtask-level work (SSO, MUSE, Shen et al.) stayed narrow. This paper is the first controlled crossing of induction level with skill format at this scale — three long-horizon benchmarks, eleven models, official evaluators, bootstrap CIs, one shared induction prompt. The design is careful and the checks are the right ones. The E.2 control (task-level agent handed the subtask-level library flips from harmed to helped) pins the effect on the skills rather than the architecture. E.3 rules out source-task quality; E.6 rules out retriever quality. The survey table is balanced and cites work that cuts against the authors' own story. Code and data are promised under MIT.

Soft spots, in proportion. The stress-test note holds up. App. A Fig. 14 frames text skills as "HINTS... Adapt or ignore" but tells the agent to "write your OWN code for THIS task. Do NOT blindly call a stored function" for code skills. The agent is being explicitly told to discount the code content being tested. No experiment holds the framing fixed while varying the format, so "text > code" may as easily be "permission > caution." This does not touch the induction-level result — both formats face their framing symmetrically across levels — but the abstract's format claim is overstated as written.

The skill utility score is a reasonable cheap diagnostic, but the causal support is thin: tau and the product form are fit on the same data, and the split-half experiment (E.4) shows 1.1- and 1.4-point gaps with overlapping CIs. Directionally consistent, not decisive. Minor gap: no seed-level variation reported, and the low absolute scores on most models put weight on a few strong ones; the within-agent comparisons keep the level effect robust to that.

Also clean: the Limitations section is honest about scope, and the appendix discloses AI-assistant use in writing.

Who it's for: anyone building skill-memory agents. The practical guidance — decompose before inducing, prefer notes, use the utility score for pruning — is concrete and mostly credible. This deserves a serious referee; the fix is one controlled experiment swapping the retrieval framing while varying the format. Send it out, and ask for that control.

The strongest objection

The headline format ranking (Sec. 5.2) is not a controlled comparison of skill representation. App. A Fig. 14 wraps retrieved text skills in one instruction set ('HINTS, not ground truth... Adapt or ignore') and retrieved code skills in a different, markedly more cautionary one ('Treat them as REFERENCE... write your OWN code for THIS task. Do NOT blindly call a stored function'). The code framing explicitly tells the agent to discount the very content being tested, while the text framing invites the agent to follow the note. Since the format comparison is a central takeaway and also feeds the utility-score analysis in Sec. 6.2, the conclusion 'text skills transfer better than code skills' could be an artifact of these differing retrieval instructions rather than of the text versus code representation. The paper's own validation does not close this gap: App. E.6 shows code skills self-retrieve as well as or better than text skills, which rules out retriever quality, but a code skill that is retrieved and then deliberately ignored because the prompt says not to trust stored functions would produce exactly the observed pattern. No experiment in the paper holds the framing fixed while varying the skill format.

The paper's strongest and best-supported result is the induction-level effect: within-agent comparisons show task-level skills harm and subtask-level skills help, and the E.2 cross-agent replay independently corroborates that the effect travels with the skills. The most load-bearing weakness is the format axis, because 'text skills transfer better than code skills' is both a headline takeaway and a component of the utility-score story, and the two format arms are not prompted equivalently. Fig. 14 gives text skills a permissive 'adapt or ignore' framing, while code skills receive an explicit 'write your OWN code' and 'do NOT blindly call a stored function' warning. That asymmetry is a direct confound: a model told to distrust stored functions will likely under-use code skills, producing lower code-skill performance regardless of whether the code representation is actually worse. E.6 addresses retrieval quality, not this instruction effect, since a skill can be retrieved and then ignored. I also considered the utility-score evidence, which is weaker (the median-split causal test in E.4 has overlapping confidence intervals), but that is secondary to the transfer claim. The reader's weakest assumption is therefore the right one, and the CONDITIONAL verdict remains appropriate: the level effect stands on strong controls, but the format ranking must survive an identical-framing test before the paper's full claim is accepted.

The referee's report

If the claims hold, the strongest contribution is the level effect: an unusually broad controlled evaluation (three benchmarks, eleven models, official evaluators, within-agent baselines, a cross-agent control in App. E.2 where the task-level agent retrieves subtask-level skills, a source-outcome control in App. E.3, and an induction-prompt ablation in Fig. 26). The paper ships its code, prompts, and skill libraries, the full prompts are reproduced in the appendix, and the headline comparisons are falsifiable. Two load-bearing points need work before the claims as stated can stand: (i) the text-versus-code ranking in Sec. 5.2 is confounded by the different retrieval framings shown in App. A, Fig. 14, so the format conclusion may reflect instruction wording rather than representation; and (ii) the skill utility score in Sec. 6 is computed with the retrieval embedder, with the product form and temperature fitted post hoc on the same data, and its independent validation (App. E.4, Tab. 4) has heavily overlapping confidence intervals. Neither issue undermines the within-agent level effect, which is well supported.

Pith's reading of the paper (a machine's summary, not the authors')

The paper tries to establish when an LLM agent's self-induced skills transfer reliably to later tasks, and it answers with a controlled comparison: the induction level decides whether memory helps at all, while the skill format decides how much. Across three long-horizon benchmarks (AppWorld, OfficeBench, KramaBench) and eleven models, skills distilled from whole-task trajectories lower the agent's average success (by 1.2 points as text and 4.1 as code, and by up to 7.4 on a single benchmark), while the same induction prompt applied to single subtasks raises average success (by 1.9 points as text and 0.5 as code). Text skills transfer better than code skills at both levels, and the paper proposes a skill utility score -- the product of specificity and abstractness -- that is computed from skills and task descriptions alone and predicts which skills will help. If the conclusions hold, practitioners get a concrete recipe: decompose tasks, store one text note per subtask, and screen the memory with the utility score before letting it influence any new task.

What carries the argument. The load-bearing object is the skill utility score, the product of two complementary properties. Specificity captures how closely a skill matches the real tasks it most resembles, defined through the probability that the skill's nearest-task cosine similarity exceeds the similarity between two random tasks; abstractness captures how evenly the skill's relevance spreads over many tasks, defined as the normalized entropy (perplexity) of a softmax temperature-scaled similarity distribution over all task descriptions. Because both are computed from skill embeddings and task descriptions only, the score needs no task execution, so it can diagnose a skill memory before any new task runs. The machinery explains the two headline effects: specificity and abstractness trade off, and only their product rewards a skill that is both close to real tasks and spread across many of them.

Core claim. On its own terms, the paper's central claim is that cross-task skill transfer is governed by two separable choices and one measurable property of the skills. Task-level induction is net harmful: skills induced from whole trajectories drag the agent below its no-memory baseline on every benchmark, by an average of 1.2 points (Text) and 4.1 points (Code). Subtask-level induction is net helpful: the same prompt, run on individual subtasks, lifts average success by 1.9 points (Text) and 0.5 points (Code), with Text helping on all three benchmarks. The format ranking holds at both levels and at every task difficulty, and it survives cost-matched efficiency curves. The paper accounts for these results with the skill utility score $\mathrm{utility}(s)=\mathrm{specificity}(s)\cdot\mathrm{abstractness}(s)$: specificity is the probability that a skill is closer to its nearest task than two random tasks are to each other, and abstractness is the normalized perplexity of its similarity distribution over tasks. Neither dimension alone predicts success, but their product rises monotonically across task-success bins, ranks subtask-level and text skills higher, and a library's high-utility half outperforms its low-utility half on the same tasks.

The premise it rests on. The comparison of text and code skills assumes the induction and retrieval instructions are equivalent across formats, but the framing differs: retrieved text skills are introduced as 'HINTS, not ground truth' with 'Adapt or ignore', while retrieved code skills are introduced with 'write your OWN code' and 'Do NOT blindly call a stored function'.

If the paper is right (Pith's inferences, not the authors')

Decompose tasks before inducing memory: storing one skill per completed subtask is the only tested configuration in which skills raise average success, while whole-task skills mostly hurt.

A skill memory is not automatically beneficial; on the task-level agent, adding text skills costs 1.2 average points and code skills cost 4.1, so an agent may be better off with no memory at all.

Store transferable procedures as text notes rather than Python functions, since text skills beat code skills at both induction levels and at every task-difficulty stratum.

Skill utility can be used as a cheap, execution-free filter: tasks that retrieve higher-utility skills succeed more, and the high-utility half of a library beats the low-utility half on the same tasks.

The subtask-level advantage is not an efficiency illusion: at equal latency and dependency budgets, the subtask-level agent with skills overtakes the task-level agent once budgets pass the smallest values.

The format comparison is not fully controlled: retrieved text skills are framed as 'HINTS, not ground truth' with 'Adapt or ignore', while code skills are framed as 'write your OWN code' and 'Do NOT blindly call a stored function'. If these divergent instructions cause agents to discount code skills, the text-over-code ranking may reflect prompting rather than representation; swapping the framings

Because utility needs only embeddings of skills and task descriptions, it could be deployed online to prune a growing skill memory before retrieval, and the same score might flag injected or malicious skills for rejection rather than reuse.

The score's predictive form suggests a testable extension to settings the paper did not run -- computer-use agents, agentic coding, and web search -- by checking whether the specificity-abstractness product, computed from their skill descriptions, reproduces the same monotone success-utility relationship.

Check this review

Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.

How often reviews like this one are right

Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.

How often objections from reviews like this one are right: not yet measured

Every value above, in the review's public record (JSON)

Reviews by people

This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.

Request a human review

How Pith checks papers · The full audit of this paper

The paper

Abstract

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.

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.

abstract compiled · 2026-09-23

The authors' main claim, as the classifier picked it out 0.93

“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.”

How the main claim is stated: asserted 1.00

What the abstract itself states, as probabilities: claims first 0.05 · states limitation 0.48 · human participants 0.04 · controlled comparison 0.95 · randomized assignment 0.03 · states quantitative result 0.09 · compares with prior results 0.90 · mentions code or data availability 0.03

The abstract, sentence by sentence

This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.

SentenceRoleThe authors' own workStates the main conclusionStrength
Large language model (LLM) agents can induce skills from completed tasks and reuse them later to grow more capable with experience. background 1.00 0.07 0.03 asserted 0.76
In practice, induced skills may transfer unreliably and can even harm the agent that retrieves them. background 0.94 0.11 0.03 hedged possibility 0.98
When agent-induced skills transfer reliably across tasks remains an open question. gap 1.00 0.04 0.02 asserted 0.91
We conduct a comprehensive and controlled study of how the way skills are induced shapes their transfer across tasks. contribution 0.97 0.93 0.03 asserted 0.94
Specifically, we compare task-level with subtask-level skill induction and text with code skill formats, the two axes along which existing methods differ. method 0.83 0.45 0.05 asserted 0.89
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. result 1.00 0.95 0.71 asserted 1.00
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. method 0.63 0.84 0.05 asserted 0.98
Neither property alone predicts task success, but their combined effect does, which we propose as a skill utility score. result 0.39 0.93 0.24 asserted 0.94
The score correlates consistently with task success when skills are transferred, and subtask-level and text skills score higher. result 0.99 0.95 0.25 asserted 0.99
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. interpretation 0.58 0.88 0.10 asserted 0.96

What kind of paper the classifier reports this is: empirical study 0.99 · evidence from observation or experiment 0.99

What was examined, and what was not

Sources read

  • arXiv listing abstract v1

Not examined

  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers

Levels run

  • P abstract

Not run

  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

How the labels were made

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 7,481 input tokens.

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON

Figures (28)
Figure 1 of the paper
Figure 1. Different tasks share subtasks. A task-level skill
Figure 2 of the paper
Figure 2. Illustration of two skill induction levels and two skill formats. (
Figure 3 of the paper
Figure 3. Task success rate within a per-task budget of de
Figure 4 of the paper
Figure 4. Task success of the six conditions by task difficulty, pooled over models with 95% task-bootstrap confidence intervals.
Figure 5 of the paper
Figure 5. Skill utility against the results. (a): Each task is scored by the average utility of the agent-retrieved skills and ranked
Figure 6 of the paper
Figure 6. Transfer density. The task stream of each benchmark
Figure 7 of the paper
Figure 7. Execution core on AppWorld, the system prompt shared by both agents. Each subtask-level role appends its role block
Figure 8 of the paper
Figure 8. Execution core on OfficeBench, the system prompt shared by both agents. Each subtask-level role appends its role
Figure 9 of the paper
Figure 9. Execution core on KramaBench, the system prompt shared by both agents. Each subtask-level role appends its role
Figure 10 of the paper
Figure 10. Role blocks of the subtask-level agent on AppWorld. Each block is appended to the execution core of Fig.
Figure 11 of the paper
Figure 11. Role blocks of the subtask-level agent on OfficeBench. Each block is appended to the execution core of Fig.
Figure 12 of the paper
Figure 12. Role blocks of the subtask-level agent on KramaBench. Each block is appended to the execution core of Fig.
Figure 13 of the paper
Figure 13. User messages of the three subtask-level roles. The progress summary starts as a fixed no-progress line, and the live
Figure 14 of the paper
Figure 14. Framing wrapped around the text and code skills retrieved for the linear and subtask-level agent.
Figure 15 of the paper
Figure 15. Text-skill induction prompt on AppWorld, appended as a user message to the span being distilled. The same prompt
Figure 16 of the paper
Figure 16. Text-skill induction prompt on OfficeBench, appended as a user message to the span being distilled. The same prompt
Figure 17 of the paper
Figure 17. Text-skill induction prompt on KramaBench, appended as a user message to the span being distilled. The same
Figure 18 of the paper
Figure 18. Code-skill induction prompt on AppWorld, appended as a user message to the span being distilled. The same prompt
Figure 19 of the paper
Figure 19. Code-skill induction prompt on OfficeBench, appended as a user message to the span being distilled. The same
Figure 20 of the paper
Figure 20. Code-skill induction prompt on KramaBench, appended as a user message to the span being distilled. The same
Figure 21 of the paper
Figure 21. The task-level text skill induced from the example task. One workflow note spans the whole trajectory from login to
Figure 22 of the paper
Figure 22. The task-level code skill induced from the same task. One function reproduces the whole trajectory and keeps the
Figure 23 of the paper
Figure 23. The subtask-level text skills induced from the same task, one note per completed subtask.
Figure 24 of the paper
Figure 24. The subtask-level code skills induced from the same task, one function per completed subtask.
Figure 25 of the paper
Figure 25. Task success of the task-level agent retrieving its
Figure 26 of the paper
Figure 26. Subtask-level induction stays ahead of task-level
Figure 27 of the paper
Figure 27. The tradeoff between the two terms of the skill
Figure 28 of the paper
Figure 28. Task success reachable within a per-task budget

Figures are the authors', reproduced from the paper.

Cited by 2 Pith papers

Reviewed papers on Pith that cite this one. The full citation record

  1. After the Fix: Transfer of Corrected Agent Experience cs.AI · Sep 2026
  2. Mining Agent Skills from Production Traces cs.AI · Oct 2026
How the literature uses it

What this paper does with the arXiv papers it cites

Each citing sentence is taken from the citing paper's LaTeX source and typed by Pith's classifier. A label appears at probability 0.8 or more (0.95 for support), a contest at 0.7 or more; the quoted words are the citing authors'. How each label was checked · JSON

What it cites · 11 sentences without a confident label

Cites as support 2 papers
Cites as background 7 papers
  • Skills in agents A line of work consolidates an agent's experience into an explicit skill memory [ref] , differing along three axes ( [ref]): (i) the skill induction level, including a trajectory [ref] , a step [ref] , a rule [ref] , or a subtask [ref] ; (ii) the skill format, including text [ref] or code [ref] ; and (iii) the induction prompt, with various instructions, demonstrations, and abstraction rules [ref] .

    Ghost in the Minecraft: Generally Capable Agents for Open-World Environments via Large Language Models with Text-based Knowledge and Memory · Related Work · 0.99

  • Skills in agents A line of work consolidates an agent's experience into an explicit skill memory [ref] , differing along three axes ( [ref]): (i) the skill induction level, including a trajectory [ref] , a step [ref] , a rule [ref] , or a subtask [ref] ; (ii) the skill format, including text [ref] or code [ref] ; and (iii) the induction prompt, with various instructions, demonstrations, and abstraction rules [ref] .

    Memory in the Age of AI Agents · Related Work · 0.99

  • Skills in agents A line of work consolidates an agent's experience into an explicit skill memory [ref] , differing along three axes ( [ref]): (i) the skill induction level, including a trajectory [ref] , a step [ref] , a rule [ref] , or a subtask [ref] ; (ii) the skill format, including text [ref] or code [ref] ; and (iii) the induction prompt, with various instructions, demonstrations, and abstraction rules [ref] .

    Reinforcement Learning for Self-Improving Agent with Skill Library · Related Work · 0.99

Challenges and discussion

Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.

No comments yet.

Sign in to comment