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:
- Random Sampling: The agent attempts a batch of tasks using its current skill-program pairs, generating execution trajectories.
- Programmatic Patch Proposal: A specialized "Proposer Agent" analyzes these trajectories. It uses programmatic tools to read existing skills and historical patches to diagnose failures.
- Adaptive Patchable Update: Instead of rewriting skills from scratch, the proposer issues "patches"—line-level edits (using
CREATE,REPAIR, orDELETEoperations). This allows for surgical fixes to either the Python logic or the NL guidance. - 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.
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.
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