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

Yifei Shen, Bo Li, Xinjie Zhang

SkillOpt-Lite replaces complex agent optimization pipelines with a minimal, file-centric debugging loop.

How can we simplify agent skill optimization into a minimal, high-performance pipeline without the overhead of complex multi-agent coordination?

Agentic skill optimization has become increasingly bloated, relying on complex mini-batch pooling and rejection buffers that often hinder rather than help performance. SkillOpt-Lite strips these layers away, treating agent execution traces as simple flat files and using an autonomous coding agent to perform targeted, semantic-driven debugging directly on the disk. This minimal pipeline accelerates convergence and allows smaller models to outperform larger ones by optimizing the agent's execution harness alongside its skills.

Paper Primer

Existing frameworks treat skill optimization as a black-box numerical problem, forcing them to use complex, compute-heavy heuristics to approximate gradients. SkillOpt-Lite recognizes that agent rollouts are actually structured program execution traces, allowing the system to perform direct, semantic-driven code patches instead of blind numerical perturbations.

The method operates on three principles: storing trajectories as independent files, mining cross-task invariants, and gating updates via an independent validation set. By granting the agent primitive shell utilities to inspect these files, the system bypasses the need for hierarchical tree-reduction or slow update damping.

SkillOpt-Lite achieves faster convergence and higher performance than full-scale optimization pipelines.

On the Spreadsheet benchmark, the streamlined pipeline outperformed the full SkillOpt framework (79.4 vs. 61.5 points on GPT-5.4). +12.6 points average increase on logic-intensive tasks.

Harness optimization enables lightweight models to surpass frontier-class models.

GPT-5.4-nano with HarnessOpt achieved 0.7758 accuracy on SpreadsheetBench, outperforming the larger GPT-5.5 (0.7620) running standard pipelines.

Why does this approach outperform complex, heavily engineered baselines?

Complex pipelines often average multiple textual updates, which blurs the implicit gradient signal. SkillOpt-Lite’s file-centric approach allows for localized, discrete edits that directly resolve logical deadlocks without the noise of mini-batch pooling.

What is the scope of this framework?

It is most effective for reasoning-heavy tasks where algorithmic execution is key. In semantic-heavy domains like text retrieval, the performance gains are marginal, though the framework still provides significant computational efficiency.

For agent engineering, the "bitter lesson" is that complex optimization topologies are often counterproductive; treating agent components as standard, editable code files is a more robust and scalable path to self-evolution.

Introduction and Motivation

We expose the need for a minimal, program‑like skill optimization pipeline.

Current skill‑optimization methods rely on intricate pipelines that combine mini‑batch reflection pooling, damping schedules, and rejected‑edit buffers. This architectural bloat obscures the core learning signal and hampers reproducibility.

The paper asks a simple yet unanswered question: what is the minimal viable pipeline for skill optimization, where every component is justified by theory or empirical necessity?

We formalize skill optimization as Zeroth‑Order (ZO) optimization, treating skill documents as programs whose trajectories provide semantic feedback rather than blind numerical perturbations.

In this view, classic ZO tricks map directly onto existing agentic mechanisms: single‑trace critiques act as one‑point gradient estimators, contrastive diagnoses correspond to central‑difference approximations, and edit‑budget buffers instantiate trust‑region radii.

From this mapping we derive three design principles. First, consensus mining across trajectories compresses cross‑task invariants and avoids the stability‑coefficient blow‑up that plagues single‑trial overfitting.

Second, independent validation gating—using a held‑out set rather than sub‑sampled training failures—removes the stability term from the PAC‑style generalization bound.

Third, a “bitter lesson” emerges: as base LLMs scale, elaborate damping and pooling become counter‑productive; letting agents manipulate raw log files with primitive shell utilities yields faster, more stable convergence.

Guided by these principles we propose SkillOpt‑Lite, a stripped‑down pipeline that drops pooling, damping, and rejection buffers and operates directly on the file system via autonomous trajectory exploration, consensus mining, and validation gating. Empirically it improves LiveMath by +8.8 points (GPT‑5.5) and +25.4 points (GPT‑5.4‑nano), raises overall scores by +12.6 points (69.7 vs 57.1), and lifts ALFWorld performance by +9.5 points (81.3 % vs 71.8 %).

**Figure 1.** The overall performance profile and optimization velocity of SkillOpt-Lite. (a) The radar plot illustrates the macro-level capability comparison averaged across all evaluated model scales, showing comprehensive performance gains over both the initial skills and the original SkillOpt. (b) The micro-level convergence curves on representative tracking segments demonstrate that our minimal viable pipeline delivers significantly accelerated policy refinement and higher validation ceilings (Best `val_hard` so far) within a tight 10-batch horizon.

The shift from complex multi‑agent pipelines to a minimal, program‑like skill‑optimization loop is the key to faster convergence and higher performance.

Formalizing Skill Optimization

We formalize skill optimization as zeroth‑order optimization and expose its core mechanisms.

Skill training can be cast as a black‑box optimization problem: we only observe a scalar reward after executing a text‑based skill on a task instance.

We treat a skill document $s$ as a function input that can only be probed by evaluating the reward it yields; gradients are unavailable, so we estimate direction by sampling perturbed copies.

How does zeroth‑order optimization differ from standard gradient descent?

Gradient descent assumes a differentiable loss and accesses exact partial derivatives; zeroth‑order optimization only queries the scalar reward at perturbed inputs, building an approximate direction from those evaluations.

Evaluate the original skill: $f(s)=0.42$ (reward from the environment).

Evaluate the perturbed skill: $f(s')=0.68$.

Compute the finite‑difference estimate $\hat{\nabla}f(s)\propto (0.68-0.42)\,u$, indicating that changing “north” to “south” improves reward.

Apply the update: replace “north” with “south”, yielding the new skill $s_{\text{new}}=\text{"go south"}$.

The estimator points directly to the token that most increases reward, showing how ZO can drive discrete edits without any gradient.

SkillOpt runs a vanilla zeroth‑order stochastic gradient descent over a mini‑batch of rollout traces, decaying the edit budget over time.

In what way does the baseline SkillOpt differ from the later SkillOpt‑Lite design?

SkillOpt relies on full‑batch variance reduction and an explicit edit‑budget decay, whereas SkillOpt‑Lite removes the multi‑agent pooling step and replaces the decay with a single‑trajectory refinement, cutting both compute and redundancy.

Classical zeroth‑order methods perturb a numeric vector blindly, while skill optimization enjoys rich, structured rollout traces that expose the exact cause of success or failure.

From a PAC‑learning viewpoint, the generalization gap is bounded by an empirical error term plus a stability penalty that scales with $s/N$.

Using a strictly disjoint validation set removes the stability term from the bound, but only if the validation data are independent of training.

**Table 1.** Mapping Between Zeroth-Order Optimization Operators and LLM/Agent Reflection Paradigms

The SkillOpt-Lite Mechanism

SkillOpt‑Lite replaces heavy batch plumbing with a lightweight file‑system driven edit loop.

Traditional SkillOpt pipelines stitch together mini‑batches, run slow epoch‑level reflection, and maintain large rejection buffers. Those components inflate compute cost and complicate iteration, especially as base models grow.

Instead of aggregating trajectories into batches and performing costly meta‑skill reflection, SkillOpt‑Lite treats each rollout file as an independent artifact and lets a language model explore the directory with simple file‑system commands, applying a minimal patch only when validation improves.

How does SkillOpt‑Lite differ from the original SkillOpt pipeline?

SkillOpt aggregates all trajectories into a mini‑batch, runs a slow epoch‑level matching loop, and maintains a rejection‑edit buffer. SkillOpt‑Lite drops all three: it stores each trajectory as a standalone file, skips batch‑level context loading, and replaces the multi‑epoch reflection with a single file‑system‑driven edit that is validated immediately.

List files:

Extract scores:

Identify the lowest‑scoring file (run2.txt) and grep its error pattern → “timeout on subtask B”.

Generate a one‑line patch fixing the timeout command and apply it to

Run validation on a held‑out set; score rises from 0.38 to 0.45, so the patch is accepted and

This toy walk‑through shows that a single file‑level edit, guided by the worst trajectory, can improve the whole skill library without ever loading the full batch into the model.

VS Code slash command that launches a ten‑round SkillOpt‑Lite loop.

**Figure 2.** Empirical evaluation of single-batch coding agent exploration versus multi-epoch skill optimization.

**Figure.** (a) The original SkillOpt pipeline [4]. (b) The proposed SkillOpt-Lite pipeline. The framework treats rollout trajectories as independent text files, allowing the optimizer model to explore the directory and extract shared failure patterns. Compared to the baseline SkillOpt framework, our streamlined design eliminates mini-batch reflection pooling, slow update damping, and historical rejection buffers.

Experimental Results

SkillOpt‑Lite matches or exceeds baselines while cutting pipeline overhead.

We evaluate SkillOpt‑Lite against the full SkillOpt pipeline on six benchmarks spanning reasoning and semantic tasks.

SkillOpt‑Lite improves LiveMath accuracy by up to +37.0 points over the full SkillOpt baseline.

On GPT‑5.5, accuracy rises from 36.6 to 73.6, a +37.0‑point gain.

**Figure 4.** Convergence curve comparison between SkillOpt (red curve with circles) and SkillOpt-Lite (blue curve with squares) across various tasks and model scales over 10 optimization steps. The y-axis denotes the best validation performance achieved so far.

SkillOpt‑Lite matches or exceeds complex baselines while cutting pipeline overhead dramatically.

Harness Optimization Framework

Ablation study quantifies the impact of each HarnessOpt component on performance.

Agent skill optimization is framed as a zeroth‑order problem where skill documents act as programs. HarnessOpt extends this by also optimizing the execution harness that runs those programs.

HarnessOpt treats the agent’s runtime scripts as tunable parameters, letting the optimizer edit the harness code alongside the skill markdown.

How does HarnessOpt differ from SkillOpt‑Lite?

SkillOpt‑Lite only edits the markdown skill file, leaving the execution harness untouched. HarnessOpt expands the search space to the harness scripts themselves, allowing structural changes such as tool augmentation and control‑flow reshaping, which are impossible when only the skill document is edited.

Removing the skill component from HarnessOpt (i.e., using “HarnessOpt w.o. skill”) drops performance dramatically across all model tiers.

GPT‑5.4‑nano falls from 0.8505 (with skill) to 0.3986 (without skill); GPT‑5.5 drops from 0.8577 to 0.8363.

**Figure 1.** The HarnessOpt framework architecture.

**Analysis of Model Behavioral Changes** – By applying HarnessOpt, we identified distinct operational bottlenecks across different model tiers and fixed them with targeted harness modifications:

Conclusion

Summarizes contributions and outlines four future research directions.

We formalize agentic skill training as a zeroth‑order optimization problem, showing that multi‑agent pooling and text‑update damping become unnecessary as base models scale.

Guided by the “everything is file” philosophy, SkillOpt‑Lite treats rollout trajectories as independent flat files and leverages autonomous coding agents for targeted, semantic‑driven debugging.

Empirically, SkillOpt‑Lite speeds up convergence and consistently matches or outperforms heavily engineered baselines across several benchmarks.

We package this workflow into a native IDE extension, demonstrating that file‑centric skill editing naturally extends to full harness optimization (HarnessOpt).

Future work includes four practical research directions.

Skill Optimization for Frontier Model Distillation: refining teacher agents to generate high‑quality distillation corpora, while fast, compute‑efficient evaluation protocols for data selection remain a challenge.

Harness Template Database for Automated Optimization: building a curated library of minimal harness templates to provide structural priors for coding agents, and extending sandboxing safety to internet‑augmented or multimodal execution domains.

Harness Evolution as Continual Learning: treating execution harnesses as non‑parametric parameters for lifelong learning, requiring methods to align and fuse independently evolved harness lineages and to personalize agents to long‑term human preferences.

Extending Optimization to Foundation Model Training: moving the optimization boundary from scripts to model parameters by managing data as files, enabling automated data‑model‑harness co‑design loops, as preliminarily demonstrated in our internal multimodal projects.

Realizing these directions will move us toward fully autonomous agent self‑evolution.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers