🤖 AI

Anything2Skill: Compiling External Knowledge into Reusable Skills for Agents

The paper proposes Anything2Skill, a framework that compiles heterogeneous external knowledge into reusable, structured procedural skills stored in a SkillBank, enabling agents to achieve significantly higher success rates than standard RAG approaches by combining declarative evidence with executable domain expertise.

Original authors: Qianjun Pan, Yutao Yang, Junsong Li, Jie Zhou, Kai Chen, Xin Li, Qin Chen, Liang He

Published 2026-06-09

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Qianjun Pan, Yutao Yang, Junsong Li, Jie Zhou, Kai Chen, Xin Li, Qin Chen, Liang He

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant but inexperienced assistant (an AI agent) who is very good at reading books and finding facts. You ask them to fix a complex machine, and they can quickly find the manual, read the parts list, and tell you what the machine is made of. This is how current AI systems work, a method called RAG (Retrieval-Augmented Generation). They are great at finding "declarative evidence"—facts and descriptions.

But here's the problem: The manual tells the assistant what a screwdriver is, but it doesn't always clearly say how to use it to fix a specific broken gear in the right order. The assistant has to read the manual, guess the steps, try to fix it, fail, read the manual again, and guess again. It's like trying to learn how to cook a complex dish just by reading a grocery list and a description of the ingredients, without ever seeing a recipe or a chef cook it.

ANYTHING2SKILL is a new system designed to solve this. Think of it as a "Skill Compiler" or a "Cookbook Creator."

The Core Idea: Turning Manuals into Recipes

Instead of just letting the AI read the raw manuals, logs, and documents every time it faces a task, ANYTHING2SKILL takes all that messy information and compiles it into reusable "skills."

Here is how it works, using a simple analogy:

The Raw Ingredients (The Knowledge Base): Imagine a giant library filled with scattered notes, old repair logs, chat transcripts, and official manuals. Right now, an AI has to search through this library every single time it needs to do something.
The Chef's Prep (The Extraction): ANYTHING2SKILL acts like a master chef who reads all those scattered notes. It doesn't just summarize them; it looks for procedures. It asks: "What are the exact steps to do this? What tools are needed? What mistakes should be avoided?"
The Skill Tree (The Organization): The system organizes these procedures into a structured "Skill Tree." It's like a family tree for tasks.
- Macro-protocols: Big-picture strategies (e.g., "How to manage a software project").
- Micro-skills: Specific, tiny actions (e.g., "How to run this specific command to delete a file").
- Safety Rules: Warnings (e.g., "Never do X if Y is happening").
The SkillBank (The Reusable Library): Once the "recipes" are written, they are stored in a permanent, organized SkillBank. This isn't just a pile of documents; it's a database of executable instructions. Each "skill" has a contract that says: "If you see situation X, do steps A, B, and C, but avoid D."

How It Helps the AI Agent

When the AI agent faces a new task, it now has two superpowers working together:

Power 1: The Librarian (RAG): It still searches the original library to find specific facts or the latest updates (the "what").
Power 2: The Veteran Mentor (SkillBank): It pulls a pre-made "skill" from the SkillBank. This skill tells the agent exactly how to do the task, step-by-step, based on what worked before.

The Result:
The paper tested this on two real-world tasks: managing CSV data files (qsv) and managing GitHub repositories (GitHub-CLI).

Without ANYTHING2SKILL: The AI was like a smart student reading a manual for the first time. It got about 65–82% of the tasks right.
With ANYTHING2SKILL: The AI had the "compiled recipes." It got about 82–92% right.
With BOTH: The AI had the facts and the recipes. It got 98.85% of the CSV tasks and 94.10% of the GitHub tasks right.

The Big Takeaway

The paper claims that we shouldn't just treat external knowledge as a pile of facts to be read. We should treat it as a source of hidden procedures that can be extracted, organized, and turned into reusable "skills."

By compiling these latent procedures into a SkillBank, we move AI agents from simply "accessing knowledge" (reading the manual) to "reusing capabilities" (knowing exactly how to do the job). It's the difference between giving someone a dictionary and giving them a well-organized instruction manual for every possible job they might need to do.

Technical Summary: ANYTHING2SKILL

Problem Statement

Retrieval-Augmented Generation (RAG) enables agents to access external knowledge at inference time, yet it primarily retrieves fragmented declarative evidence (e.g., passages, manuals, logs). Consequently, agents must repeatedly reconstruct task procedures from these fragments at runtime. This limitation is critical in agentic settings where success depends not only on retrieving facts but on following specific procedures: determining when to invoke tools, executing correct action sequences, satisfying constraints, and avoiding failure cases. Existing skill-based agents often rely on manually specified skills, skills learned through environment interaction, or code generated during task solving, failing to leverage the vast amount of latent procedural knowledge already embedded in heterogeneous external knowledge bases.

Methodology

The paper proposes ANYTHING2SKILL, a taxonomy-guided framework designed to compile heterogeneous external knowledge into reusable, retrievable, and executable skills. The framework operates through a pipeline of extraction, management, and inference augmentation.

1. Skill Extraction with Skill-Tree Prior

Given a corpus of knowledge records $K$ (documents, dialogues, logs, trajectories), the system decomposes records into strict evidence windows. It employs a plan-and-expand extraction strategy under a skill-tree prior:

Taxonomy Prior: A skill taxonomy $\mathcal{T}$ defines stable asset types (e.g., macro_protocol, session_skill, micro_skill, safety_rule) and hierarchy levels. This constrains extraction toward procedural capabilities rather than free-form summaries.
Plan-and-Expand: An LLM-based planner first identifies distinct skill candidates from evidence windows. A subsequent expansion stage converts these candidates into structured skill drafts.
Procedural Validity: Candidates are filtered to ensure they contain procedural components (workflow steps, action moves, constraints) and can be mapped to the taxonomy.
Output: Extracted drafts are converted into structured skill contracts specifying invocation conditions, contraindications, action moves, workflow steps, constraints, output specifications, supporting evidence, and confidence scores.

2. Skill Management in the SkillBank

To transform local drafts into a deployable SkillBank ( $\mathcal{B}$ ), the system performs three management steps:

Document-Level Compilation: Drafts describing overlapping capabilities are grouped by a taxonomy-aware identity key. A compiler produces a canonical skill specification for each group, constrained to preserve asset types and taxonomy nodes while citing only supported evidence.
Registry-Level Reconciliation: Incoming skills are reconciled with the persistent SkillBank using hybrid retrieval (dense similarity, sparse lexical matching, and taxonomy compatibility). A management model predicts lifecycle actions: CREATE, STRENGTHEN, REVISE, MERGE, SPLIT, UNCHANGED, or DISCARD. This ensures versioning, conflict resolution, and prevents merging incompatible skill layers (e.g., merging a safety rule into a micro-skill).
Visible Skill-Tree Projection: Active skills are organized into a visible hierarchy based on the taxonomy. The system performs same-level consolidation to reduce navigational redundancy, selecting primary skills based on lifecycle status and provenance coverage.

3. Skill-Augmented Retrieval

At inference time, the agent utilizes a dual-retrieval mechanism:

Declarative Evidence: Retrieves task-specific passages from the original knowledge base ( $C_q$ ) via standard RAG.
Procedural Guidance: Retrieves relevant compiled skills from the SkillBank ( $S_q$ ).
The agent solves the task conditioned on both sources, allowing RAG to provide factual grounding while the SkillBank provides reusable procedural memory.

Key Contributions

Framework Proposal: Introduction of ANYTHING2SKILL, which extends retrieval-augmented agents from simple knowledge access to reusable capability acquisition by compiling heterogeneous records into structured, evidence-grounded skills.
Implementation Pipeline: A complete pipeline for skill compilation and management, including evidence-window construction, plan-and-expand extraction under a skill-tree prior, structured contract generation, taxonomy-aware consolidation, registry-level reconciliation, lifecycle tracking, and versioned updates.
Empirical Validation: Demonstration that augmenting RAG agents with a compiled SkillBank substantially improves task success on command-line benchmarks, outperforming RAG-only and skill-only baselines.

Experimental Results

The framework was evaluated on two command-line agent benchmarks: qsv (CSV operations) and GitHub-CLI (repository management).

Baselines: A Base Agent (no external context) achieved 81.60% (qsv) and 64.70% (GitHub-CLI) success.
RAG Only: Improved success to 95.41% (qsv) and 76.50% (GitHub-CLI).
ANYTHING2SKILL Only: Achieved 91.95% (qsv) and 82.30% (GitHub-CLI), demonstrating that compiled skills provide reusable procedural knowledge even without task-time document retrieval.
ANYTHING2SKILL + RAG: Achieved the highest performance with 98.85% on qsv and 94.10% on GitHub-CLI.

The results indicate that while RAG provides necessary declarative facts, compiled skills offer complementary procedural guidance (invocation conditions, action sequences, constraints) that significantly reduces the burden of reconstructing procedures at runtime. The improvement was particularly pronounced on GitHub-CLI, where complex workflows benefit more from pre-compiled procedural structures.

Significance and Claims

The paper claims that compiling latent procedural knowledge into explicit, reusable skills is an effective method for extending retrieval-augmented agents. The authors argue that agents should not merely retrieve external documents as declarative evidence but should also organize and reuse the procedural capabilities latent within that knowledge. By transforming documents, manuals, and logs into a persistent SkillBank, ANYTHING2SKILL enables agents to move from knowledge access toward capability reuse, bridging the gap between retrieval-augmented generation and skill-based capability reuse.