Program-Aided Patchable Skill Evolution

Jiahao Wang, Yuqi Xiong, Qing Yang, Zhipeng Xu, Zhenghao Liu, Zulong Chen, Yubin Bao

TL;DR

PASE (Program-Aided Patchable Skill Evolution) is a new framework that boosts LLM agent performance by decoupling "skills" into two parts: natural language descriptions and executable Python programs. By using a patch-based system to iteratively refine these programs and documents independently, PASE achieves higher accuracy, greater evolutionary stability, and better cross-model generalization than traditional text-only skill methods.

What Problem Does This Paper Address?

LLM agents often require specialized "skills"—reusable sets of instructions—to handle complex, domain-specific tasks like spreadsheet manipulation or database querying. Currently, these skills are typically represented as natural language (NL) documents.

The authors identify a major bottleneck: entanglement. In NL-only skills, procedural logic (the "how-to" code-like steps) is intertwined with descriptive knowledge (the "what" and "why"). This makes skills difficult to maintain. If an agent fails a task, updating the NL description to fix a specific logic error often requires rewriting large chunks of text, which can introduce ambiguity or accidentally break other parts of the skill. This leads to "evolutionary instability," where a skill might improve in one round of training only to degrade in the next.

Methods

PASE introduces a dual-representation for skills: a Skill Document (NL guidance) and an Executable Program (Python code).

The framework evolves these skills through a four-stage iterative process:

  1. Random Sampling: The agent attempts a batch of tasks using its current skill-program pairs, generating execution trajectories.
  2. Programmatic Patch Proposal: A specialized "Proposer Agent" analyzes these trajectories. It uses programmatic tools to read existing skills and historical patches to diagnose failures.
  3. Adaptive Patchable Update: Instead of rewriting skills from scratch, the proposer issues "patches"—line-level edits (using CREATE, REPAIR, or DELETE operations). This allows for surgical fixes to either the Python logic or the NL guidance.
  4. Gated Validation: Proposed patches are tested on a held-out validation set. Only updates that strictly improve performance are "committed" to the skill library, preventing regressions.
Figure 2: Overview of our PASE framework.

Datasets

The authors evaluated PASE across several challenging benchmarks:

  • SpreadsheetBench: A real-world benchmark for Excel/XLSX manipulation (used as the in-domain training set).
  • Domain-Spreadsheet: Out-of-domain tasks covering Finance, HR, Real Estate, Sales, and Supply Chain.
  • TableQA: WikiTableQuestions and HiTab, converted into spreadsheet manipulation tasks to test general reasoning.

Key Insights and Ideas

  • Code is a Better Logic Container: Moving complex procedural logic (like regex string splitting or multi-step lookups) into Python programs reduces the "textual burden" on the LLM. As shown in Figure 3d, PASE skills are significantly shorter and more concise than those of NL-only baselines.
  • Evolutionary Stability: By using executable code and gated validation, PASE avoids the performance "jitter" common in NL evolution. Figure 3a illustrates that while NL-only methods fluctuate wildly in accuracy across training steps, PASE shows a steady, upward trajectory.
  • Surgical Precision: The patch-based mechanism allows the system to fix a specific bug in a Python function without touching the high-level strategy described in the NL document. The authors found that 62.2% of updates involved the programmatic component, highlighting its central role.
Evaluation accuracy across training steps, showing PASE's superior stability compared to text-only methods.

Key Results

PASE consistently outperformed state-of-the-art baselines like Trace2Skill and EvoSkill across multiple LLM backbones (Qwen3.6, Qwen3.7-Plus, and Gemma-4):

  • Overall Performance: PASE achieved an average improvement of over 2.8% across all benchmarks.
  • In-Domain Success: On the SpreadsheetBench-Verified set, PASE improved performance by over 14% compared to a vanilla LLM without skills.
  • Cross-Model Transfer: Skills evolved by a stronger model (like Qwen3.7-Plus) could be successfully used by smaller models (like Gemma-4), often outperforming the smaller model's own self-evolved skills. This suggests that the decoupled programs capture "universal" procedural knowledge.

Limitations and Future Work

The authors acknowledge several areas for improvement:

  • Skill Retrieval: Currently, the system injects all relevant skills directly into the prompt. As the skill library grows, a more sophisticated retrieval mechanism will be needed to stay within context limits.
  • Explicit Invocation: The agent must explicitly choose to call the Python program. If an agent (like a ReAct-based one) decides to write its own logic in a Bash tool instead of using the predefined skill program, the benefits of PASE are lost.
  • Gated Validation Strictness: The current "improvement-only" gate might reject "neutral" patches that don't help immediately but provide a necessary foundation for future complex skills.

The authors have committed to releasing all data and code via GitHub to support further research into programmatic skill evolution.

Summary updated

Abstract

Agent skills have emerged as an effective means of enabling LLM agents to solve complex, interactive tasks by encoding reusable knowledge without modifying model parameters. Recent approaches further improve skill adaptation by distilling reusable experience from agent execution trajectories and evolving skills based on downstream task feedback. However, existing methods primarily represent skills as natural language documents, intertwining procedural logic with descriptive knowledge and making skills difficult to maintain and evolve. To address this limitation, we propose PASE (Program-Aided Patchable Skill Evolution), a program-aided framework that iteratively evolves skills by associating them with executable programs. Unlike prior approaches that encode trajectory-derived experience primarily in natural language, PASE separates reusable procedural logic into editable programs, enabling targeted updates to executable components while reducing the need to repeatedly revise natural language skills. Extensive experiments across diverse models and benchmarks demonstrate that PASE consistently outperforms all baselines, by achieving over 2.8% improvements. Further analyses show that PASE exhibits greater evolutionary stability and generalisation capability, highlighting the critical role of programmatic knowledge in skill evolution. We will release all data and code via GitHub.
BibTeX
@misc{wang2026program,
  author = {Jiahao Wang and Yuqi Xiong and Qing Yang and Zhipeng Xu and Zhenghao Liu and Zulong Chen and Yubin Bao},
  title = {{Program-Aided Patchable Skill Evolution}},
  year = {2026},
  eprint = {2611.14019},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.14019},
}
Figure