Self-evolving agents accumulate reusable skills by appending successful procedures and failure fixes. Over time, the same requirement is often restated in several branches, examples, and warnings, while common action sequences are copied rather than reused. The resulting skill becomes expensive to inject and difficult to maintain. Generic prompt compression is ill-suited to this setting because a skill is not a flat passage: its name and description define when it applies, its workflow controls execution, its tool and output contracts constrain validity, and rare exceptions may remain essential even when no sampled task activates them. Evaluation-guided compression can test these behaviors, but it introduces rollouts, cost, and dependence on the compression-time evaluation set. We present SkillZip, an evaluation-free method that compresses a skill by finding its shortest faithful structural explanation. The intuition 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, and keep only the differences as explicit exceptions. We formalize this intuition as a typed minimum description-length objective over a skill contract and a residual, subject to a hard coverage constraint for every extracted trigger, workflow edge, tool requirement, obligation, and output field. The formulation provides simple sharing thresholds, preserves unique rare rules by construction, and supports efficient local updates. SkillZip has a one-shot mode with one structured extraction call and deterministic optimization, and a continual Zip-on-Write mode that integrates each self-evolution patch without replaying tasks or reparsing the full history. Through comprehensive experimental evaluations, we demonstrate the effectiveness and superiority of SkillZip in compression performance, generalizability, and cost overhead.
Alex: Welcome to another episode of ResearchPod. Today, we're looking at a paper about a surprisingly practical problem in AI development: what happens when an AI agent's instruction manual gets so long and cluttered that it starts working against itself. The authors call this "skill bloat."
Sam: So this is about AI systems accumulating too many rules over time? Like, they keep adding new ones but never clean out the old ones?
Alex: Exactly. Think about how these agents learn. Every time they make a mistake or encounter a new situation, a developer adds a new rule or warning to their instructions. But the old rules rarely get removed. Over time, you end up with a manual that's padded with overlapping, sometimes contradictory guidance.
Sam: It's like a student who sticks a new note on their textbook every time they get a question wrong. After a year, the book is buried under sticky notes, and finding the actual rule you need takes longer than just guessing.
Alex: That's a good way to put it. And the problem isn't just inconvenience. When an AI has to read through a bloated set of instructions every time it acts, it's slower, more likely to get confused by contradictions, and harder for developers to maintain. The authors introduce a method called SkillZip to address this directly.
Sam: So SkillZip is the editor that cleans up the manual. But how does it decide what to keep and what to cut? Deleting the wrong rule could break everything.
Alex: That's exactly the right concern, and it's what makes this approach different from simple text compression. Most compression tools look at which words appear most often and trim the rest. SkillZip doesn't do that. Instead, it reads the instructions the way a programmer reads code — looking at the underlying structure, not just the surface words.
Sam: So it's trying to understand what the instructions actually do, not just what they say?
Alex: Right. It maps out things like: which rules trigger which actions, which tools the agent is required to use, and how different steps connect to each other. Once it has that map, it can spot redundancy at a structural level. If the same requirement appears in five different places, SkillZip recognises that and states it once, cleanly, at the top.
Sam: That reminds me of how programmers avoid repeating themselves. Instead of writing the same block of code in ten different places, you write it once as a function and just call it whenever you need it.
Alex: That's precisely the analogy the paper leans on. The underlying principle is called Minimum Description Length — the idea that the most efficient version of any set of rules is the one that captures everything accurately while using the least amount of space. Not by cutting corners, but by eliminating genuine redundancy.
Sam: And the parts that aren't redundant — the unique exceptions and edge cases — those get kept?
Alex: They do. SkillZip calls those "residuals." They're the instructions that are genuinely unique to a specific situation and can't be folded into a general rule. Those stay in, clearly labelled, as separate items.
Sam: Here's what I'd push back on, though. All of this is happening without actually running the AI through any tasks to check if the compressed version still works. That feels like a significant gamble.
Alex: It's a fair concern, and it's one the authors take seriously. The reason they avoid running tasks — what they call "rollouts" — is partly practical. Testing an AI agent against a full library of scenarios is expensive and slow. But more importantly, they argue you shouldn't need to if you've done the structural verification correctly.
Sam: What does that verification actually look like?
Alex: The system runs what you might call a structural audit. Before it finalises the compressed version, it checks that every single trigger, every workflow connection, and every tool requirement from the original instructions is still present and accounted for. Nothing gets dropped. If the audit passes, the compressed manual is formally guaranteed to cover the same ground as the original.
Sam: So it's not just hoping the compression worked — it's proving it, at least at the level of structure.
Alex: Exactly. And there's a further safeguard for cases where the system isn't certain. If SkillZip encounters a piece of text it can't parse with high confidence — something vague or ambiguous — it doesn't try to compress it. It locks that section in place, verbatim, and leaves it completely untouched.
Sam: So it only reorganises what it fully understands. Anything it can't be sure about, it leaves alone. That's a conservative approach, but it makes sense — better to keep a redundant line than to accidentally remove a guardrail.
Alex: That's the design philosophy throughout. The authors are treating these instruction sets less like documents and more like formal contracts. A contract has to be precise, complete, and internally consistent. You can't just paraphrase a clause and hope the meaning survives.
Sam: That's an interesting reframe. Most people probably think of AI instructions as just... text. Natural language that the AI interprets loosely. But this paper is arguing they should be treated with the same rigour as legal or technical specifications.
Alex: And that shift in thinking is what makes the approach scalable. If you treat instructions as structured contracts, you can maintain them systematically as the agent grows. You're not relying on a developer to manually read through thousands of lines and spot the redundancies by eye.
Sam: Does that mean SkillZip can keep up with an agent that's still actively learning? Like, if new rules are being added regularly, can it compress on the fly?
Alex: The paper describes an incremental update mechanism for exactly that reason. Rather than waiting for the manual to become completely unmanageable and then doing a full rewrite, SkillZip can process new additions as they come in, folding them into the existing compressed structure without starting from scratch each time.
Sam: So it's more like ongoing maintenance than a one-time cleanup. The manual stays lean as it grows, rather than being cleaned up after the fact.
Alex: That's the goal. And because the whole process doesn't require running tasks, it's fast enough to be practical in that kind of ongoing role. The authors see this as part of a longer-term shift in how we think about AI agent maintenance — moving from reactive patching to something more like continuous, structured upkeep.
Sam: It's a bit like the difference between a codebase that gets refactored regularly versus one that only gets touched when something breaks. The first one stays readable; the second one becomes a mess that nobody wants to open.
Alex: That's a fitting way to end on. The paper's core argument is that as AI agents become more capable and longer-lived, the way we manage their knowledge has to become more disciplined. SkillZip is one approach to building that discipline in from the start. Thanks for listening to ResearchPod.