Technical Summary: SKILL-DISCO

Problem Statement

Large Language Model (LLM) agents frequently solve similar interactive tasks from scratch, leading to redundant reasoning, excessive execution traces, and brittle generalization. While prior work has explored reusing workflows or inducing executable skills, a fundamental gap remains: it is unclear which task scenarios admit reusable procedural skills and how to represent the shared structural logic across diverse successful traces. Existing methods often synthesize skills directly from traces using LLMs without an explicit notion of shared structure, resulting in libraries that are fragmented, redundant, and tied to surface-level patterns rather than reusable procedural logic.

Methodology: SKILL-DISCO Framework

The authors propose SKILL-DISCO, a distillation-and-compilation framework designed to discover reusable procedural skills in FSM-defined scenarios (scenarios with finite states, finite actions, and deterministic transitions). The core insight is to view successful agent traces as paths in an unknown transition graph and procedural skills as reusable, parameterized control-flow subgraphs within that graph.

The framework operates in two primary phases:

1. Distillation Phase

This phase approximates the latent lifting function that maps raw traces to reusable Parameterized Finite-State Machine (PFSM) subgraphs. It consists of three stages:

• Trace Normalization: Raw agent logs (interleaving reasoning, actions, and observations) are converted into structured, executable intermediate Python programs. This step makes control flow (loops, branches) and parameterized entities (objects, locations) explicit while preserving the order of primitive operators.
• Subgoal-level Operation Extraction: The normalized programs are decomposed into intermediate-granularity operators. These are coherent sequences of steps corresponding to subgoals (e.g., "search and retrieve"), filtering out single primitive actions or overly specific full-trace routines.
• Procedural Skill Consolidation: Extracted operations are clustered based on shared parameterized execution structures. Even if concrete objects or locations differ, operations sharing the same control-flow logic (e.g., a loop searching locations until an object is found) are grouped. High-coverage clusters are identified as candidate procedural skills.

2. Compilation Phase

This phase transforms structural candidates into callable, executable, and verifiable artifacts.

• Skill Specification: Each candidate is augmented with a formal definition, including a typed signature, natural language description, behavioral requirements (pre/post-conditions), and metadata. This provides a domain-agnostic vocabulary for agents.
• Synthesis and Verification: The system synthesizes Python code implementing the specified behavior using primitive actions. These candidates undergo verification on held-out tasks to check runtime correctness, postcondition satisfaction, and action savings. Only skills that pass verification (with limited retries for synthesis) are included in the final library.

Key Contributions

1. Explicit Scope Definition: The paper formalizes procedural skill discovery within FSM-defined scenarios, where successful traces are paths in an unknown graph and skills are well-defined transition structures.
2. Structural Formulation: Skills are formulated as reusable Parameterized Finite-State Machine (PFSM) subgraphs. This allows matching multiple successful traces under parameter binding, moving beyond treating each trace as an independent routine.
3. SKILL-DISCO Framework: A novel pipeline that distills compact, high-coverage PFSM subgraphs from traces and compiles them into verified, executable skills.
4. Empirical Validation: Extensive experiments demonstrate that structurally grounded skills improve success rates and efficiency across different benchmarks and model scales.

Experimental Results

The framework was evaluated on ALFWorld (text-based household tasks) and WebArena (web navigation tasks).

• Performance Gains: SKILL-DISCO achieved the highest success rates (SR) across all benchmarks. On ALFWorld, combining SKILL-DISCO with CodeAct improved SR from 96.3% to 99.3%. On WebArena, it improved ReAct SR from 23.9% to 29.1%, outperforming prior offline skill-induction methods.
• Efficiency: The framework significantly reduced average agent turns (e.g., -54.5% on ALFWorld for ReAct), as agents delegate repeated low-level sequences to reliable skills.
• Cross-Model Transfer: A skill library induced by a strong model (GPT-4o) successfully transferred to weaker models (e.g., Qwen3.5-4B/9B, GPT-4o-mini). Notably, Qwen3.5-9B equipped with GPT-4o-induced skills surpassed the performance of the inducer itself on ALFWorld (98.5% vs. 96.3%), demonstrating effective procedural knowledge distillation.
• Reliability and Compactness: SKILL-DISCO produced a much smaller skill library (5 skills vs. 110 for baselines on ALFWorld) with higher step compression. Crucially, it reduced execution errors from 75.3% to 0.0% on ALFWorld, as verified skills are less error-prone than ad-hoc generation.

Significance and Limitations

The paper argues that representing shared experience as reusable execution structures (PFSM subgraphs) rather than textual routines or instance-specific scripts is key to robust agent improvement. By compiling skills into verified code, the system ensures reliability and enables transfer across model families and scales.

The authors acknowledge specific limitations:

• Domain Scope: The approach is effective for tasks with reusable procedural structures (navigation, automation, tool use) but offers no benefit for pure NLP tasks (text generation, reading comprehension) lacking executable procedures.
• Dependency on Model Capability: The quality of the pipeline relies on the compiler LLM's reasoning and code-generation abilities; insufficient capability can lead to incorrect or overly specific skills.
• Requirement for Success: The distillation signal relies entirely on successful traces. In domains where even frontier models rarely succeed, the corpus may be too sparse for reliable extraction.