Skills that evolve,
agents that compound.
First surfaced in Tandemly Briefing — 2026-05-28
Every agent with a skill library has the same quiet problem: the library doesn't get better on its own. ByteDance researchers built the framework that changes that. Five components handle the full lifecycle of a skill: creation after task completion, quality-gated admission, refinement from new examples, and retirement when performance falls off. The result closes most of the gap between no skills and human-written skills without a human writing anything.
Static skill libraries
set the ceiling at deploy time.
Most skill libraries for agents are written once and edited by hand. That approach works until you want the agent to improve on its own.
Skill libraries make agents faster and more consistent. Instead of reasoning from scratch on every task, an agent can retrieve a skill it has used before, adapt it, and execute. The approach works well enough that most frameworks include some form of it.
The problem is that most skill libraries are static. You write the skills, load them in, and the agent calls them. If a skill stops working, nobody knows unless a human notices and edits the file. If the agent solves a new class of problem it has never seen before, that solution disappears when the session ends. The library is exactly as good as the last time someone sat down to improve it.
There is a secondary problem: quality decay. Real skill libraries accumulate entries over time. Some skills were well-written and generalize well. Others were written under pressure and handle only one specific case. In a static library, the well-written and the poorly-written skills sit side by side with no signal distinguishing them. Agents retrieve both.
The obvious fix is to let the agent manage the library itself. But "self-improving agent" has been promised more often than it has been built. What it requires is not a single mechanism but a full lifecycle: creation, storage, evaluation, refinement, and retirement working together.
What if every successful task execution could automatically produce a skill, test it, refine it, and retire it if it starts underperforming? Can a fully autonomous skill lifecycle close most of the gap between an agent with no skills and an agent given carefully human-written ones?
Five components,
one complete lifecycle.
MUSE-Autoskill (Memory-Utilizing Skill Evolution) breaks the skill lifecycle into five distinct components, each responsible for one stage. No human writes or edits skills after the initial configuration.
Because skills are stored as vector-indexed descriptions rather than agent-specific code, they are not tied to the agent that created them. The team tested whether skills generated by one agent could improve a different agent without any additional tuning. They could. This makes the skill library a shared organizational asset, not a per-agent artifact.
Auto-generated skills
beat the human ceiling.
The benchmark compared three conditions: no skills, human-written skills (the intended ceiling), and MUSE-Autoskill's autonomous library. The auto-generated library came closer to the human ceiling than the gap implied.
On the 35 tasks where skill generation succeeded, MUSE-Autoskill reached 87.94% accuracy. The human-skill baseline sits below that number on those tasks. The agent's self-generated descriptions, tested against held-out examples before admission, outperformed what a human wrote for the same task category.
That figure comes with a caveat the paper is upfront about: it applies only to the subset of tasks where skill generation succeeded. The paper does not report what fraction of tasks produced a successful skill, so the ceiling-beating result cannot be generalized to the full task distribution without knowing the denominator.
When MUSE-Autoskill's generated skills were injected into Hermes, a different agent that had not participated in skill creation, Hermes gained 10.51 percentage points. That number closes 79% of the gap between Hermes with no skills and Hermes with human-written skills.
The practical implication: an organization running multiple agents with overlapping task coverage could use one agent to build the skill library and share it across all of them. The creation cost is paid once; the improvement distributes.
Libraries with automatic retirement accumulated measurably fewer low-quality entries than static-library baselines over the same number of tasks. This finding is not surprising in principle, but the experiment makes it concrete: the absence of a retirement path produces compounding retrieval noise. The longer the library runs without retirement, the worse that noise gets.
The 87.94% ceiling-beating figure covers only the 35 tasks where skill generation succeeded. The distribution of success rates across the full task set is not reported, which limits what can be said about reliability in the general case. Cross-agent skill transfer was tested on one agent pair. Whether the result holds across more diverse agent architectures is an open question.
What this means
for agent builders.
The paper's most actionable contribution is not the system as a whole but the three mechanisms that make it work: the quality gate, the retirement path, and skill-level memory. Each can be adopted independently.
Where to go
from here.
Five concrete next steps for taking the skill lifecycle seriously in your own systems.