PaperlayerView exact revision on arXiv

Source-linked AI summary

SkillGLoW: Procedural-Family Skill Consolidation for Self-Improving Agents on Long-Horizon Task Streams

Ao Yan, Xin Zhang, Jiawei Du, Joey Tianyi Zhou

arXiv:2609.02217v1cs.AI

TL;DR

Long-horizon task streams expose a gap in organizing self-generated skills: single documents become generic while flat per-task pools retain instance-bound entries. SkillGLoW consolidates execution-derived local skills into procedural-family priors, regenerates task details locally, and gates revisions by real execution; across four benchmarks and three models, it improves over no-skill baselines while using a smaller library.

  • Problem

    Long-horizon workloads with heterogeneous solutions challenge single-document and flat per-task skill organizations because shared procedures and instance-specific details have different reuse patterns.

  • Method

    SkillGLoW aggregates execution-derived local skills into procedural families, compresses shared procedures into global priors, regenerates local task details, and admits revisions through verifier-grounded execution.

  • Results

    17.2 points average hard-setting improvement over No-Skill occurred across 12 runs, with positive gains in every run; local regeneration reached 18.0 points, while the library was 3.6× more compact.

  • Takeaways & Limitations

    Unmodified priors raised unseen ALFWorld success from 73.9% to 83.9%, indicating that consolidated reusable procedure rather than task memory transfers.

  • Takeaways & Limitations

    Transfer was shown where task categories recur, while survival across a genuine domain change remains open; family quality also depends on how families are drawn.

Abstract

from arXiv · show

LLM agents increasingly self-improve by writing and reusing textual skills, kept either as one global document or as a flat pool of per-task entries, though most of the evidence comes from domains with structurally similar tasks. On long-horizon workloads where each task demands a different solution, the two forms fail in opposite ways: the document collapses into generic discipline, while the pool inflates and its entries stay bound to the instance that wrote them. We argue the missing unit of reuse is the solving procedure shared by a cluster of related tasks, and build SkillGLoW (Global-Local Weave) around it: the local skills a task writes from its own execution are aggregated into procedural families and compressed into de-instantiated global priors, while the instance detail they hold is regenerated per task rather than stored; a commit gate admits a prior only when real execution shows it does not degrade the deployed library. Across four benchmarks (mathematical reasoning, terminal automation, software repair, and embodied control) and three models, the priors gain 17.2 points (hard) over the no-skill baseline on average, with positive gains in all 12 continual-improvement runs, and 18.0 with local regeneration, while the library holds one prior per procedural family, 3.6x more compact than the per-task pool. Under the same protocol GLoW leads a published single-document optimizer on 15 of 21 cells. Unmodified, the library lifts success on unseen ALFWorld tasks from 73.9% to 83.9%, evidence that what transfers is procedure rather than task memory.

1 Introduction

Existing skill organizations assume either one dominant procedure or wholesale reuse of task-specific entries, assumptions that fail on heterogeneous long-horizon workloads. SkillGLoW instead consolidates the shared solving procedure of task families while regenerating instance details locally.

  • Long-horizon tasks quickly outgrow fixed prompts and human-written skills, motivating agents that distill reusable skills from their own execution trajectories.
  • Model-written skills can underperform the no-skill baseline, despite human-curated skills improving pass rate by 16.2 points.
  • Single documents assume one dominant procedure, whereas per-task libraries assume old entries can be reused wholesale.
  • On heterogeneous workloads, similar tasks share a solving procedure, but instance-specific constraints surface only during execution and should not be stored as reusable skill content.
  • GLoW compresses each procedural family into a stable global prior, regenerates local task detail, and revises priors only when real execution does not degrade the deployed library.
  • 17.2 points average improvement over the no-skill baseline and a 3.6× smaller library summarize GLoW’s performance and compactness across 12 continual-improvement runs.
  • GLoW’s frozen priors raise unseen embodied-task success from 73.9% to 83.9%, supporting procedural rather than task-memory transfer.

2 Related Work

Related work develops textual skill construction, optimization, retrieval, and long-term governance, but generally stores skills in a single layer. GLoW addresses the shared granularity and maintenance problem with procedural-family consolidation.

  • Prior systems discover skills as executable code or text, mine candidates from conversations, pool trajectories before distillation, or optimize a persistent document.
  • SkillOpt admits document edits only when held-out performance improves and scopes its persistent skill document to a single domain.
  • Most systems use either one continually rewritten document or a flat retrievable library, with retrieval and governance mechanisms such as deduplication and pruning.
  • Lifecycle-oriented systems freeze execution while governing library changes, add prerequisite structure, or extend maintenance to runtime and multi-agent settings.

3 Method

GLoW separates reusable procedural priors from task-local execution feedback, consolidates local skill cards into procedural families, and admits candidate revisions through measured execution.

  • 3.1 Problem Formulation: A skill is a natural-language procedure inserted into context; execution under a frozen agent returns a trajectory and verifier score.
  • 3.1 Problem Formulation: GLoW maintains a global prior library with one base prior and family priors, where the number of priors is smaller than the number of historical tasks.
  • 3.1 Problem Formulation: For each task, the recalled global context is combined with a locally regenerated skill based only on that task’s trajectory differences and verifier feedback.
  • 3.1 Problem Formulation: Library size follows the number of distinct procedures found because consolidation maintains one prior per family rather than one per task.
  • 3.2 Local Skill Construction: Localize compares multiple real executions, uses verifier feedback to retain supported operational hypotheses, and packages each task’s experience as a skill card.
  • 3.3 Procedural Clustering and Prior Compression: Procedural clustering groups cards by how tasks are solved, combining separately encoded signatures, instructions, skill text, and trajectories with fixed weights.
  • 3.5 End-to-End Procedure: GLoW’s stream pass recalls frozen priors, generates local evidence, clusters cards automatically, compresses families, and forms candidate revisions without storing local skills in the library.
  • 3.3 Procedural Clustering and Prior Compression: Consensus clustering varies linkage rules and cluster counts, then derives families from pairwise co-occurrence frequencies.

4 Experiments

Across four benchmarks and three models, SkillGLoW improves continual learning over No-Skill while consolidating skills by procedural family. Its gains persist on heterogeneous tasks, outperform alternative organizations, and transfer to unseen instances, though family construction can affect outcomes.

  • Setup: The evaluation spans mathematical reasoning, terminal automation, software repair, and embodied control across three models and 12 continual-improvement runs.The benchmarks contain heterogeneous repositories and terminal scenarios as well as more procedurally shared tasks.
  • Main results: 17.2/13.0 points (hard/soft) are the average gains of frozen priors over No-Skill across 12 runs.With local regeneration, gains rise to 18.0/14.6 points; both settings improve in every run.
  • Comparisons: GLoW leads SkillOpt on 15 of 21 cells, while SkillOpt leads on four and ties on two.GLoW’s hard-score margins average +8.3 on TBP, +6.7 on SWE, and +6.9 on LMB; SkillOpt’s wins are all on ALFWorld.
  • Organization: The deployed library is 3.6× more compact than the per-task pool because it stores one prior per procedural family.The family layer addresses the mismatch between a single global document and instance-bound entries; retrieval over a flat pool does not close the gap.
  • Admission: The gate accepts only candidates that survive real deployment, retaining +14.7 points in the final round versus +9.6 for unconditional candidates.It accepted 19 of 26 decisions and rejected seven; four of those seven would have passed a consolidation-time score alone.
  • Analysis: Family alignment determines transfer: one prior fixes three different ALFWorld objects, while a large heterogeneous terminal family repairs one task and breaks another.A second model forms smaller terminal families, showing that procedure sharing depends on how families are drawn.
  • Analysis: All three models improve, with the smallest gain for the model having the highest baseline, consistent with a ceiling effect.This pattern is reported for the transfer analysis.
  • Transfer: On unseen software-repair instances, the library raises MiniMax-M3’s resolve rate from 40.0% to 45.6%.The result covers 30 unseen instances, each from a different repository.

5 Conclusion

SkillGLoW addresses heterogeneous long-horizon task streams by consolidating shared solving procedures into compact priors while regenerating task-specific detail. Across continual-improvement runs, this approach improves performance and transfers to unseen tasks, while domain-change and cross-model inheritance remain open.

  • 17.2 points over No-Skill is the average gain from procedural-family priors across 12 continual-improvement runs.The library is 3.6× smaller than the per-task pool.
  • Procedural families consolidate de-instantiated priors, while instance detail is regenerated per task instead of stored.Priors enter the library only when measured execution shows they do not degrade the deployed library.
  • 73.9% to 83.9% is the transfer improvement on unseen ALFWorld tasks using the unmodified library.The result is presented as evidence that consolidated knowledge transfers as procedure rather than task memory.
  • Whether priors survive a genuine domain change and whether libraries can transfer across models remain untested.The paper notes cross-model inheritance is possible in principle because priors are plain text.

A Metric Definitions

The appendix defines hard and soft evaluation measures, explains the commit-gate scoring choice, and documents the deployed representation, weighting, baselines, and alignment controls.

  • Metric Definitions: Hard is the benchmark’s all-or-nothing flag, while soft is continuous partial credit; ALFWorld soft scores come from the authors’ verifier.
  • Metric Definitions: Table A1 reports hard and soft scores one benchmark at a time, with per-benchmark columns providing the comparable read-outs.Average soft scores across benchmarks should be interpreted only as relative movement within a row because the scales differ.
  • Metric Definitions: The commit gate uses soft scores because sparse hard outcomes can give the wrong verdict on long-horizon tasks.The cited example compares candidate 0.283 with deployed 0.151, both on soft scores.
  • Representation and weighting: Each local skill card uses up to five L2-normalized view vectors whose weighted sum forms ϕ(c), with runtime tiers determined by available fields.The deployed tiers and channels are documented in Tables A2 and A3.
  • Representation and weighting: Signature channels receive the greatest combined weight, 0.50 in both deployed tiers, while full skill text receives the least.Missing channels fall back to task instructions, and weights accumulate through an exponential moving average with α = 0.2.
  • Baseline alignment: The SkillOpt comparison holds task sets, models, trials, thinking, turn limits, and scoring identical across implementations.The baseline uses a neutral 99-byte skeleton so gains are attributed to the optimization loop rather than human initial skills.

C.2 AWM

AWM induces shared workflows from batches of attempted tasks and injects one globally retrieved document, whereas GLoW forms procedural families, gates updates through execution, and recalls per task. Under the shared evaluation, GLoW shows larger and more consistently positive gains.

  • C.2 AWM: AWM extracts recurring workflows from already-attempted task batches and prepends the resulting document to the agent prompt.The port replaces the web-specific example with one using the target benchmark’s action vocabulary.
  • C.2 AWM: AWM retrieval is global: every test task queries one index, and the pooled top-k results are injected identically into every task.The port sets top-k to 3 rather than the official default of 10.
  • Results: AWM’s twelve-cell results are eight up, one flat, and three down, with median gains of ↑2.7 and ↑1.7.
  • Results: AWM averages +5.0 across twelve cells, while GLoW’s Global arm is samesigned in 12/12 cells with a +17.2 mean.The comparison uses gains against No-Skill on the same scale and cells.
  • Results: GLoW’s advantage is largest on LMB, where AWM averages zero across models while GLoW’s Global arm averages the reported positive gains.The passage attributes the difference to family formation, execution-based admission, and per-task recall.

D.1 Paired Tests Across Runs

The paired analysis compares Global against No-Skill on identical tasks and evaluates only committed, deployed libraries. Across twelve runs, gains are consistently positive, while the commit gate excludes candidates that fail its execution-based standard.

  • Paired results: The paired tests establish significance at the level of twelve runs, not individual cells.With every difference positive, the paired test reaches p = 2/2^12, the smallest attainable at n = 12.
  • Peak read-out: GLoW reports peaks only from committed libraries that were actually deployed, excluding higher-scoring rejected candidates.In the last round, the deployed trajectory is +14.7 pp versus +9.6 pp for the candidate, leaving the retained library 5.1 pp higher.
  • Gate decisions: The gate uses a measured anchor based on the standing library and No-Skill baseline, with tolerance ϵ = 0.02 and an additional previous-round floor.Candidates are adjudicated through real deployment rather than held-out evaluation.
  • Compression: The reported compression ratio compares final committed global priors with final per-task local skills using both entry and word counts.Intermediate local snapshots are excluded from the denominator.
  • Compression: 3.6× compression is the body’s reciprocal last-round word ratio, chosen as the least favourable of the available aggregations.Pooling word counts gives 3.8×, while averaging per-cell reciprocals gives 4.1×.

F.1 ALFWorld Held-Out

The ALFWorld held-out evaluation tests whether a frozen prior transfers without modifying the library or regenerating local skills. The prior improves performance on an official unseen split, and all three models move in the same direction.

  • Evaluation setup: The Global column evaluates a frozen consolidated prior alone on 60 official unseen ALFWorld tasks.No local regeneration or library modification is used for these tasks.
  • Across models: All three models improve, while MiniMax-M3 gains least despite starting highest, consistent with a ceiling effect.The held-out evaluation uses the unchanged committed library.
  • Additional held-out result: The reported SWE held-out comparison is 40.0 →45.6 mean resolve rate over three trials on the disjoint 30-task split.This matched pair uses MiniMax-M3.

G.1 Agreement With the Dataset’s Labels

Family assignments are evaluated against ALFWorld’s six canonical task types and against concrete terminal-task procedures. The evidence indicates that procedural families can be finer-grained than semantic task labels while preserving procedural alignment.

  • Label agreement: ALFWorld provides seven tasks in each of six solution-type categories for evaluating family-label agreement.The comparison uses externally defined solution-type labels rather than labels created by the algorithm.
  • Label agreement: K = 15 families yields high purity and middling ARI because families intentionally split canonical types rather than mix them.Five families are singletons, and the remaining 35 tasks retain purity 0.943 after removing them.
  • Procedural cross-cuts: Two ALFWorld families cross-cut canonical types where goals differ but the procedural skeleton remains identical.One example swaps cooling and heating before placing an Egg in a microwave or fridge.
  • Terminal mapping: In the terminal mapping, the stripped_binary_feature-flag family splits tasks by byte-level solving procedure rather than binary-related subject matter.Its prior begins by scanning repeated markers, validating a candidate manifest, and decrypting bitmaps.
  • Terminal mapping: The terminal family test uses actual solution procedures from trajectories and verifier outcomes, not clustering quality as an input.The mapping covers ten families over 32 tasks, including nine repairs against one pass-to-fail.

H Benchmarks and Splits

The benchmark protocol fixes task streams and splits across models, runs, and methods, while measuring continual improvement through repeated deployments. It also quantifies reproduction variability and keeps hyperparameters shared across all cells.

  • Splits: All four task streams use fixed split files across rounds, twelve runs, and both compared methods.The sampled splits and traversal order use seed=42, while ALFWorld uses a deterministic selection.
  • Held-out evaluations: The study has exactly two held-out evaluations, drawn from different sources and listed separately from the four training streams.Their different origins imply different evidential roles without changing the fixed-stream protocol.
  • Continual protocol: Each continual run uses 3 rounds × 3 sub-rounds and one trial per task, with one real deployment over the stream per sub-round.The twelve runs share this loop size.
  • Training cost: The three candidate routes require no extra rollouts because their scores are read from the nine existing deployments.Candidate admission is settled by the first deployment of the next round within the same budget.
  • Reproduction spread: 2.71 pp is the pooled within-group standard deviation from 18 repeated round-0 No-Skill measurements.The main-table Global gain of 17.2 points is 6.4 times this spread.
  • Resolution: Single-cell resolution is approximately ±5.4 pp at two standard deviations, so significance at twelve runs does not establish significance for one cell.This resolution comes from measured repetitions rather than an iid-task assumption.
  • Hyperparameters: One hyperparameter setting is shared across all four benchmarks and three models, without cell-specific tuning.The protocol therefore reports no sensitivity analysis for those values.

L Compute Environment

The compute environment is documented in Table A22, including a measured WSL2 memory constraint and bounded concurrency for SWE and TBP. The consolidation pipeline uses benchmark-independent prompt templates, with run selection based on family-structure balance.

  • Compute Environment: The compute environment is summarized in Table A22, with GPU use limited to embedding retrieval rather than base-model inference.WSL2 memory was lowered from 24 GB to 21 GB after a fully loaded SWE run exhausted host memory, constraining SWE and TBP concurrency.
  • Prompt Templates: The consolidation pipeline uses 24 prompt templates phrased benchmark-independently, without benchmark names, task identifiers, or answers.The five core prompts are deployed in pipeline order, with placeholders filled by card content at run time.
  • Run Selection: Each benchmark run is selected by family-structure balance, using ARI against labels for ALFWorld and size-distribution balance for the other benchmarks.Prior counts include one unconditional base prior, so they equal the number of families K plus one, while Table 3 counts family priors only.

N.2 Family Names and the Clustering Axis

SkillGLoW groups tasks by shared solving procedures rather than surface subject matter, then compresses each procedural family into a global prior. Family names are generated after clustering and can therefore reflect member wording without defining the clustering axis.

  • N.2 Family Names and the Clustering Axis: Family names are generated after clustering from salient member wording, so repository or mathematics names do not define family membership.The namer sees only text within a family, while multi-member SWE families cross repositories and LMB families cross mathematics branches.
  • N.2 Family Names and the Clustering Axis: Local skills are extracted after a task changes from failing to passing, with de-instantiation enforced at the top of the pipeline.The extraction prompt requests minimal reusable procedure knowledge focused on steps, checks, and calls.
  • N.2 Family Names and the Clustering Axis: Tasks are grouped by whether one reusable procedure could correctly accomplish both, judged by underlying operations and data flow rather than surface wording.Pairwise procedure judgment is the LLM channel used for clustering.
  • N.2 Family Names and the Clustering Axis: Family compression gathers each family’s local skills into one candidate global prior.This compression is described as Eq. (3), and the compressor may return a short generic result rather than forcing a procedural step.
  • N.2 Family Names and the Clustering Axis: Append-only repair changes performance by ↑3.1 for DeepSeek, ↓3.4 for GPT, and ↑4.8 for MiniMax-M3, so candidate routes are adjudicated by the commit gate.The sign flips with the model, and all three candidate routes are sent through the same gate.
  • N.2 Family Names and the Clustering Axis: The family library reaches 0.467 on LMB val15 with 0.42× the entries of a flat library 2.4 times its size.Both family arms are above the median of the four flat arms in this single-trial, 15-task validation comparison.
Loading 2609.02217v1…