PaperlayerView exact revision on arXiv

Source-linked AI summary

Compile Away Uncertainty: Self-Evolving Agent Skills via Programmatic Compilation

Chengyu Yang, Yunxiang Zheng, Zongzheng Li, Jiamei Li, Boxun Lan, Xiaoyu Liu, Xiaoyu Zhang, Xiaohong Chen, Ming Hu

arXiv:2610.39508v1cs.AI

TL;DR

Self-evolving skills preserve procedural knowledge, but executing them through repeated LLM interpretation can produce uncertainty and similar executable capabilities may be rebuilt across skills. SKILLCOMPILER selectively compiles well-specified operations into validated programs and reuses program assets. Across five benchmarks and six model families, it reports higher mean task performance, with up to 32.33% improvement.

  • Problem

    Evolved skills still require repeated LLM interpretation that can yield different outcomes, while similar executable capabilities are often rebuilt rather than persistently reused.

    Source: §I · p. 1

  • Method

    SKILLCOMPILER selectively compiles well-specified operations into validated programs, retains LLM reasoning for context-dependent decisions, and reuses validated program assets across evolving skills.

    Source: §I · p. 2

  • Results

    Across five benchmarks and six model families, SKILLCOMPILER shows higher mean task performance, with up to 32.33% improvement over state-of-the-art methods.

    Source: §I · p. 2, §V · p. 9

  • Takeaways & Limitations

    The framework combines programmatic execution and context-dependent reasoning in hybrid skill skeletons, while persistent assets support reuse; fixed-bank repetitions show fewer outcome reversals.

    Source: §V · p. 9

    Compilation depends on identifiable operation boundaries, observable preconditions, and independently checkable effects, so ambiguous or context-dependent decisions remain under LLM control.

    Source: F. Discussion · p. 8

Abstract

from arXiv · show

Self-evolving agent skills enable AI agents to accumulate and refine reusable procedural knowledge from interaction experience without updating model parameters. However, since such skills are typically represented as textual documents and executed through LLM reasoning, even previously learned procedures must be repeatedly interpreted and regenerated, introducing avoidable uncertainty into every execution. In contrast, program execution is deterministic and independently verifiable. Intuitively, transforming well-specified operations into executable programs can reduce reliance on LLM reasoning and, consequently, reduce execution uncertainty. Motivated by this intuition, we introduce SKillCompiler, a self-evolving skill framework that integrates programmatic compilation into the skill evolution process. Specifically, SkillCompiler adopts an executability-aware skill compilation strategy that decomposes skills into fine-grained operations, analyzes their executability, and constructs hybrid skill skeletons that retain LLM reasoning for context-dependent operations while compiling well-specified ones into validated programs. To avoid redundant program synthesis and enable executable knowledge to accumulate across evolving skills, we further design a program asset reuse mechanism that organizes validated programs as reusable assets, retrieves existing implementations whenever applicable, and synthesizes and verifies new programs only when necessary. Extensive experiments on five benchmarks and six model families demonstrate that SkillCompiler consistently outperforms state-of-the-art methods, achieving up to 32.33\% improvement in task performance.

I. INTRODUCTION

SKILLCOMPILER addresses execution uncertainty and repeated construction of executable capabilities in evolving skills by selectively compiling suitable operations and reusing validated programs. Experiments report up to 32.33% improvement in task performance.

I. INTRODUCTION

  • Existing skill evolution methods face execution uncertainty and repeated construction of similar capabilities across evolving skills.Skills can require repeated LLM interpretation, while executable procedures are often built for individual skills or tasks rather than persistently reused.Source: §I · p. 1
  • Well-specified operations can be executed as programs, while LLM reasoning remains available for context-dependent decisions.Validated programs can also be accumulated and reused across evolving skills.Source: §I · p. 1
  • SKILLCOMPILER selectively compiles executable skill operations and reuses validated program assets across evolving skills.Its executability-aware strategy retains LLM reasoning for context-dependent operations, while the asset mechanism retrieves compatible programs or synthesizes and verifies new ones when needed.Source: §I · p. 2
  • Up to 32.33% improvement in task performance is reported for SKILLCOMPILER over state-of-the-art methods.Source: §I · p. 2

II. RELATED WORK

Prior work preserves experience as reusable skills and improves skill content or execution. SKILLCOMPILER combines operation-level selective compilation with persistent reuse of resulting program assets.

A. Experience Accumulation and Reusable Agent Skills

B. Agent Skills Evolution

  • Prior skill-evolution methods refine skill content or augment execution with workflows, tools, and executable representations.SKILLCOMPILER differs by analyzing operation-level executability and persistently reusing compiled program assets across skill evolution.Source: B. Agent Skills Evolution · p. 2

A. Overview

  • SKILLCOMPILER analyzes and compiles operations into a hybrid skill skeleton, reuses or synthesizes validated programs, and refines skills from execution traces.The overview describes a task analyzer, programmer, executor, skill optimizer, and program asset manager.Source: A. Overview · pp. 2–3

B. Executability-Aware Skill Compilation

SKILLCOMPILER selects operations for programmatic execution while retaining LLM reasoning for context-dependent work. It decomposes tasks into reusable operation contracts and assigns each operation an execution mode.

B. Executability-Aware Skill Compilation

1) Operation Decomposition.:

  • Each operation is represented by inputs, outputs, observable preconditions, expected local effects, checks, and reusable guidance.Task-specific entities and values are instantiated when the operation is invoked, supporting reuse across tasks.Source: 1) Operation Decomposition · p. 3

2) Operation Analysis.:

  • Operations with explicit inputs and outputs, specified procedures, observable preconditions, verifiable effects, and bounded tool support are programmatic; unresolved or context-dependent work remains agent-guided.This assignment moves well-specified procedures to deterministic execution while retaining LLM reasoning for dynamic observations and contextual decisions.Source: 2) Operation Analysis · p. 3

3) Skill Skeleton Construction.:

The hybrid skill skeleton organizes programmatic and agent-guided operations together, preserving their execution requirements. Selected operations receive compatible validated programs before integration; unsuccessful validation can prompt repair or leave the operation agent-guided.

3) Skill Skeleton Construction.:

  • The skill skeleton records operation occurrences, execution order, data and prerequisite relations, and current argument bindings.Unresolved task-specific values are instantiated from observations during execution, and the skeleton checks interface compatibility and input sources.Source: 3) Skill Skeleton Construction · pp. 3–4

4) Programming and Validation.:

  • For programmatic operations, the system reuses a compatible implementation when available or synthesizes one from the operation contract, tools, and execution evidence.Programs are checked in isolation for successful execution, input/output conformity, and satisfaction of expected effects; failures guide repair, and only validated programs are integrated.Source: 4) Programming and Validation · p. 4

C. Program Asset Reuse

SKILLCOMPILER accumulates validated programs as reusable assets to avoid synthesizing similar implementations repeatedly. Retrieval combines similarity-based discovery with contract and environment checks before reuse.

C. Program Asset Reuse

  • Validated implementations are stored in the Program Asset Bank and reused across skills when compatible operations recur.Different tasks may share operations with the same underlying capability.Source: C. Program Asset Reuse · p. 4

1) Compatibility-Based Program Retrieval.:

  • Retrieval uses lexical similarity to find candidates, then filters for capability and contract compatibility before ranking.Skill Skeletons use lexical similarity; atomic skills are ranked by lexical Dice similarity, historical utility, and active status.Source: 1) Compatibility-Based Program Retrieval · p. 4
  • A retrieved program is eligible only when its inputs, preconditions, environment interfaces, and validation record apply to the current operation.Lexical similarity finds candidates; interface and state compatibility govern whether they can be invoked.Source: 1) Compatibility-Based Program Retrieval · p. 4
  • When multiple implementations exist, the system reuses a uniquely eligible or preferred one; otherwise selection stays agent-guided, and absent a compatible asset it synthesizes and validates a program.Applicability conditions and validation evidence are retained for each implementation.Source: 1) Compatibility-Based Program Retrieval · p. 4

D. Skill Optimization

SKILLCOMPILER uses execution traces to revise failing operations locally, then merges compatible operations and validates program changes before reuse.

D. Skill Optimization

  • During execution, validated programs handle programmatic operations while the target agent handles the rest, and traces record actions, observations, bindings, checks, and task feedback.These traces support subsequent skill updating.Source: D. Skill Optimization · p. 4

1) Trace-Based Skill Revision.:

  • When a task fails, operation-level contract checks retain operations that met expectations and guide local revisions to conditions, bindings, dependencies, guidance, or faulty programs.Program failures trigger repair and validation rather than regeneration of the entire skill.Source: 1) Trace-Based Skill Revision · p. 4

2) Skill Merging and Updating.:

  • Operations are merged only when they share capability semantics and compatible contracts; task-specific entities and values are parameterized, while conflicting operations remain separate.Compatibility covers input/output semantics, preconditions, expected effects, and checking requirements.Source: 2) Skill Merging and Updating · p. 5
  • After reorganization, agent-guided-only changes can be used directly, while changed programmatic operations are retrieved or regenerated and validated before the candidate skill is executed again.Successful execution confirms the update; failure supplies a new trace for local revision.Source: 2) Skill Merging and Updating · p. 5

IV. EXPERIMENTS

The experiments compare SKILLCOMPILER with skill and prompt baselines across five benchmarks and six language models, using shared evaluation conditions and multiple seeds.

IV. EXPERIMENTS

  • The experiments assess baseline performance, repeated-execution reliability, resource consumption, and the contributions of key components through ablations.The section proceeds from setup and performance comparisons to reliability, cost, and ablation analyses.Source: §IV · p. 5

A. Experimental Setup

  • The evaluation covers five benchmarks spanning open-domain question answering, document understanding, mathematical reasoning, and long-horizon interactive tasks.Table I summarizes training, validation, and test partition statistics for the benchmarks.Source: A. Experimental Setup · p. 5, Table I · p. 5
  • Experiments use six language models and compare SKILLCOMPILER with seven baselines, including no-skill, human-written-skill, and skill-evolution methods.The listed baselines include Trace2Skill, EvoSkill, EmbodiSkill, GEPA, and SkillOpt.Source: A. Experimental Setup · p. 5
  • Methods share task partitions, available tools, evaluators, and inference settings within each model–benchmark configuration; main performance and cost results average three seeds.Persistent skill states are frozen during testing.Source: A. Experimental Setup · p. 5

B. Performance Comparison

SKILLCOMPILER achieves the highest average score across six model families, with gains over each model’s strongest baseline. Improvements vary by benchmark, with the largest reported gain on LiveMath.

2) Performance with different model families:

1) Performance on different benchmarks:

  • 32.33%: SKILLCOMPILER improves GLM-5.3-Flash performance on LiveMath, where the largest gains generally occur across model families.Kimi-K2.6 also improves over the strongest benchmark-specific baselines on all four benchmarks.Source: 1) Performance on different benchmarks · pp. 5–6
  • Gains are larger on LiveMath and OfficeQA than on SearchQA and DocVQA, and the paper associates stronger benefits with well-specified operations that can be compiled into validated programs.The reported task-performance benefits vary across task characteristics.Source: 1) Performance on different benchmarks · p. 6

3) Performance on long-horizon interaction tasks:

On long-horizon ALFWorld tasks, SKILLCOMPILER achieves the highest success rate and also shows lower execution instability. Resource savings vary by benchmark and baseline.

3) Performance on long-horizon interaction tasks:

  • 98.26% success on ALFWorld was highest, beating EmbodiSkill by 4.73% and No Skill’s 79.60% by 18.66%.It also exceeded SkillOpt by 10.20% and GEPA by 11.44%.Source: 3) Performance on long-horizon… · p. 7

C. Uncertainty Analysis

  • 3.0% EIR on ALFWorld was lowest, while APS, APSsucc, and EPR were 81.3%, 82.5%, and 44.8%.On LiveMath, SKILLCOMPILER achieved 78.67% EM and 11.00% EIR, reducing EIR from SkillOpt’s 32.00% by 65.6%.Source: C. Uncertainty Analysis · p. 7, Figure 2 · p. 8

D. Cost Analysis

  • 2.695M learning tokens on LiveMath was 41.9% below SkillOpt and 52.1% below GEPA; inference used 0.450 model calls/task, lowest among methods.On ALFWorld, inference was 47.015k tokens/task, 7.6% and 32.7% below SkillOpt and GEPA; LiveMath inference tokens exceeded SkillOpt but remained below EvoSkill, EmbodiSkill, and GEPA.Source: D. Cost Analysis · p. 7, Table V · p. 8, Table VI · p. 8

E. Ablation Study

ALFWorld ablations identify complementary contributions from the Skill Skeleton, Programmer, and Skill Optimization. The discussion notes that compilation depends on identifiable operations and validation under tested conditions.

E. Ablation Study

  • 53.48% SR without Programmer was the largest ablation drop; token use rose to 7.36x and EIR to 19.40%.Without the Skill Skeleton, SR was 95.52%, tokens rose 2.75x, and EIR reached 8.21%; without Skill Optimization, SR was 95.52%, tokens rose 2.48x, and APS fell from 81.27% to 61.95%.Source: E. Ablation Study · p. 8, Table VIII · p. 8

F. Discussion

  • Larger gains on LiveMath and OfficeQA suggest selective compilation is particularly beneficial when tasks have recurring, explicit, verifiable operations.Tasks dominated by context-dependent interpretation offer fewer opportunities to replace LLM reasoning with executable procedures.Source: F. Discussion · p. 8
  • Compilation requires identifiable operation boundaries, observable preconditions, and independently checkable effects; local validation does not guarantee generalization to unseen conditions.The benefits of program reuse also depend on contract compatibility and sufficient reuse to amortize synthesis and validation costs; evaluation focused primarily on controlled benchmarks.Source: F. Discussion · p. 8

V. CONCLUSION

  • Across five benchmarks and six model families, SKILLCOMPILER showed higher mean task performance and fewer outcome reversals in fixed-bank LiveMath and ALFWorld repetitions.Resource savings varied by baseline, while ALFWorld ablations identified contributions from programmatic execution, explicit operation dependencies, and optimization.Source: §V · p. 9

APPENDIX

The appendix specifies how task scores, repeated executions, paths, and resource variability are measured, and sets boundaries on program validation, reuse, and experimental evaluation.

Repeated-run metrics

  • Repeated-run EM or SR averages all |T|K binary outcomes, while EIR and RSR use tasks—not repetitions—as their denominator.EIR counts tasks with correctness flips; RSR is the fraction solved in every repetition.Source: APPENDIX · p. 10

Path metrics

  • Path metrics use canonical environment-action sequences, expanding program-internal actions and excluding restoration-discarded actions from accepted paths while retaining them in raw cost.APS is success-conditioned; direct answers without a meaningful action sequence receive no artificial perfect path score.Source: APPENDIX · p. 10

Program execution and reuse

  • Persistent Program Coverage counts tasks with an actually started invocation from the frozen bank, while a planned or temporary program does not count.Cross-Skill Reuse requires a used persistent program version to be invoked by at least two distinct Skill Skeletons; repeated instances of one skeleton are insufficient.Source: APPENDIX · pp. 10–11
  • Program Invocation Success measures successful started invocations, but does not establish final task correctness or universal semantic validity.Consumed Program Outputs is a conservative, trace-confirmed lower bound; invocation or a recorded return alone is insufficient evidence of downstream consumption.Source: APPENDIX · pp. 10–11

Validation scope

  • Local validation supports behavior only for checked inputs, environments, and effects, not exhaustive branch coverage or semantic equivalence on arbitrary inputs.Programs run through permitted benchmark interfaces under bounded execution, while unresolved semantics and context-dependent decisions remain with the target agent.Source: APPENDIX · pp. 11–12

Independent learning runs and repeated execution

  • Main task performance and cost metrics are calculated within each independent learning run and averaged across seeds 42, 43, and 44; repeated-execution analyses use the skill state learned with seed 42.Repeated executions hold persistent skills, task inputs, initial environment states, and inference settings fixed, examining execution variation rather than variation between independently learned banks.Source: APPENDIX · p. 12

Ablation scope

  • The ablations evaluate three interventions on ALFWorld with DeepSeek-V4.1-Flash, learning each condition from an empty bank with seed 42.The conditions remove Skill Skeleton construction, program synthesis and invocation, or subsequent semantic skill optimization, respectively.Source: APPENDIX · p. 12

Resource accounting

  • Learning and test resource accounting include model requests and retries, while fully program-executed tasks contribute zero model requests.Main cost tables average seeds 42–44; ablation costs average three repeated evaluations of each condition’s seed-42 bank.Source: APPENDIX · p. 12
Loading 2610.39508v1…