MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation

🕒 Published (v1): 2026-05-26 17:59 UTC · Source: Arxiv · link

Why this paper was selected

MUSE-Autoskill: self-evolving skill management with creation, memory, and evaluation

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

MUSE-Autoskill (Memory-Utilizing Skill Evolution) is a training-free, skill-centric agent framework that treats skills as long-lived, versioned assets managed through a five-stage lifecycle: creation, memory, management, evaluation, and refinement. Unlike prior work that produces static skill artifacts, MUSE introduces per-skill memory (.memory.md), unit-test-gated registration, and automatic refinement triggered by test failures. On SkillsBench, self-generated skills exceed the human-skill accuracy ceiling, and transfer cleanly to a different agent without modification.

Problem

Existing automatic skill systems address only isolated lifecycle stages: they either create skills without runtime context, lack structured per-skill experience accumulation, ship unvalidated skills with no test harness, or flood long-horizon tasks with uncompressed conversation history. The result is skills that are static, unreliable, and agent-specific—they cannot be reliably reused, improved over time, or ported to a different agent without retraining.

Method

MUSE wraps a standard ReAct (Plan → Action → Observation) loop with five tightly coupled subsystems:

Skill Creation. A built-in skill_create tool, invokable from within the runtime loop, generates a structured skill package: SKILL.md (interface spec), scripts/ (executable code), tests/ (unit tests), and resources/ (auxiliary data), following Anthropic's Agent Skills format. Skills are not registered until all unit tests pass; failures route to the Refiner.

Skill Evaluation. After creation or update, the Evaluator runs the tests/ suite inside an isolated sandbox. Pass/fail signals gate registration into the Skill Bank and trigger the refinement loop.

Skill Refinement. On test failure, the Refiner patches the skill package (diff-style code edits) and re-runs tests. At the management level, overlapping skills are merged and chronically-failing or unused skills are pruned.

Multi-level Memory. Three scopes: (1) short-term — current task context with adaptive two-level compression (per-node then chain-level summarization via a DAG of conversation nodes with mutable parent_id for the active chain and immutable history_prev/next for full history); (2) long-term — persistent cross-session notes never compressed; (3) skill-level — each skill carries its own .memory.md appended with usage observations, failure modes, and input quirks, surfaced whenever the skill is loaded.

Skill Management. At task start, available skill metadata from SKILL.md is injected into the system prompt (progressive-disclosure pattern). Selection occurs during Planning; the catalog is indexed by name, description, inputs, and outputs.

Key Contributions

• Formal five-stage skill lifecycle (creation, memory, management, evaluation, refinement) as a unifying design principle
• Per-skill .memory.md memory that accumulates cross-task experience, distinct from shared short- and long-term memory
• Unit-test-gated create → evaluate → register loop ensuring only validated skills enter the Skill Bank
• Adaptive context compression via a two-level DAG-node scheme supporting long-horizon tasks without context blowup
• Empirical validation of cross-agent skill transfer: skills generated by MUSE injected unmodified into a different agent (Hermes)

Results

All experiments use GPT-5.5-backed agents on SkillsBench (51 real-world tasks, Docker-evaluated, four super-domains):

• MUSE with human skills: 68.40% overall vs. Codex 67.3%, Hermes 61.2% — best in 3 of 4 domains
• MUSE baseline lift: +15.21 pp over its own no-skills baseline (53.19% → 68.40%)
• Self-generated skills on 35 tasks where generation succeeds: 87.94%, surpassing the human-skill ceiling
• Cross-agent transfer: injecting MUSE-generated skills into Hermes raises Hermes accuracy by +10.51 pp, closing 79% of the gap between Hermes without skills and Hermes with human skills
• Domain breakdown (with skills): Sci. & Eng. 52.1%, Data Analysis 67.3%, Document Processing 68.4%, Ops & Planning 88.9% (MUSE), compared to Hermes highs of 82.2%, 82.2%, 71.1%, 88.9%

Limitations

• SkillsBench is only 51 tasks; generalization to larger, more diverse benchmarks is undemonstrated
• Skill generation succeeds on only 35 of 51 tasks in the self-generation condition; the failure cases are not analyzed
• Context compression (adaptive summarization) may lose information on very long tasks — the paper does not quantify information loss
• Evaluation relies on a single LLM backbone (GPT-5.5); cross-backbone portability is claimed but not benchmarked across multiple models
• No wall-clock or cost analysis: the overhead of the create → evaluate → refine loop, sandbox lifecycle, and multi-level memory lookups is unreported
• The merging and pruning mechanisms are described architecturally but not ablated

Relevance to Harnesses / Meta-Harnesses

MUSE-Autoskill is essentially a meta-harness: it manages a population of subordinate skill-harnesses (SKILL.md packages with scripts, tests, and resources) through a gated lifecycle, making it directly analogous to a harness orchestrator that governs tool registration, validation, and versioning. The unit-test-gated registration pattern — where a new skill must pass its own test suite before entering the bank — is a canonical harness quality-control mechanism applied at skill granularity. The .memory.md per-skill experience accumulation extends standard harness logging toward a self-improving registry, relevant to harness designers who want tools that adapt from runtime feedback rather than requiring manual updates. Cross-agent transfer without modification demonstrates that skill packages can function as portable, self-describing harness units, a property central to meta-harness interoperability.