Skip to content

SkillAdaptor: Self-Adapting Skills for LLM Agents from Trajectories

🕒 Published (v1): 2026-05-31 00:00 UTC · Source: HuggingFace · link

Why this paper was selected

SkillAdaptor self-adapts reusable skills from step-level trajectory feedback; training-free

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

SkillAdaptor is a training-free, step-level skill adaptation framework for LLM agents that identifies the first accountable fault step in a failed trajectory, links responsibility to specific skills, and applies targeted revisions under explicit acceptance checks. Rather than reflecting over entire trajectories, it decomposes adaptation into Attribution → Modification → Qualification to avoid diffuse, misdirected skill updates. It plugs into OpenClaw-class agent harnesses as a post-execution module.

Problem

Existing training-free skill adaptation methods update reusable external skills from trajectory-level outcomes or session-level summaries. In long-horizon tasks, a failed trajectory typically contains many correct intermediate steps; attributing failure to the final outcome diffuses error signals across unrelated steps, producing overly broad or misdirected skill revisions. This credit-assignment problem worsens when a single early error invalidates many subsequent actions.

Method

SkillAdaptor maintains a dynamic skill collection \(\mathcal{K} = \{s_1, s_2, \ldots, s_n\}\) of structured textual records (title, principle, applicability conditions). The backbone LLM remains frozen throughout.

Initialization: The agent executes tasks with no skill bank; successful trajectories are distilled into an initial \(\mathcal{K}_0\).

Skill injection: For each task \(q\), candidate skills are retrieved by cosine similarity using Qwen3-Embedding-8B: $\(S_q = \text{Rerank}\!\left(\text{TopK}_{s \in \mathcal{K}} \text{sim}(\phi(d_q), \phi(s)),\ d_q\right)\)$ and the agent conditions generation on \(S_q\).

Adaptation (up to 10 rounds, stopping after 3 unchanged rounds): 1. Attribution — A Localizer predicts the earliest accountable fault step \(t^*\) and a failure description \(\pi\). A Linker produces a weighted suspect set over retrieved skills and selects action \(\hat{a} \in \{\text{REVISE}, \text{GENERATE}\}\). 2. Modification — The Modifier either rewrites the highest-weighted suspect skill (REVISE) or synthesizes a new skill anchored at \(t^*\) (GENERATE). Duplicate suppression uses a semantic similarity threshold \(\theta_{\text{dup}}\). 3. Qualification — Candidate updates are accepted only when re-execution under \(\mathcal{K}^+\) shows \(\Delta = \mathbb{E}[M(q;\mathcal{K}^+)] - \mathbb{E}[M(q;\mathcal{K})] \geq 0\); otherwise the original \(\mathcal{K}\) is retained.

Key Contributions

  • Step-level failure attribution (Localizer + Linker) that identifies the first actionable fault step and the responsible skill, rather than treating the full trajectory as the unit of reflection.
  • A Qualification gate that empirically validates each candidate skill update before committing it, suppressing unstable or harmful revisions.
  • A plug-in design compatible with OpenClaw-class harnesses, requiring no backbone fine-tuning.
  • Empirical demonstration that ~65–75% of all accepted skill updates occur in rounds 1–2, suggesting the framework efficiently resolves dominant failure modes early.

Results

Evaluated on WebShop, PinchBench, and Claw-Eval with Kimi-K2.5, GLM-5, and GPT-5.2.

  • WebShop (vs. EvoSkill, strongest prior baseline):
  • GLM-5: Score 43.9 vs. 41.6 (+2.3); Succ% 33.3 vs. 32.6 (+0.7)
  • Kimi-K2.5: Score 41.6 vs. 40.4 (+1.2); Succ% 33.0 vs. 31.3 (+1.7 pp)
  • GPT-5.2: Score 44.8 vs. 43.1 (+1.7); Succ% 34.3 vs. 33.0 (+1.3 pp)
  • PinchBench (vs. OpenSpace baseline):
  • GLM-5: Avg Score% 73.8 vs. 72.3 (+1.5); Kimi-K2.5: 67.2 vs. 66.0 (+1.2)
  • Claw-Eval (vs. OpenSpace):
  • Kimi-K2.5: Avg Score 75.8 vs. 74.0 (+1.8); Pass@3% 77.4 vs. 75.9
  • Ablation (Kimi-K2.5, WebShop): Removing Localizer+Linker drops Succ% from 33.0 to 28.6; removing Qualifier drops to 26.3 with variance ±2.6 vs. ±1.0 full system.

Limitations

  • Effectiveness degrades under sparse or delayed reward signals and when required tool interfaces are unavailable.
  • Evaluated on three public benchmarks only; generalization under longer-term deployment or broader distribution shift is unverified.
  • Gains are task-type dependent: strongest on Data/Code tasks with clear procedural traces; weaker on Research, Memory, and Security tasks where failures involve persistent state or cross-session context beyond single-skill scope.

Relevance to Harnesses / Meta-Harnesses

SkillAdaptor is explicitly designed as a plug-in post-execution module for OpenClaw-class agent harnesses, making it a direct instance of meta-harness infrastructure: a component that sits above the agent execution loop and manages the skill library that agents draw from at runtime. The Qualification gate (re-running tasks under candidate \(\mathcal{K}^+\) before committing) is architecturally analogous to meta-harness validation loops that gate harness-level configuration changes based on observed outcomes. The paper's framing of the skill collection as the sole mutable substrate — while the backbone and harness remain frozen — represents a clean separation of concerns relevant to anyone engineering modular, self-improving harness components. Its step-level attribution mechanism also provides a concrete blueprint for tying harness-level observability signals back to targeted policy updates.