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

Abstract: While skill optimization for autonomous agents has gained traction, existing methods rely on complex pipelines. This leaves a fundamental question unaddressed: What constitutes a minimal viable pipeline for skill optimization, where every component is justified by theory or empirical necessity? We formalize skill optimization via Zeroth-Order (ZO) optimization, mapping classical counterparts (central difference, trust regions) to recent literature. Noting that unlike blind numerical perturbations in classical ZO, skill trajectories serve as interpretable debugging feedback. Grounded in Claude Code philosophy and PAC learning, we establish three principles for convergence and generalization: file-system-based trajectory exploration, consensus attribute mining, and independent validation gating. Eliminating redundancies, we propose SkillOpt-Lite. It accelerates convergence and outperforms full SkillOpt: improving LiveMath by +8.8 points on GPT-5.5 and +25.4 points on GPT-5.4-nano, allowing the nano model to surpass standard GPT-5.4 optimized by SkillOpt. Finally, we integrate our framework into production coding agents like VSCode Copilot, enabling developers to evolve agent skills via one line of vibe. Because our framework treats all agent components simply as standard editable code, this minimal pipeline naturally generalizes to full harness optimization (HarnessOpt). On SpreadsheetBench, HarnessOpt enables GPT-5.4-nano to achieve 0.7758 accuracy, outperforming the larger GPT-5.5 running standard pipelines (0.7620). Code is available at https://github.com/EvolvingLMMs-Lab/SkillOpt-Lite.

• The paper introduces a minimal, file-centric pipeline that formalizes agent skill optimization as a statistical learning problem using zeroth-order methods.
• It details methodologies like independent validation gating and direct file-system exploration to reliably extract consensus failure patterns for efficient skill patching.
• Empirical results demonstrate accelerated convergence and improved performance, notably on code-centric benchmarks, establishing a practical blueprint for autonomous agent evolution.

SkillOpt-Lite: Minimal Viable Pipelines for Efficient Agent Skill and Harness Evolution

Problem Statement and Theoretical Underpinnings

Skill optimization for autonomous agent architectures has become an essential focus as agent deployment shifts from research settings to mission-critical production. Existing systems such as SkillOpt (Yang et al., 22 May 2026), Trace2Skill (Ni et al., 26 Mar 2026), and SkillForge (Liu et al., 9 Apr 2026) have steadily increased in complexity, incorporating batch consensus extraction, meta-skill hierarchical reductions, edit-budget schedules, and multi-step rejection buffers. However, this trend raises a fundamental research question: what constitutes a theoretically and empirically minimal pipeline for robust and transferable skill optimization?

The authors of "SkillOpt-Lite: Better and Faster Agent Self-evolution via One Line of Vibe" (2607.03451) rigorously formalize skill optimization as a statistical learning problem framed through zeroth-order (ZO) optimization. Classical ZO methods treat the agent’s skill or prompt as an intractable, discrete variable and seek to optimize the expected downstream performance in a non-differentiable environment. The analogy is extended by systematically mapping agentic skill editing operators (e.g., reflection heuristics, contrastive diagnosis, edit budgets) to canonical ZO optimization constructs: central differences, coordinate descent, trust region constraints, and control variates.

A critical conceptual divergence is highlighted:

Classical ZO relies on blind numeric perturbations, but agent skill optimization is a language-mediated program compilation process where execution trajectories yield interpretable debugging feedback.

This compiler perspective motivates rethinking the role of algorithmic overhead in skill optimization pipelines, especially as foundation LLMs gain capabilities.

Principles for Minimal Skill Optimization

The authors derive three core principles—justified by PAC learning theory and empirical investigations—that a minimal viable skill optimization pipeline must satisfy:

1. Consensus Attribute Mining: Avoid overfitting to idiosyncratic failures in individual trajectories to minimize the generalization gap $\beta_{\exp}$. Extract cross-task invariants by consensus compression rather than mini-batch averaging.
2. Independent Validation Gating: Employ validation gating on a strictly held-out, statistically independent set to decouple overfitting from model selection and ensure generalization bounds are not biased.
3. Direct File-System Exploration: Empirical results reveal that complex reflection pooling or damped update schemes offer diminishing returns versus direct, unsupervised file-based editing and tracing as model scale increases.

These principles yield a theoretical and operational blueprint for a drastically simplified pipeline.

SkillOpt-Lite: Pipeline Architecture

SkillOpt-Lite embodies the above principles by treating all execution traces, skill artifacts, and harness code as simple flat files within a workspace. The optimizer—be it an LLM or an external agent such as Copilot—operates using primitive file-system and code-editing tools, bypassing engineered dataflows, mini-batch pooling, rejection buffers, or epoch-level reflection.

Workflow Stages:

• Each rollout trajectory (including logs, rationales, and outputs) is dumped to disk as an independent file.
• The optimizer autonomously explores these files to mine consensus failure patterns and synthesize minimal skill patches.
• Candidate updates are validated exclusively using an independent validation set. Only empirically beneficial edits are accepted as new baselines. Rejected edits are archived, but do not propagate buffer-based control variates.

This "everything is a file" philosophy naturally unifies skill, scaffold, and harness optimization.

Figure 2: Diagram of the original SkillOpt pipeline highlighting its architectural complexity.

Figure 4: SkillOpt-Lite delivers a steeper convergence curve and higher performance ceilings within tight optimization budgets compared to the original SkillOpt.

Empirical Results: Performance and Optimization Efficiency

Macro-Level Gains and Task Generality

SkillOpt-Lite is benchmarked against the full SkillOpt pipeline and initial skills across multiple real-world tasks: SearchQA, SpreadsheetBench, ALFWorld, LiveMath, OfficeQA, and DocVQA. The experimental protocol ensures an identical base model and consistent data splits.

Figure 1: SkillOpt-Lite demonstrates broad, macro-level capability improvements across all evaluated tasks and model scales.

Key empirical findings:

• On logic-intensive and code-centric benchmarks (SpreadsheetBench, LiveMath), SkillOpt-Lite delivers performance increases of up to +42.3 points (Spreadsheet, GPT-5.5) and +37.0 points (LiveMath, GPT-5.5) relative to SkillOpt. The framework enables even lightweight models (GPT-5.4-nano) to outperform much larger baselines optimized by prior pipelines.
• For open-ended or retrieval-centric tasks (e.g., SearchQA, ALFWorld), both frameworks converge to similar optima, but SkillOpt-Lite achieves these bounds with fewer optimization steps and significantly lower computational overhead.

Convergence Speed and Data Efficiency

The streamlined pipeline empirically demonstrates:

• Superior early optimization velocity. SkillOpt-Lite consistently achieves near-final validation performance within 2–3 steps, a regime where SkillOpt stagnates due to complex update-damping and batch merging.
• Equal or higher asymptotic performance ceilings, even without reflection pooling or rejected-edit buffers.

HarnessOpt: Extending Beyond Skills to Codebase Evolution

SkillOpt-Lite's architectural simplicity facilitates a seamless transition to agent harness optimization (HarnessOpt), generalizing the pipeline to treat the agent execution environment as editable code assets. This is operationalized via:

• Round-0 bootstrapping: Diagnosing and proposing structural environment changes through log consensus mining, with human-in-the-loop approval for critical codebase modifications.
• Closed-loop evolution: Automated patching, strict sandboxed validation gating, rollback support, and modular toggles for safety.

On SpreadsheetBench, this joint optimization delivers an empirical capability inversion: GPT-5.4-nano achieves 0.7758 accuracy post-harness optimization, outperforming GPT-5.5 running the full SkillOpt scaffold (0.7620). The best results are consistently realized by jointly optimizing both skill and harness artifacts, validating the pipeline's flexibility and efficacy.

Practical Implications and Directions for Future Work

By demonstrating that a minimalist, file-centric pipeline not only matches but frequently exceeds the performance of complex alternatives, the work encourages a reevaluation of the necessity of batch reflection, control-variate damping, and non-primitive update schedules—especially for agents powered by advanced LLMs. The practical encapsulation as a VS Code extension further removes adoption barriers in industrial workflows, enabling agent self-evolution with "one line of vibe."

Future research directions include:

• Extending skill optimization to facilitate distillation from frontier LLMs, with dynamic patch-based teacher evolution for enhanced data quality.
• Constructing robust libraries of harness templates and adaptive sandbox techniques for generalized, safe environment co-evolution.
• Treating harness and skill evolution as the primary parameter set for continual, life-long agent learning, circumventing expensive full-model retraining.
• Applying the optimization pipeline to the data/model co-design process in foundation model pretraining, closing the loop from skill/harness edits to full agent self-evolution.

Conclusion

SkillOpt-Lite provides a principled, empirically validated answer to the minimal requirements for performant and generalizable agent skill optimization. Through file-centric program compilation and direct code patch mining, it both accelerates optimization and unlocks new regimes of agent and environment co-design—enabling lightweight models to achieve and surpass the capabilities of frontier models within practical, production contexts. The work argues for a return to simplicity, leaning on the inherent power of modern LLMs and principled statistical learning, and sets the stage for scalable, autonomous AI agent evolution.