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

> SkillGLoW organizes LLM agent skills into procedural families, compressing shared solving procedures globally while regenerating instance details locally, gaining +17.2 points over no-skill baselines with a 3.6x more compact library.

- **Source:** [arXiv](https://arxiv.org/abs/2609.02217)
- **Published:** 2026-09-12
- **Permalink:** https://picx.dev/p/4R1Cbp
- **Whiteboard:** https://picx.dev/p/4R1Cbp/image

## Summary

## Summary (Overview)

- **Core contribution**: SkillGLoW (GLoW) introduces the **procedural family** as the missing unit of skill reuse for LLM agents operating on long-horizon, heterogeneous task streams, sitting between a single global document and a flat per-task skill pool.
- **Key mechanism**: A two-layer skill organization—a **global layer** compressing shared solving procedures into de-instantiated priors, and a **local layer** regenerated per task from its own execution feedback—combined at solving time and separated at consolidation time.
- **Verifier-grounded commit gate**: Candidate priors are admitted to the library only when real downstream execution shows they do not degrade the deployed library, protecting against over-generalization from lossy compression.
- **Results**: Across 4 benchmarks and 3 models (12 continual-improvement runs), global priors gain **+17.2 points (hard)** over the no-skill baseline on average, with positive gains in all runs; the library is **3.6× more compact** than a per-task pool.
- **Transfer evidence**: Unmodified libraries lift success on unseen ALFWorld tasks from **73.9% to 83.9%**, demonstrating that what transfers is reusable procedure rather than task memory.

---

## Introduction and Theoretical Foundation

### Background and Motivation

- LLM agents are moving from short-horizon, closed tasks toward longer-horizon, complex environments (Yao et al., 2023; Shinn et al., 2023; Liu et al., 2024).
- Recent systems distill reusable skills from execution trajectories, but most evidence comes from **structurally similar tasks**.
- Two dominant skill organization forms fail on heterogeneous workloads:
  - **Single global document**: assumes one dominant procedure; collapses into generic discipline the model already knows.
  - **Flat per-task library**: assumes old entries can be reused wholesale; inflates linearly and entries stay bound to the instance that wrote them.

### The Missing Unit of Reuse

> "Solutions differ from instance to instance, but tasks are not isolated. Similar tasks form families and share a solving procedure, while each instance carries local constraints that surface only during execution. The shared procedure transfers across tasks; the instance details do not."

This insight motivates the **procedural family**—a cluster of tasks sharing a solving procedure—as the fundamental unit of skill consolidation.

### Theoretical Framing

GLoW's objective is to construct and maintain a global prior library $\mathcal{G}$ over a task stream to maximize expected execution value:

$$
\max_{\mathcal{G}} \mathbb{E}_{x \sim \mathcal{D}} \left[ r_x\left(\mathrm{Recall}(\mathcal{G}, x) \oplus L_x\right) \right], \tag{2}
$$

where $r_x$ is the verifier score, $\mathrm{Recall}$ retrieves the relevant prior, $L_x$ is the task-local skill, and $\mathcal{D}$ is the task distribution. The optimization is hard because $r_x$ is a black box, the granularity of $\mathcal{G}$ is unknown, and language compression is lossy.

---

## Methodology

### 1. Problem Formulation

- A **skill** is a natural-language procedure inserted into the agent's context.
- Given a frozen agent $\pi$, task $x$, skill context $s$, and execution harness $h$, one execution returns $(\tau_x(s), r_x(s)) = h(\pi, x, s)$ with $r_x(s) \in [0,1]$.
- GLoW maintains a committed global prior library $\mathcal{G} = \{G_{\mathrm{base}}, G_1, \dots, G_K\}$, where $K$ is far smaller than the number of historical tasks.

### 2. Local Evidence and Skill Cards

- **Localize** generates a task-local skill $L_x = \mathrm{Localize}(\Delta\tau_x, r_x)$ from trajectory differences between multiple real executions of the same task.
- Each task's experience is encapsulated as a **skill card**: $c_x = (x, a_x, \tau_x, r_x, L_x)$ — task instruction, abstract signature, trajectory text, verifier score, and local skill.

### 3. Procedural Clustering and Prior Compression

- **Consensus clustering**: Each card is encoded via four textual views (signature, instruction, skill text, trajectory), fused with fixed weights where the signature carries the largest weight. Multiple hierarchical clusterings with varying linkage rules and cluster counts produce a co-occurrence frequency, which becomes a consensus similarity; final families come from clustering on it.
- **Automatic cluster count** via Kneedle knee point of the silhouette curve.
- Each family is compressed into one candidate prior:
  $$
  G_k^{(t)} = \mathrm{Compress}\left(\mathcal{C}_k^{(t)}\right), \tag{3}
  $$
  retaining only: applicability conditions, the core solving procedure, and common failure modes. Instance details are discarded and regenerated locally.

### 4. Verifier-Grounded Commit Gate

The execution value of deploying pure global priors on a task set $D$ is:

$$
V(\mathcal{G}; D) = \frac{1}{|D|} \sum_{x \in D} r_x\left(\mathrm{Recall}(\mathcal{G}, x)\right), \tag{4}
$$

where the argument is the recalled prior **alone** (no $L_x$), so measured value is attributable to the prior. A round's candidates come from three routes: fresh compression, append-only repair with scope-restricted guards, and carry-forward of the best-scoring version. The gate keeps the best:

$$
\begin{array}{c} V^{\mathrm{real}} = \max_v V\left(\mathcal{G}^{(v)}; D\right), \\ \text{commit} \iff V^{\mathrm{real}} \geq A - \epsilon. \end{array} \tag{5}
$$

The anchor $A = \max(V^\star, V^{\mathrm{ns}})$ is the larger of the standing library's value and the No-Skill baseline, with $\epsilon = 0.02$ absorbing fluctuation.

### 5. Execution-Time Global–Local Weaving

- At test time, the committed global prior library stays **frozen**.
- Recall implements Eq. (1) in two levels: base prior always present; family prior retrieved by cosine-similarity top-1 over embeddings, injected only when similarity exceeds a fixed threshold (fail-closed).
- The local skill $L_x$ is freshly regenerated per task and combined as $G_x \oplus L_x$.

```
Algorithm 1: GLoW: one pass over a task stream
Require: agent π, harness h, stream D, rounds T, sub-rounds J
Ensure: committed prior library G
1:  G ← {G_base}
2:  for t = 1 to T do
3:     STAGE 1 local evidence; C ← ∅
4:     for j = 1 to J do
5:     for all task x ∈ D do
6:     Gx ← Recall(G, x)  ▷ frozen for the episode
7:     (τx, rx) ← h(π, x, Gx)
8:     repeat
9:     Lx ← Localize(Δτx, rx)  ▷ no library lookup
10:    (τx, rx) ← h(π, x, Gx ⊕ Lx)
11:    until iteration budget exhausted
12:    C ← C ∪ {(x, ax, τx, rx, Lx)}  ▷ card; Lx never enters G
13:    end for
14:    end for
15:    STAGE 2 consolidation
16:    {Ck}k ≤ K ← CONSENSUSCLUSTER(φ(C))  ▷ auto-K
17:    Ĝk ← Compress(Ck) for all k ≤ K  ▷ de-instantiate
18:    STAGE 3 admission
19:    G' ← {G_base} ∪ {Ĝk}k ≤ K  ▷ the round's candidate revision
20:    G ← G' if GATE(G', G) accepts  ▷ one decision per round
21:  end for
22:  return G
```

---

## Empirical Validation / Results

### Main Results (Table 1, 12 continual-improvement runs, hard scores)

| Method | TBP↑ (hard) | SWE↑ (hard) | ALFWorld↑ (hard) | LMB↑ (hard) | Avg.↑ (hard) |
|---|---|---|---|---|---|
| **DeepSeek-V4-Pro** | | | | | |
| No-Skill | 34.4 | 45.0 | 57.1 | 13.2 | 37.4 |
| SkillOpt† | 43.8 ↑9.4 | 60.0 ↑15.0 | 90.5 ↑33.4 | 22.6 ↑9.4 | 54.2 ↑16.8 |
| GLoW (Global) | 50.0 ↑15.6 | 70.0 ↑25.0 | 83.3 ↑26.2 | 37.7 ↑24.5 | 60.3 ↑22.9 |
| GLoW (Global+Local) | 43.8 ↑9.4 | 70.0 ↑25.0 | 81.0 ↑23.9 | 39.6 ↑26.4 | 58.6 ↑21.2 |
| **MiniMax-M3** | | | | | |
| No-Skill | 40.6 | 35.0 | 76.2 | 22.6 | 43.6 |
| SkillOpt† | 43.8 ↑3.1 | 55.0 ↑20.0 | 95.2 ↑19.0 | 28.3 ↑5.7 | 55.6 ↑12.0 |
| GLoW (Global) | 53.1 ↑12.5 | 60.0 ↑25.0 | 92.9 ↑16.7 | 28.3 ↑5.7 | 58.6 ↑15.0 |
| GLoW (Global+Local) | 53.1 ↑12.5 | 65.0 ↑30.0 | 90.5 ↑14.3 | 35.8 ↑13.2 | 61.1 ↑17.5 |
| **GPT-5.4-mini** | | | | | |
| No-Skill | 28.1 | 35.0 | 42.9 | 15.1 | 30.3 |
| SkillOpt† | 40.6 ↑12.5 | 40.0 ↑5.0 | 61.9 ↑19.0 | 13.2 ↓1.9 | 38.9 ↑8.7 |
| GLoW (Global) | 50.0 ↑21.9 | 45.0 ↑10.0 | 61.9 ↑19.0 | 18.9 ↑3.8 | 43.9 ↑13.6 |
| GLoW (Global+Local) | 46.9 ↑18.8 | 50.0 ↑15.0 | 66.7 ↑23.8 | 18.9 ↑3.8 | 45.6 ↑15.3 |

**Key findings**:
- GLoW improves on No-Skill in **all 12 runs** (Wilcoxon signed-rank $p = 0.000488$).
- Frozen priors gain **+17.2/+13.0 points** (hard/soft) on average; +18.0/+14.6 with local regeneration.
- Largest gains on software repair (MiniMax-M3, +30.0/+27.7 with regeneration); smallest on mathematical reasoning where tasks share the most procedural structure.
- GLoW leads SkillOpt on **15 of 21 cells**; SkillOpt's 4 wins are all ALFWorld (single action space where one skeleton covers the whole set).

### Component Ablations (Table 2, hard scores)

| Bench | Model | Base-only (w/o families) | Local-only (w/o global) | AWM (flat + recall) |
|---|---|---|---|---|
| TBP | DeepSeek-V4-Pro | 25.1 ↓9.3 | 48.5 ↑14.1 | 37.5 ↑3.1 |
| TBP | MiniMax-M3 | 46.9 ↑6.3 | 50.0 ↑9.4 | 34.4 ↓6.2 |
| TBP | GPT-5.4-mini | 34.4 ↑6.3 | 46.9 ↑18.8 | 40.6 ↑12.5 |
| SWE | DeepSeek-V4-Pro | 45.0 | 57.5 ↑12.5 | 65.0 ↑20.0 |
| SWE | MiniMax-M3 | 30.0 ↓5.0 | 50.0 ↑15.0 | 30.0 ↓5.0 |
| SWE | GPT-5.4-mini | 30.0 ↓5.0 | 45.0 ↑10.0 | 40.0 ↑5.0 |
| ALFWorld | DeepSeek-V4-Pro | 73.8 ↑16.7 | 73.8 ↑16.7 | 76.2 ↑19.1 |
| ALFWorld | MiniMax-M3 | 78.6 ↑2.4 | 79.8 ↑3.6 | 85.7 ↑9.5 |
| ALFWorld | GPT-5.4-mini | 50.0 ↑7.1 | 53.6 ↑10.7 | 45.2 ↑2.3 |
| LMB | DeepSeek-V4-Pro | 20.8 ↑7.6 | 24.5 ↑11.3 | 13.2 |
| LMB | MiniMax-M3 | 18.9 ↓3.7 | 32.1 ↑9.5 | 24.5 ↑1.9 |
| LMB | GPT-5.4-mini | 15.1 | 14.2 ↓0.9 | 13.2 ↓1.9 |
| **Mean** | — | **39.1 ↑2.0** | **48.0 ↑10.9** | **42.1 ↑5.0** |

- **Base-only** (single document): averages +2.0 points, flips sign across benchmarks, loses ground on 4 of 12 cells.
- **Local-only** (per-task skills): helps by +10.9 points but trails Global-only.
- **AWM** (flat pool + retrieval): averages +5.0 points, still below GLoW's +11.2 for one round of family consolidation.

### Admission Gate Analysis (Figure 3)

- Across 12 runs, the gate made **26 admission decisions**: 19 accepted, 7 rejected.
- 4 of the 7 rejections would have been admitted under consolidation-time score alone.
- Representative case: MiniMax-M3 on LMB, round-2 candidate scored 0.283 (soft) exceeding the anchor, yet achieved only 0.151 in deployment (−13.2 points).
- Averaged over runs: the gate-kept library reaches **+14.7 points** by the final round vs. +9.6 for unconditionally admitted candidates.

### Transfer to Unseen Tasks (Table 4)

| Model | No-Skill | Global |
|---|---|---|
| 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 |

- All three models improve on 60 unseen ALFWorld tasks (valid_unseen split).
- On software repair: resolve rate on 30 unseen instances improves from 40.0% to 45.6% (MiniMax-M3).

### Procedural Organization Evidence (Table 3, ALFWorld)

| Task class | Tasks | Priors | Solved (no skill → with global) | Fix/Break |
|---|---|---|---|---|
| Examine-in-light | 7 | 1 | 4 → 7 | ↑3 |
| Pick-and-place | 7 | 3 | 7 → 7 | — |
| Clean-then-place | 7 | 3 | 4 → 5 | ↑2 ↓1 |
| Cool-then-place | 7 | 2 | 5 → 6 | ↑1 |
| Heat-then-place | 7 | 3 | 5 → 7 | ↑2 |
| Two-instance | 7 | 3 | 7 → 7 | — |
| **All six classes** | **42** | **15** | **32 → 39** | **↑8 ↓1** |

Consolidation returns 15 priors over 42 tasks: 13 sit wholly inside one labeled class, two straddle a pair. No class is left uncovered and none is invented.

---

## Theoretical and Practical Implications

### Theoretical Implications

1. **Granularity matters as much as optimization**: The paper demonstrates that *how* skills are organized (at what granularity) is as important as *how well* they are optimized. The single-document and flat-pool organizations fail in opposite, predictable ways on heterogeneous streams.

2. **Procedure vs. task memory**: The transfer results (Table 4) provide evidence that what consolidates and transfers is **reusable procedure**, not task-specific memory—a distinction with implications for continual learning and skill abstraction theory.

3. **Verifier-grounded admission**: The commit gate (Eq. 5) shows that measured downstream execution is a more reliable admission criterion than consolidation-time scores alone, since compression can widen rules or drop constraints in ways text evaluation cannot detect.

4. **Predictive ordering**: The framework predicts where family granularity pays off most (heterogeneous solutions) and least (shared action spaces). This prediction is confirmed: gains are largest on software repair and smallest where mathematical tasks share the most structure.

### Practical Implications

1. **Library efficiency**: One prior per procedural family rather than one per task yields a **3.6× more compact** library, critical for long-running agent deployments with bounded context/memory.

2. **Cross-task transfer**: Unmodified libraries transfer to unseen tasks within a benchmark, suggesting a path toward genuinely reusable skill libraries for open-ended workflows.

3. **No utility scorer needed**: Unlike prior work requiring learned or hand-set utility scorers for skill governance, GLoW's retention "falls out of consolidation" and acceptance "turns only on measured downstream execution"—simpler and more robust.

4. **Failure modes identified**: The paper systematically measures all three prior organizations under identical conditions (Table 2), providing practitioners with concrete evidence about when each form fails.

---

## Conclusion

### Main Takeaways

- Neither a single global document nor a flat per-task library survives a stream where each task needs a different solution.
- The missing unit of reuse is the **procedural family**: compress the local skills of each cluster into one de-instantiated prior, regenerate instance detail per task rather than storing it, and admit priors only through measured execution.
- This recipe gains **+17.2 points** over No-Skill on a library **3.6× smaller** than the per-task pool, and transfers unmodified to unseen tasks (73.9% → 83.9%).

### Future Directions

1. **Domain change**: Whether a prior survives a genuine domain change (not just held-out instances of the same benchmark) remains open.
2. **Cross-model inheritance**: Since a prior is plain text, one model's library could in principle be handed to another; this remains untested.
3. Both point toward a library any open-ended workflow could accumulate, rather than one tied to a benchmark—a step toward genuinely self-improving agents with persistent, transferable procedural knowledge.

---

_Markdown view of https://picx.dev/p/4R1Cbp, served by PicX — AI-generated visual whiteboard summaries of research papers._