Stop copy-pasting skills: SkillZip's evaluation-free fix for bloated agents

Self-evolving agents build their skills the way some codebases grow: by appending. A procedure works, so it gets saved. A failure produces a fix, so the fix gets added too. Before long, the same requirement is stated in several branches, examples, and warnings, and common action sequences are copied rather than reused. The result is a skill that is expensive to inject and difficult to maintain.

A paper posted to arXiv on August 11, 2026 proposes a different habit. SkillZip compresses a skill by finding its shortest faithful structural explanation. The intuition, as the abstract phrases it, is "explain once, reference many":

• State a repeated rule once at the scope where it applies.
• Factor a repeated action sequence into a shared procedure.
• Keep only the differences as explicit exceptions.

Why skill bloat becomes a correctness problem

The paper argues that generic prompt compression is the wrong tool here, because a skill is not a flat passage. It is a structured artifact: a name and description that define when it applies, a workflow that controls execution, and tool and output contracts that constrain validity. Rare exceptions may stay essential even when no sampled task activates them, so a compressor that only protects what a test set exercises can quietly break a skill.

The obvious alternatives have real costs. Generic prompt compression treats a skill as flat prose, so it has no way to respect the parts that are load-bearing. Evaluation-guided compression can test whether those behaviors survive, but it introduces rollouts, cost, and a dependence on the compression-time evaluation set. SkillZip is built to make that test unnecessary.

That matters because the cost of a skill is paid every time it is used. When an agent injects its skill text into context, every redundant branch, example, and warning rides along on every turn the skill is active. The cost compounds, and the same bloat that slows inference also makes the skill harder for a human to audit. A compressed skill is cheaper to run, and a skill that states each rule once is cheaper to maintain. The pattern is familiar to anyone who has watched an agent load a heavy skill and stall, not because the reasoning failed, but because the context did, a failure mode the planning trap article documents in production agents.

How SkillZip's formulation works

The method formalizes that intuition as a typed minimum description-length objective over a skill contract and a residual. A hard coverage constraint binds every extracted trigger, workflow edge, tool requirement, obligation, and output field, which is what stops compression from silently dropping a structural necessity. The formulation provides simple sharing thresholds, preserves unique rare rules by construction, and supports efficient local updates.

SkillZip runs in two modes. One-shot mode performs a single structured extraction call followed by deterministic optimization. The continual Zip-on-Write mode integrates each self-evolution patch without replaying tasks or reparsing the full history. For agents that keep evolving their skills, the second mode is the point: the compression tracks the learning instead of forcing a full re-compression whenever something changes.

Where SkillZip fits in skill-layer research

The bloat problem is not unique to this paper. A related paper, SkillCoach, posted to arXiv in July 2026, describes skill repositories as a reusable operational layer for LLM agents, one that encodes SOPs, domain rules, tool workflows, scripts, and validation routines, and warns that overlapping skills in realistic repositories make reliable skill-use difficult. SkillZip works on the same layer from the storage side, shrinking skills so that overlap has less room to cause trouble.

Nor is SkillZip the only recent attempt at the broader cost problem. A separate study found that adding procedural skills to LLM agents can backfire: the extra context introduces regressions, and the loaded skill starts costing more than it returns, a dynamic the regression tax analysis measures directly. SkillZip attacks the same failure from the storage direction, and the two papers pair naturally: one documents when skills hurt, the other proposes a way to keep them lean.

What the abstract leaves unverified

What the abstract does not provide is numbers. It reports "comprehensive experimental evaluations" and claims superiority in compression performance, generalizability, and cost overhead, but no quantitative results appear in the abstract itself. The experiments may well confirm the claims; for now, the claims are the paper's own.

The case for the method is clear. Compression that costs no rollouts and depends on no evaluation set is attractive for any team running self-evolving agents. The two operating modes give it a practical shape: one-shot for a clean slate, Zip-on-Write for systems whose skills keep changing. The open question is whether the structural discipline holds up on messy real-world repositories, where the line between a shared procedure and a genuine exception is rarely obvious. That is a question the paper's own experiments are meant to answer.