Technical Summary: SKILLPYRAMID

Problem Statement

Recent advances in Large Language Models (LLMs) have enabled agents to flexibly invoke skills for complex tasks. However, long-term agent improvement is fundamentally constrained by a lack of systematic skill construction, accumulation, and transfer. Current approaches often treat skills as isolated, task-specific solutions stored in flat libraries. This leads to three primary limitations:

1. Redundancy: Agents redundantly construct similar capabilities across different tasks.
2. Inefficiency: Agents fail to effectively transform past experience into reusable assets, often exploring from scratch when no exact skill match is found.
3. Poor Generalization: Agents struggle to generalize task-specific skills to novel scenarios because the internal transferable experience within existing skills remains underexploited.

Existing skill-management frameworks improve organization but typically reuse skills as stored units rather than composing new capabilities from the underlying experience of prior skills.

Methodology: SKILLPYRAMID

The authors propose SKILLPYRAMID, a hierarchical skill consolidation framework designed to transform a static skill collection into a dynamic, self-evolving system. The framework organizes skills into a multi-level pyramid where lower levels contain fine-grained, reusable atomic capabilities, and upper levels abstract recurring problem-solving patterns.

Core Components

The system operates via a multi-agent framework consisting of four key modules:

1. Relation Analyzer:

   • Coarse Grouping: Inspects skill names and descriptions to group potentially related skills.
   • Fine-Grained Analysis: Analyzes the full structured content of grouped skills to identify specific reuse relations. It outputs assignments for the Relation Builder, specifying the relation type (e.g., shared steps, subset relations, or shared schemas) and providing natural language rationale.

2. Relation Builder:

   • Downward Atomic Extraction: Identifies shared low-level capabilities across a group of skills and extracts them as atomic skills. These are minimal, reusable units (e.g., "find object → take object") that are less tied to specific task instances. Original skills are rewritten to explicitly reference these atomic skills via a dependency field.
   • Upward Abstract Induction: Identifies shared high-level functional structures across a group of skills and induces abstract skills. These summarize common problem-solving patterns (e.g., "acquire → transform → place") and serve as higher-level guidance for task decomposition.

3. Skill Creator:

   • When a new task arrives, this agent retrieves relevant skills from the current pyramid.
   • It performs Framework Construction using higher-level abstract skills to outline the task structure and logic.
   • It performs Detail Instantiation using lower-level atomic skills to fill in executable operations, inputs, and checks.
   • If no single skill matches, it synthesizes a new task-specific skill by composing components from the hierarchy rather than generating from scratch.

4. Self-Evolution Mechanism:

   • To handle open-ended streams of tasks, the system incrementally updates the pyramid.
   • When a new skill is created, the Relation Analyzer treats it as a query to find related existing skills.
   • The Relation Builder constructs new reuse relations involving the new skill, and these updates are incrementally inserted into the pyramid without rebuilding it from scratch.

Key Contributions

1. Hierarchical Organization: A framework that organizes agent skills into a growing hierarchy, improving transferability through explicit reuse and dependency modeling.
2. Pyramid Construction Mechanism: A dual-process approach using a Relation Analyzer and Builder to construct atomic skills via downward extraction and abstract skills via upward induction.
3. Task-Driven Self-Evolution: A mechanism that retrieves, composes, and generates skills while incrementally updating the pyramid, allowing the system to adapt over time.

Experimental Results

The authors evaluated SKILLPYRAMID on three benchmarks: ALFWorld (embodied household tasks), WebShop (e-commerce navigation), and ScienceWorld (scientific experiments). Experiments were conducted across four backbone LLMs (DeepSeek-V3.2, GPT-4.1, Gemini 2.5 Pro, and Qwen3-235B).

Performance Metrics:

• Reward/Success Rate: SKILLPYRAMID achieved an average reward of 73.7, outperforming baselines including ReAct (53.4), Reflexion (59.6), ExpeL (61.3), and ReAct+Skills (65.8).
• Generalization: On unseen tasks, SKILLPYRAMID achieved an average reward of 84.8, significantly higher than ReAct+Skills (73.9).
• Efficiency: The method reduced the average number of interaction steps by 27.7% (from ~20.2 to 14.6 steps on average), indicating more targeted action sequences.

Ablation Studies:

• Removing atomic skills reduced performance, particularly on tasks rich in reusable low-level operations.
• Removing abstract skills disproportionately hurt performance on tasks requiring multi-step procedural composition.
• Removing self-evolution (freezing the pyramid) led to performance degradation over time, confirming the need for incremental adaptation.
• Generating skills from scratch (without reusing the pyramid) resulted in performance worse than using a flat skill library, highlighting the necessity of grounding new skills in the existing hierarchy.

Web-Mined Skills:
When applied to noisy, web-mined skills on the GAIA-Lite benchmark, SKILLPYRAMID achieved higher accuracy and fewer steps compared to using flat web skills, demonstrating its ability to consolidate noisy data into a structured, usable format.

Significance and Claims

The paper claims that SKILLPYRAMID transforms a skill collection from a static resource pool into a dynamic evolution system. Its significance lies in demonstrating that:

• Structured skill consolidation is a promising direction for building agents that accumulate reusable capabilities over time.
• The effectiveness of the framework stems not merely from exposing agents to external skills, but from reorganizing them into reusable low-level components and high-level procedural guidance.
• Explicit reuse relations and hierarchical organization enable stronger generalization to novel task instances compared to flat retrieval or experience-based reflection alone.

The authors acknowledge limitations, including the computational cost of initial pyramid construction, reliance on capable backbone LLMs for relation identification, restriction to text-based benchmarks, and the use of a single deterministic run for evaluation. They also note that the current pyramid uses only two reuse axes and does not model richer temporal or causal dependencies.