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

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

• The paper demonstrates SkillGLoW’s ability to significantly enhance AI agents' performance on long-horizon tasks, showing an average **18.0-point hard gain** and a **3.6-fold reduction in library size**
• Key techniques include global prioritization, retrieval only on substantial task matching, and second-stage verifier-grounded validation, verifying the efficiency of consolidated procedural families.
• Most effective on tasks involving procedural regularity, with numerous use-cases such as software repair, heterogeneous terminal scenarios, and mathematical reasoning, tasks commonly shared between dissimilar domains.

Problem setting and central claim

SkillGLoW addresses the organization of textual skills for LLM agents operating on heterogeneous, long-horizon task streams. Existing systems generally use one of two representations: a single continually optimized document or a flat library containing one entry per task or trajectory. The paper argues that these representations encode incompatible assumptions. A single document presumes that the workload has a dominant procedure; a flat library presumes that previously recorded entries can be reused with limited adaptation. Neither assumption is reliable when tasks differ in surface content and solution details but share intermediate procedures.

The paper’s central claim is that the appropriate unit of consolidation is the procedural family: a cluster of tasks that share a solving procedure while differing in instance-specific bindings. SkillGLoW therefore separates reusable procedural structure from local task information. It stores a global prior for each procedural family, regenerates task-local knowledge during execution, and admits global revisions only after evaluating them through real downstream execution.

The failure modes motivating this design are summarized below.

Figure 1: Single-document and flat-library organizations fail in different ways on heterogeneous long-horizon workloads, whereas procedural-family consolidation preserves shared procedure while discarding instance-specific bindings.

The distinction is substantive rather than merely architectural. A merged document can collapse into generic advice such as reading specifications, checking edge cases, and validating outputs. Conversely, a per-task entry can preserve details that are correct only for the task that generated them. SkillGLoW attempts to retain the algorithmic or operational skeleton while regenerating the bindings, constraints, and environmental facts that must be inferred afresh.

SkillGLoW architecture

The system operates over a frozen base agent and a task execution harness. Each execution produces a trajectory and a verifier score. The verifier is treated as the only authoritative signal of whether a skill changed task performance; textual quality or evaluator preference is not used as a substitute for execution.

For each task, SkillGLoW first recalls a global prior. A base prior is always injected, while at most one family prior is selected using cosine similarity between the task instruction and the committed priors. Retrieval is fail-closed: if similarity does not exceed the fixed threshold of $0.45$, the task receives only the base prior. The recalled global context remains frozen throughout the solving episode.

The agent then generates a local skill from differences between successive executions of the current task and their verifier outcomes. This local skill is not retrieved from historical experience and is never directly written into long-term memory. Instead, it supplies task-specific detail during the current episode and becomes evidence for later consolidation.

The resulting task record, or skill card, contains the task instruction, an abstract operation signature, trajectory information, verifier scores, and the local skill. Cards are embedded through multiple textual views: compact and verbose signatures, task instructions, trajectories, and full local skills. The signature channels receive the largest weights, while the full skill receives the smallest, so clustering is intended to follow procedural structure rather than lexical similarity or task subject matter.

The consolidation pipeline contains three stages: local evidence collection, procedural-family clustering and compression, and verifier-grounded admission.

Figure 2: SkillGLoW separates local execution-time adaptation from offline family-level consolidation and admits candidate priors only after real deployment evaluation.

Procedural-family clustering

SkillGLoW constructs a consensus similarity matrix from multiple hierarchical clustering configurations. It varies linkage rules and cluster counts, records pairwise co-assignment frequencies, and clusters the resulting consensus matrix. The number of families is selected automatically using the Kneedle knee criterion applied to the silhouette curve.

This procedure is designed to reduce sensitivity to an individual linkage rule or manually specified cluster count. Its conceptual target is “how the task is solved,” not “what the task is about.” The paper provides several examples in which tasks from different repositories or mathematical subfields are grouped together because their solution procedures share a common data-flow pattern. However, the approach remains dependent on the quality of textual signatures, trajectory summaries, embeddings, and LLM-generated canonical labels. The clustering mechanism does not directly observe an abstract program representation of the solution.

Each family is compressed into a candidate global prior containing three kinds of information:

• applicability conditions;
• the recurring solving procedure; and
• common failure modes.

Instance-specific file paths, object locations, thresholds, and other bindings are deliberately removed. These details are expected to be regenerated by the localizer at execution time.

Verifier-grounded admission

Compression is lossy and can generalize a rule beyond its valid scope. SkillGLoW therefore does not commit every compressed candidate. It evaluates candidate revisions using the actual execution harness and a soft verifier score. The gate compares the best candidate revision against an anchor determined by the standing library, the No-Skill baseline, and the strongest value measured in the preceding round. A candidate is admitted only if it reaches the anchor within a tolerance of $\epsilon = 0.02$.

The gate evaluates the global prior without local regeneration. This isolates the value of the consolidated library from within-task adaptation. The distinction is important: a candidate that appears useful only after substantial task-local repair has not demonstrated that the global prior itself transfers.

The gate accepted 19 of 26 admission decisions and rejected 7. Four rejected candidates would have been admitted under a consolidation-time score rather than a real deployment score. The paper reports a representative MiniMax-M3 mathematical-reasoning case in which a candidate achieved a soft score of $0.283$ during candidate evaluation but only $0.151$ when deployed, corresponding to a $13.2$-point degradation. The result supports the paper’s claim that compression-time judgments are insufficient for lifecycle governance.

Experimental design

The evaluation covers four benchmarks with different degrees of cross-task procedural sharing:

Benchmark	Tasks	Primary characteristics
Terminal-Bench-Pro	32	Heterogeneous terminal scenarios
SWE-bench Verified	20	Independent software repositories
ALFWorld	42	Recurrent embodied task procedures
LiveMathematicianBench	53	Mathematical reasoning and proof sketches

Three frozen models are evaluated: DeepSeek-V4-Pro, MiniMax-M3, and GPT-5.4-mini. This produces 12 continual-improvement runs. Each run uses three rounds and three sub-rounds, with one deployment per task in each sub-round. The study reports No-Skill, Local-only, Global-only, and Global+Local configurations. It also compares against SkillOpt, a published single-document optimizer, and evaluates flat retrieval-based controls.

The primary hard metric is benchmark-specific all-or-nothing success. Soft metrics measure partial progress, with benchmark-specific definitions. Because hard scores are sparse on long-horizon tasks, the admission gate uses the soft score while the headline comparisons emphasize hard success. This separation is methodologically defensible, although it means that the library-selection objective and the principal reported metric are not identical.

Main empirical results

The main result is that the global prior improves over No-Skill in all 12 continual-improvement runs. Global-only produces an average hard-score gain of 17.2 percentage points, while Global+Local produces 18.0 points. The corresponding soft-score gains are 13.0 and 14.6 points. Both configurations are positive in every model–benchmark cell; the paired sign test and Wilcoxon signed-rank test both yield $p = 0.000488$, the smallest attainable two-sided value for 12 paired observations.

Configuration	Mean hard gain	Mean soft gain	Positive runs
Global-only	+17.2 points	+13.0 points	12/12
Global+Local	+18.0 points	+14.6 points	12/12

The effect is not restricted to domains with obvious procedural regularity. The largest gains occur on software repair, where tasks are separate repositories and therefore provide limited direct lexical reuse. MiniMax-M3 gains 30.0 hard points and 27.7 soft points with Global+Local on SWE-bench Verified; DeepSeek-V4-Pro gains 25.0 points on both metrics. By contrast, gains on mathematical reasoning are smaller for two of the three models, ranging from 3.8 to 5.7 hard points. The paper interprets this ordering as evidence that family-level organization is most valuable when a single global procedure is inadequate but related solution structures still recur.

The comparison with SkillOpt is also favorable but not uniform. Under the paper’s aligned protocol, GLoW leads SkillOpt on 15 of 21 reported cells, while SkillOpt leads on four and ties on two. SkillOpt wins all four of its non-tied cells on ALFWorld, the benchmark where a single broad action skeleton is already appropriate. GLoW’s average hard-score margins over SkillOpt are reported as 8.3 points on Terminal-Bench-Pro, 6.7 points on SWE-bench, and 6.9 points on LiveMathematicianBench. This pattern is consistent with the paper’s granularity hypothesis: a single document is competitive when the task distribution is procedurally homogeneous.

The admitted trajectories and candidate trajectories differ materially.

Figure 3: Across 12 runs, verifier-gated libraries retain stronger deployed performance than unconditional candidate admission, especially when candidate compression produces deployment regressions.

Across the runs, the final gated libraries average a 14.7-point hard gain, compared with 9.6 points for the corresponding final-round candidates admitted unconditionally. Thus, the gate is not merely a conservative implementation detail; it prevents candidate revisions from replacing stronger deployed libraries.

Ablations and the role of granularity

The ablations test whether the gains arise from the procedural-family representation rather than from local adaptation, retrieval, or generic skill optimization.

A single compressed document, called Base-only, averages only +2.0 hard points over No-Skill. Its performance changes sign across benchmarks, ranging from a 9.3-point loss to a 16.7-point gain, and it loses on four of 12 cells. Its only consistently favorable setting is ALFWorld, where the workload contains broad shared procedures.

Local-only performs better than Base-only, averaging +10.9 points, but it does not provide durable cross-task transfer. It demonstrates that within-task regeneration is useful, not that historical skills have been effectively consolidated.

The flat retrieval control, implemented using AWM-style workflows, averages +5.0 points, with eight positive cells, three negative cells, and one unchanged cell. This is substantially below the Global-only gain of 17.2 points. Retrieval therefore does not eliminate the problem created by storing task-level entries at the wrong granularity. A flat library can select a relevant-looking entry while still transferring instance-bound assumptions.

These results support the paper’s strongest organizational claim: the relevant alternative to a global document is not necessarily better retrieval over a larger flat pool; it is a representation that consolidates at the level of shared procedure.

The paper’s ALFWorld analysis provides an external check on the clustering axis. The benchmark has six independently defined task classes, each containing seven tasks. SkillGLoW produces 15 families over 42 tasks. Thirteen families lie wholly within one benchmark class, while two cross class boundaries. The resulting purity is 0.950, although the adjusted Rand index is 0.605 because the learned families intentionally subdivide broad benchmark classes.

The cross-class families are especially informative. One groups pick-and-place and pick-two tasks through the common procedure of placing an object into a closed container. Another groups cooling-and-placement with heating-and-placement because both require an appliance transformation followed by deposition at a target receptacle. These examples indicate that the learned family structure can be finer than the benchmark taxonomy and can cross it when the operational sequence is shared.

The textual compression analysis is consistent with this behavior. A 989-word task-local skill for an ALFWorld instance includes a memorized receptacle-location table. The corresponding family prior is 440 words for its procedure section and removes the table, replacing it with an instruction to inspect the initial observation and identify the relevant object and receptacle. The implication is that compression removes bindings while preserving the action sequence and its associated failure-avoidance rules.

Transfer and compactness

The paper evaluates whether consolidated priors transfer to unseen instances without modification. On 60 unseen ALFWorld tasks, the frozen global library increases mean hard success from 73.9% to 83.9%, a gain of 10.0 points. All three models improve:

Model	No-Skill	Global prior	Gain
DeepSeek-V4-Pro	71.7%	88.3%	+16.7
GPT-5.4-mini	66.7%	75.0%	+8.3
MiniMax-M3	83.3%	88.3%	+5.0
Mean	73.9%	83.9%	+10.0

The transfer result is important because local regeneration is disabled in this comparison. The improvement therefore cannot be attributed to a task-local skill generated after observing the unseen task. It is evidence that the global priors encode reusable procedures rather than merely preserving training-instance memory. The ceiling effect is also visible: MiniMax-M3 starts with the highest baseline and obtains the smallest gain.

On a 30-instance held-out SWE-bench split, MiniMax-M3’s resolve rate increases from 40.0% to 45.6% over three trials. The smaller effect is consistent with software repair being a more difficult transfer setting: repositories differ substantially, and the procedural overlap is weaker than in ALFWorld.

The library is also substantially smaller than the per-task local-skill pool. The paper reports a 3.6-fold word-count compression in the least favorable aggregate calculation, with approximately one committed prior per procedural family rather than one entry per historical task. This compression is not obtained by simply truncating all skills. It results from replacing repeated instance-specific descriptions with shared procedural abstractions and regenerating the omitted details at execution time.

Limitations and open questions

The empirical scope is substantial but bounded. The core comparison uses 12 runs over fixed task streams, one trial per task, vendor-hosted models, and a single decoding temperature. The authors measure reproduction dispersion and report a pooled standard deviation of 2.71 points, but the statistical tests operate over the 12 model–benchmark cells rather than over independently sampled workloads. Consequently, the $p$-value establishes consistency across these runs, not universal superiority across task distributions.

The family construction depends on hard-coded multi-view weights, a fixed retrieval threshold of 0.45, and a fixed gate tolerance of 0.02. These values are shared across benchmarks and models, which limits per-cell overfitting, but the paper does not provide a full sensitivity analysis. In particular, it remains open whether the performance gains are robust to changes in embedding model, threshold calibration, cluster instability, or the number of retrieved family priors.

The gate evaluates candidate libraries on the same task stream used to generate them. Although the held-out transfer experiments are separate, the admission procedure is not based on a held-out validation stream. This creates a potential interaction between library governance and stream-specific overfitting. The paper’s fail-closed retrieval policy and real-execution gate mitigate some risks, but they do not establish distribution-free retention.

The analysis also documents genuine family-level failure. A large Terminal-Bench-Pro family containing debugging, write-ahead-log recovery, and CRC32 logic-gate tasks repaired one task but broke another. The authors report nine repairs against one regression in another terminal configuration, but the existence of such regressions shows that family consolidation can still merge procedures too aggressively. The current gate is revision-level rather than family-level, so a good update to one family can coexist with a harmful change to another inside a candidate revision.

Finally, transfer is demonstrated primarily across unseen instances within recurring benchmark categories. The conclusion explicitly leaves open whether a prior survives a genuine domain shift. Cross-model library inheritance is also untested, despite the fact that the stored priors are plain text. These are concrete unresolved questions about the portability of procedural priors, not general claims about agentic systems.

Conclusion

SkillGLoW presents procedural-family consolidation as an intermediate organizational level between a single global skill document and a flat per-task memory. Its implementation combines task-local skill regeneration, multi-view consensus clustering, de-instantiated family-level compression, frozen execution-time priors, and a verifier-grounded admission gate.

Across 12 continual-improvement runs, the method achieves 17.2 hard points of average gain with global priors and 18.0 points when local regeneration is added, while reducing the skill library by 3.6 times relative to the per-task pool. The strongest evidence for procedural rather than episodic transfer is the improvement on unmodified unseen ALFWorld tasks from 73.9% to 83.9%. The remaining uncertainty concerns robustness under genuine domain change, sensitivity to family construction and gate parameters, and transfer of consolidated priors across models.