One-sentence Summary

Researchers from Alibaba Group, Zhejiang University, and Duke University propose SkillZip, an evaluation-free skill compression method that discovers reusable structural explanations via a typed minimum-description-length objective with hard coverage constraints, enabling one-shot and continual Zip-on-Write modes and achieving superior compression, generalizability, and cost efficiency.

Key Contributions

• Evaluation-free skill compression is formalized as a typed contract representation, and a shortest faithful explanation objective is derived that unifies rule sharing, scope lifting, workflow reuse, and exception encoding with a hard coverage constraint that preserves rare rules independently of task frequency.
• SkillZip provides a one-shot mode using a single structured extraction call followed by deterministic optimization, and a Zip-on-Write mode that continually integrates new self-evolution patches through local updates without replaying tasks or reparsing the full history.
• Comprehensive experiments demonstrate that SkillZip achieves substantial gains in compression performance, robust generalizability, and low cost overhead.

Introduction

Self-evolving agents accumulate procedural knowledge as append-only instructions, causing skills to grow with redundant rule copies, repeated workflows, and scattered exceptions. This bloat increases context cost and obscures the governing logic, yet existing prompt compression methods estimate token importance relative to a query or answer distribution and cannot preserve the typed procedural structure (branch guards, temporal order, tool contracts) that must remain invariant across all future tasks. The authors introduce SkillZip, which treats a skill as a typed contract and compresses it by extracting shared rules, scope lifting, workflow reuse, and exception encoding into a shorter faithful explanation. The method guarantees that every normative requirement, including rare edge cases, is retained without observing any task, trajectory, or verifier, and it supports both one-shot compression of an evolved checkpoint and Zip-on-Write integration into continual self-evolution.

Method

The authors propose SkillZip, an evaluation-free compression framework that treats natural-language skills as structured, typed contracts rather than homogeneous text. By decoupling interpretation from optimization, the method ensures that every operational requirement is preserved without relying on downstream task execution or behavioral verifiers.

At the core of the framework is the extraction of a typed contract from the source skill. As shown in the figure below, this contract decomposes the skill into six distinct components: the interface (triggers and exclusions), the workflow (control flow and actions), the tool protocol (arguments and preconditions), scoped rules (normative constraints with guards), the output contract (validation and fields), and supporting evidence. This decomposition is critical because it dictates which compressions are safe; for instance, two sentences about the same tool cannot be merged if they require different arguments.

The overall pipeline consists of two main phases: One-Shot Compression and Continual Compression (Zip-on-Write), as illustrated in the framework diagram.

In the One-Shot Compression phase, the process begins with a deterministic scan of the skill document to parse headings, lists, and code blocks, reducing the structural inference burden on the language model. Next, a schema-constrained model recovers the typed contract, mapping source spans to typed units. Any ambiguous spans that cannot be interpreted with sufficient confidence are placed into a locked residual and copied verbatim. The system then proposes type-compatible reuse candidates, such as merging equivalent rules or extracting shared workflow fragments, using hashing and embedding indices. Finally, it selects the shortest covering explanation by minimizing the rendered token cost under a Minimum Description Length objective, ensuring that all required contract units remain covered. A structural audit reparses the compressed output to verify that no triggers, guards, or output fields were lost, restoring source spans if necessary.

For agents that evolve over time, the Continual Compression phase, or Zip-on-Write, maintains the contract via a sidecar file containing the current contract, scope tree, and workflow graph. When a new patch arrives, the system extracts patch units and compares them against the existing contract neighborhood using four operations: Absorb (restating existing requirements), Refine (adding guards or exceptions), Extend (introducing new requirements), and Refactor (creating new shared rules). The host selects the feasible operation that minimizes the increase in the description length objective. To capture long-range reuse that local updates might miss, the system tracks approximate counts and triggers a global repack when the estimated recoverable saving exceeds a threshold or the contract grows significantly. Throughout this process, the model proposes structure, but a deterministic host validates the schema and enforces coverage before atomically updating the skill.

Experiment

The experiments evaluate SkillZip, an evaluation-free skill compression method, across three agent backbones and three benchmarks using self-evolved skills. They show that self-evolution causes skills to grow over five times their initial length, and SkillZip compresses this bloat by about 31% while preserving or improving task performance without any task rollouts, making it 3.5× faster than the baseline SkillReducer. Compressed skills transfer better across models, and enabling continual compression from the start of evolution prevents length bloat entirely without sacrificing accuracy.

SkillZip compresses evolved skills more aggressively than SkillReducer while preserving task performance near the best uncompressed results. The method requires no task rollouts, leading to substantial speed gains, and its compressed skills transfer across models with higher retention. Continual compression from the start of self-evolution prevents skill bloat without sacrificing accuracy. SkillZip achieves a higher compression rate (27.1%) than SkillReducer (10.5%) while keeping performance on BFCL-V4, LiveMath, and Spreadsheet within a narrow margin of the uncompressed evolved skill or the best compressed alternative. Unlike SkillReducer, SkillZip uses no task rollouts for validation, resulting in a 3.5× average speedup and avoiding dependence on executable environments and behavioral verifiers. When transferred to a different model, SkillZip retains 0.97 of LiveMath performance, outperforming SkillReducer's 0.91 retention, indicating that preserving explicit rules and constraints yields a more model-independent skill representation. Activating continual compression from round 1 of self-evolution caps skill length growth at 1.6×–1.9× of the seed, a 38%–50% reduction relative to uncompressed endpoints, while final accuracy matches or slightly exceeds the uncompressed skill. Delaying compression until later rounds only partially recovers accumulated redundancy, showing that preventing bloat from the start is more effective than removing it afterward.

SkillZip is substantially faster than SkillReducer across all datasets, achieving an average speedup of roughly 3.5×. The speedup results from eliminating task rollouts, which dominate compression cost even though SkillReducer uses fewer direct LLM calls. SkillZip requires zero rollouts, making the evaluation‑free design far more efficient. SkillZip is on average 3.5× faster than SkillReducer, with compression times of 207–332 seconds compared to 587–1331 seconds. SkillReducer requires 40–80 validation rollouts per compression, while SkillZip uses none, showing that environment interaction dominates the end‑to‑end cost. Despite making fewer direct compressor LLM calls (3 vs 4–8), SkillReducer’s rollout overhead makes it significantly slower.

The experiments compare SkillZip with SkillReducer on compressing self-evolved skills across several benchmarks. SkillZip achieves higher compression rates and nearly matches uncompressed performance while requiring no task rollouts, yielding a 3.5× average speedup and avoiding environment dependencies. Its compressed skills transfer better to other models, and applying continual compression from the start of self-evolution caps skill growth and prevents bloat without sacrificing accuracy, unlike delayed compression that only partially recovers redundancy.