Skip to content

SkillOpt-Lite: Better and Faster Agent Self-evolution via One Line of Vibe

🕒 Published (v1): 2026-07-03 00:00 UTC · Source: HuggingFace · link

Ask a follow-up

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

💬 Ask ChatGPT✦ Ask Claude

TL;DR

SkillOpt-Lite strips agent skill optimization down to a minimal viable pipeline—file-system trajectory staging, consensus mining, and independent validation gating—grounded in zeroth-order (ZO) optimization theory and PAC-learning bounds. Eliminating mini-batch reflection pooling, slow-update damping, and rejection buffers accelerates convergence and beats the full SkillOpt baseline across six benchmarks. The same loop naturally generalizes to full harness optimization (HarnessOpt), allowing a lightweight GPT-5.4-nano to outperform GPT-5.5 under standard pipelines.

Problem

Existing automated skill optimization frameworks (SkillOpt, Trace2Skill, SkillForge, SkillAdapter) have accumulated components—hierarchical tree merges, learning-rate schedules, rejected-edit buffers, epoch-level slow updates—borrowed from classical optimization without principled justification. No prior work asks: what is the minimal set of components that is theoretically necessary and empirically sufficient for convergence and generalization?

Method

The paper first formalizes skill optimization as maximization of \(f(s) = \mathbb{E}_{z \sim \mathcal{D}}[R(H(M, z, s))]\) over a discrete text space \(S_\text{text}\), mapping existing heuristics onto ZO operators (1-point estimators, central differences, coordinate descent, trust regions, control variates). It then identifies a key divergence: unlike classical ZO, agentic rollouts yield semantically rich execution traces, making the problem analogous to language-mediated program compilation rather than black-box function querying.

Three principles are derived: 1. Consensus Mining (from algorithmic stability / PAC bounds): the optimizer must extract cross-task invariants to keep the stability coefficient \(\beta_\text{exp}\) small, bounding generalization error as \(\epsilon(S) \leq \hat{\epsilon}_\mathcal{D}(S) + O\!\left(\beta_\text{exp} + \sqrt{\ln(1/\delta)/N}\right)\). 2. Independent Validation Gating: a strictly disjoint validation set removes \(\beta_\text{exp}\) from the model-selection bound, giving \(\epsilon(S_\text{val}) \leq \hat{\epsilon}_\text{val}(S_\text{val}) + O\!\left(\sqrt{\ln(1/\delta)/m}\right)\). 3. Bitter Lesson: granting the optimizer primitive shell file-system tools (list, read, replace) over flat trajectory files consistently matches or outperforms heavily engineered topologies—especially as base LLMs scale.

SkillOpt-Lite pipeline (four steps per batch): 1. Trajectory Staging — each rollout is dumped as an independent flat text file on disk. 2. Trajectory Exploration — the optimizer uses shell commands to list directories, cluster failure types, and select high-leverage files within a fixed token budget. 3. Consensus Mining & Minimal Edit — the optimizer reads selected files, identifies shared failure patterns, and generates a compact patch (minimal-modification principle). 4. Validation Gating — the patched candidate \(\tilde{S}\) is evaluated on an independent held-out set; accepted if it improves current skill, written as best_skill.md if it sets a new high score.

HarnessOpt extends the same loop: by treating the agent harness as editable code files, a subagent mines failure proposals and a coding agent implements them, optimizing both skill documents and harness code jointly.

Key Contributions

  • Theoretical unification: maps the full landscape of skill-optimization heuristics to a ZO optimization taxonomy, exposing where prior work violates PAC-learning independence requirements.
  • Three design principles (consensus mining, independent validation gating, file-system primitives) derived from ZO theory, stability theory, and an empirical pilot study.
  • SkillOpt-Lite: a minimal pipeline removing reflection pooling, slow-update damping, and rejection buffers, delivered as an open-source VS Code Copilot extension triggerable via a single slash command.
  • HarnessOpt: natural generalization of the same file-centric loop to joint skill + harness co-optimization, enabling a smaller model to surpass a larger one.

Results

  • LiveMath / GPT-5.5: SkillOpt-Lite +8.8 points over SkillOpt (absolute); GPT-4o +27.6 points over baseline (31.2 → 58.8); GPT-5.5 +37.0 points (36.6 → 73.6).
  • LiveMath / GPT-5.4-nano: +25.4 points over SkillOpt; nano surpasses standard GPT-5.4 optimized by SkillOpt.
  • Spreadsheet / average across models: +12.6 points over SkillOpt (69.7 vs. 57.1); GPT-5.4 specifically 79.4 vs. 61.5.
  • ALFWorld / GPT-5.4-nano: 81.3% (+9.5 over SkillOpt).
  • Pilot study (1-batch coding agent vs. SkillOpt 4 epochs): single-batch GitHub Copilot exploration outperforms SkillOpt on LiveMath and DocVQA; degrades on Spreadsheet (motivating the validation gate).
  • HarnessOpt / SpreadsheetBench: GPT-5.4-nano achieves 0.7758 accuracy vs. GPT-5.5 + full SkillOpt at 0.7620.
  • SearchQA, ALFWorld, OfficeQA: marginal differentials (+0.1 to +1.5 points) — SkillOpt-Lite matches but does not strongly exceed SkillOpt on semantics-heavy retrieval tasks.

Limitations

  • Gains are concentrated on reasoning-intensive and code-execution tasks (LiveMath, Spreadsheet); improvements on open-ended retrieval (SearchQA) and grounded navigation (ALFWorld) are small.
  • Pilot study showed that removing validation gating can cause skill degradation on some benchmarks (Spreadsheet), so the gate is empirically necessary but adds evaluation cost.
  • Validation set sizes for LiveMath and OfficeQA were only 10–20 instances in the original splits, requiring adjusted splits (2:2:6); results on these tasks carry higher variance.
  • OfficeQA uses an offline evaluation variant due to missing live API access, potentially affecting ecological validity.
  • Paper text is truncated before the full results table (Table 2), so complete numbers across all model-benchmark combinations are not available in the provided excerpt.

Relevance to Agentic AI / LLM Agents

This work directly addresses the reproducibility and efficiency problem in agentic self-improvement loops: it shows that elaborate optimization machinery borrowed from numerical methods can be replaced by a file-centric, LLM-native debugging loop without sacrificing—and often improving—performance. The ZO formalization provides a unified theoretical lens for comparing all major skill-optimization methods (Reflexion, Voyager, Trace2Skill, SkillOpt, SkillForge, SkillAdapter, SkillCat), which is valuable for researchers designing new agent training pipelines. The extension to HarnessOpt is particularly significant: it demonstrates that joint optimization of the agent scaffold and skill documents can enable smaller models to surpass larger ones, pointing toward environment co-design as a first-class research direction. The IDE integration also illustrates a practical path from research pipelines to developer-facing agent evolution tooling.