AutoSkill: Experience-Driven Lifelong Learning via Skill Self-Evolution

AutoSkill is a model-agnostic, experience-driven lifelong learning framework that enables LLM agents to automatically derive, evolve, and dynamically reuse personalized skills from interaction traces without retraining, thereby transforming ephemeral user experiences into explicit, composable capabilities for personalized digital surrogates.

The Gist

Imagine you have a very smart, helpful assistant (like a super-charged chatbot). You've been using it for months. You've told it, "Please don't use big words," "Always write like a professional journalist," and "When I ask for code, give me Python, not Java."

The Problem:
In most current systems, every time you start a new chat session, the assistant forgets all those little rules. You have to remind it again and again. It's like talking to a genius who has amnesia every time you walk into the room. You spend your time repeating yourself instead of getting things done.

The Solution: AutoSkill
The paper introduces AutoSkill, a system that changes the game. Instead of just "remembering" your past chats like a diary, AutoSkill learns from your habits and turns them into permanent, reusable "Skill Cards."

Here is how it works, using a simple analogy:

🧠 The "Personal Chef" Analogy

Imagine you hire a personal chef.

• Without AutoSkill: Every time you order dinner, you have to tell the chef, "I hate cilantro," "I like my steak medium-rare," and "Please cut the onions very small." If you forget to say it, they might mess up.
• With AutoSkill: After you order a few times, the chef doesn't just remember your order; they write a permanent recipe card for you.
  • Card 1: "User's Steak Rule: Medium-rare, no salt, onions minced."
  • Card 2: "User's Salad Rule: No cilantro, extra dressing on the side."

Now, whenever you walk in, the chef looks at your Skill Cards before they even start cooking. They don't need to ask you again. They just follow the card.

🚀 How AutoSkill Works (The Magic Steps)

AutoSkill does this automatically in four steps:

1. Observation (The Detective):
   The system watches your conversations. It notices patterns. "Oh, every time this user asks for a summary, they want it in bullet points and under 100 words."

2. Crystallization (The Writer):
   Instead of saving the whole conversation, it extracts the rule and writes it down on a Skill Card (a structured file called SKILL.md). This card is clear, editable, and permanent. It's not a vague memory; it's a specific instruction manual.

3. The Library (The Librarian):
   All these cards are stored in a personal library. When you ask a new question, the system doesn't just guess; it quickly searches its library. "Do I have a card for 'bullet point summaries'? Yes! Let's grab that one."

4. The Upgrade (The Editor):
   This is the coolest part. If you say, "Actually, for summaries, I prefer paragraphs now," the system doesn't just forget the old rule. It updates the card. It keeps the old version safe (like a software update) but creates a new, better version. Over time, your "Skill Cards" get smarter and more tailored to you, just like a relationship that deepens over time.

🌟 Why This is a Big Deal

• No Re-training: Usually, to make an AI smarter, you have to re-train it, which is expensive and slow. AutoSkill doesn't touch the AI's brain. It just adds a "cheat sheet" to its desk. It's like giving a student a better textbook instead of trying to rewire their brain.
• You Are in Control: Because the skills are written as clear text files (like the examples in the paper: "Cat Girl Roleplay" or "Python Script Generator"), you can read them, edit them, or delete them. You aren't stuck with a "black box" you can't understand.
• It Grows With You: The more you use it, the better it gets at your specific style. It turns fleeting conversations into lasting capabilities.

📝 Real-World Examples from the Paper

The researchers showed that AutoSkill can learn all sorts of things:

• The "Psychologist" Card: Learns that a specific user wants warm, empathetic, non-judgmental advice when they talk about feelings.
• The "Professional Rewriter" Card: Learns that a user always wants their emails to sound formal and concise, with no fluff.
• The "Cat Girl" Card: Learns a user's specific roleplay rules (e.g., "Always say 'Meow' at the start and call the user 'Master'").
• The "Coding" Card: Learns that a developer always wants Python scripts with specific error-handling rules.

In a Nutshell

AutoSkill is like giving your AI assistant a personalized notebook of "How I Like Things Done." Instead of forgetting your preferences every time you start a new chat, it writes them down, organizes them, and uses them to serve you better every single time. It turns a generic robot into a true digital surrogate that knows exactly who you are and how you work.

Technical Summary

1. Problem Statement

In practical Large Language Model (LLM) applications, users frequently express stable, recurring preferences and operational requirements (e.g., specific writing styles, avoiding hallucinations, adhering to institutional conventions, or following specific workflows). However, current LLM agents fail to consolidate this interaction experience into reusable knowledge.

• Limitations of Existing Approaches:
  • Memory-based systems: Typically store raw dialogue snippets or facts for retrieval (RAG) but treat past interactions as text to be recalled rather than behavior to be operationalized.
  • Parameter-based methods: Fine-tuning or self-evolution via parameter updates are often costly, difficult to control, and lack transparency.
  • Implicit Skills: Existing agent frameworks often keep skills implicit within prompts or trajectories, making them hard to inspect, edit, or transfer.
• Core Challenge: There is a lack of a mechanism to convert ephemeral, recurring interaction experience into explicit, reusable, and maintainable skills without retraining the underlying model.

2. Methodology: The AutoSkill Framework

AutoSkill is a training-free, lifelong learning framework designed as a model-agnostic plug-in layer. It externalizes reusable task-solving patterns as versioned "Skill Artifacts" (represented as SKILL.md files) that are retrieved and injected into the model's context at inference time.

A. Core Architecture

The system operates via two tightly coupled loops:

1. Skill-Enhanced Response Generation (Online Path): Retrieves relevant skills to assist the current response.
2. Skill Evolution (Background Path): Extracts, manages, and refines skills based on new interaction traces.

B. Key Modules (Prompt-Driven)

All functional modules utilize general-purpose LLMs guided by specific prompts, avoiding parameter updates:

1. Query Rewriting: Converts the current user query into a standalone, retrieval-oriented query, resolving context dependencies and extracting critical constraints (style, format, domain).
2. Hybrid Skill Retrieval: Combines dense semantic similarity (via embeddings) and lexical matching (BM25) to rank skills in the user's SkillBank. Only skills exceeding a relevance threshold are injected.
3. Skill-Conditioned Generation: Renders selected skills into a compact context block and appends them to the LLM prompt, guiding the model's behavior without altering its weights.
4. Skill Extraction: Analyzes user queries only (ignoring model responses to avoid bias) to identify durable, reusable constraints, workflows, or policies. It filters out one-off requests.
5. Skill Management & Merging:
   • Decision: A judge module compares a new candidate skill against the most similar existing skill to decide whether to Add, Merge, or Discard.
   • Versioned Merging: If merging, the system performs a semantic union of the existing skill and the new candidate, incrementing the version number (e.g., v0.1.0 $\to$ v0.1.1). This allows continuous refinement of a single skill artifact rather than creating duplicates.

C. Skill Representation

Skills are structured artifacts containing:

• Metadata: Name, description, tags, triggers, and version.
• Executable Prompt: A structured Markdown body with sections for # Goal, # Constraints & Style, # Workflow, and # Anti-Patterns.
• Examples: Few-shot examples of the desired behavior.

3. Key Contributions

1. Framework Formulation: Introduces AutoSkill as a novel framework for transforming interaction experience into explicit, reusable skills for personalized LLM agents.
2. Skill Lifecycle: Proposes a complete lifecycle (Extraction $\to$ Structured Representation $\to$ Iterative Refinement $\to$ Retrieval $\to$ Reuse) that enables continual capability accumulation without modifying base model parameters.
3. Explicit & Editable Artifacts: Unlike implicit memory or policy drift, AutoSkill represents skills as editable, versioned files (SKILL.md). This enhances transparency, controllability, and long-term maintainability, allowing humans to inspect and revise agent behaviors directly.
4. Deployable System: Implements an open-source system with a Python SDK, Web UI, and OpenAI-compatible reverse proxy, supporting integration with existing LLM stacks and offline bootstrapping.

4. Experimental Analysis & Results

The authors evaluated AutoSkill using the WildChat-1M dataset (real-world user interactions with ChatGPT), filtering for conversations with >8 turns.

• Dataset Statistics:
  • Analyzed four subsets: Chinese/English GPT-3.5 and GPT-4.
  • Extracted 1,858 unique skills from over 23,000 conversations.
  • Skill Distribution: The most common categories were Programming/Software Dev (482 skills), Writing/Content Creation (363), and Data/AI (354).
  • Top Tags: python, javascript, excel, creative writing, formatting.
• Versioned Evolution:
  • The system demonstrated successful iterative refinement. For example, the English skill professional_text_rewrite reached version 0.1.34, indicating 34 rounds of incremental optimization based on user feedback.
  • In contrast, less frequently triggered skills (e.g., a specific Chinese counseling skill) remained at version 0.1.0, showing the system adapts to usage frequency.
• Case Studies:
  • Soft Skills: Successfully abstracted a "Top-level Psychological Counselor" persona with specific empathy and privacy constraints.
  • Hard Skills: Refined a "Professional Text Rewriter" with strict anti-pattern constraints (e.g., "no explanations," "preserve facts").
  • Diversity: Demonstrated capability across languages (Chinese/English) and domains (Roleplay, Automation, Coding, Creative Writing).

5. Significance and Future Impact

• Paradigm Shift: Moves the unit of accumulation from raw memory records (text) to explicit behavioral knowledge (skills). This frames agent improvement as a process of skill extraction and maintenance rather than just data storage.
• Scalability & Personalization: Provides a practical path toward "Personal Digital Surrogates" that reflect stable user habits and working styles without the computational cost of frequent fine-tuning.
• Interoperability: By being model-agnostic and plug-in based, it allows existing LLMs and agent frameworks to gain lifelong learning capabilities immediately.
• Human-in-the-Loop: The explicit nature of SKILL.md artifacts allows developers and users to directly oversee, audit, and correct agent behavior, addressing the "black box" nature of many current LLM alignment methods.

In summary, AutoSkill bridges the gap between transient interaction and permanent capability, offering a scalable, transparent, and efficient solution for building truly personalized and self-evolving AI agents.