PaperlayerView exact revision on arXiv

Source-linked AI summary

SkillZip Pro: Execution-Aware Dynamic Compression of Progressively Loaded Skills for Self-Evolving Agents

Xiaofan Bai, Chao Liu, Hongqiang Lin, Di Wu, Mingli Song, Xuan Jin, Xipeng Cao, Yuhong Li

arXiv:2608.30785v1cs.AI

TL;DR

Production skills are progressively loaded directory bundles, so flat or root-only compression can miss deployment cost or increase always-loaded context. SkillZip Pro performs evaluation-free, cross-file compression while preserving routing and entry usability through an unchanged harness. Across production and benchmark evidence, it reduces bundle and per-run token costs while maintaining quality and routes, whereas unprotected flattening can destroy fidelity.

  • Problem

    Root-only compression misses most deployed text, while flattening destroys progressive-loading boundaries and can move rare branch details into always-loaded context.

  • Method

    SkillZip Pro compresses complete skill bundles across files and preserves routing and entry contracts in an ordinary directory without changing the agent harness.

  • Results

    38.1% fewer deployed bundle tokens and 10.4% fewer measured per-run tokens were achieved in production without measurable loss in decision quality, while every routing pair was preserved across benchmarks and deployment.

  • Takeaways & Limitations

    Effective skill compression must preserve the loading structure through which agents access content, not merely reduce the amount of text.

Abstract

from arXiv · show

Production agent skills are directory bundles, not isolated prompts. The root is loaded at activation; references, schemas, scripts, assets, and nested subskills are loaded only when an execution path needs them. Compressing only the root misses most deployment cost and may move branch-specific details into the always-loaded context. Flattening instead destroys progressive-loading boundaries. We introduce \method, an evaluation-free compressor for complete, progressively loaded skill bundles. It leaves the agent harness unchanged and emits an ordinary directory. The method combines two safeguards. First, it compresses \emph{across files}, removing content from a reference or subskill when the root or a declared environment contract already provides it. Second, it preserves routing, so every required file and directly callable entry remains reachable after rewriting. Users can configure \method along two independent axes. \emph{One-Shot} mode rebuilds the full bundle; \emph{Continual} mode reuses state and applies Zip-on-Write after each evolution patch. \emph{Persistent} compression rewrites the shipped bundle to reduce storage and runtime context. \emph{Transient} compression keeps that bundle byte-identical and builds a task-specific view, reducing only per-run context after build cost. Entry contracts mark private, public, and conditional resources; a multi-entry audit preserves standalone public subskills. On a production content-moderation skill evaluated by our industrial multi-round harness, \method removes \hl{38\%} of skill bundle tokens and \hl{10.4\%} of end-to-end per-run tokens with no quality loss, while an unprotected 71\% configuration loses up to 26 accuracy points to one-sided false positives. On a multi-entry bundle, \method effeciently reduces token cost while near-perfectly preserving every route and public entry.

I. Introduction

SkillZip Pro compresses complete, progressively loaded skill bundles across files while preserving routing, loading boundaries, and independent entry usability. It supports distinct compression modes and lifecycles, reducing production bundle and runtime costs without sacrificing decision quality.

  • Problem: Production skills are directory bundles whose root, references, subskills, scripts, schemas, and assets load at different stages or execution paths.Catalog metadata precedes activation; the root loads on selection, while path-specific resources load only for relevant branches.
  • Problem: Root-only compression misses deployed text, while flattening files destroys progressive disclosure and can move rare branch details into every invocation.Compression must account for the resource graph and execution-dependent loading rather than a flat string.
  • Method: SkillZip Pro jointly compresses content across the root, references, and subskills without moving rarely used content into the always-loaded root.It removes cross-file redundancy, factors repeated branch content within loading scope, and can place guarded branches into on-demand capsules.
  • Method: Routing constraints and entry contracts keep required branches reachable and preserve independent usability for public subskills and references.The emitted ordinary directory works with unchanged readers, paths, and loading behavior; Persistent compression requires a multi-entry audit when public entries are modified.
  • Method: One-Shot rebuilds the full bundle, Continual applies Zip-on-Write after evolution patches, Persistent rewrites shipped files, and Transient builds task-specific views.The modes govern when compression occurs, while the lifecycles govern whether the canonical bundle changes.
  • Results: 38% fewer deployed skill tokens and 10.4% fewer end-to-end per-run tokens were achieved on a production skill while preserving decision quality.The compressor emits an ordinary directory and leaves the agent harness unchanged.

D. Four Costs, One Constrained Objective

SkillZip Pro optimizes storage and execution exposure jointly over progressively loaded bundles rather than relying on a single compression ratio. Its placement-aware objective avoids promoting sparse branch content into the root while accounting for persistent and transient deployment costs.

  • Cost model: The objective uses an empirical execution-path distribution and a deployment-weight parameter λ=0.05, subject to bundle faithfulness.When traces are unavailable, explicit branch guards induce a uniform distribution over reachable leaf paths.
  • Cost model: SkillZip Pro measures catalog, activation, path, and deployment costs separately because a single compression ratio can hide regressions in always-loaded or path-specific context.For each metric x, reduction is 1 − C_x(B′)/C_x(B), with negative values retained rather than clipped.
  • Lifecycle: Persistent compression rewrites the canonical bundle, whereas Transient compression leaves it unchanged and builds a task-specific execution view whose benefit applies only after build and cache costs.The two lifecycles therefore differ in storage, runtime exposure, and accounting requirements.
  • Optimization: SkillZip retains typed-contract set-cover optimization, but SkillZip Pro changes candidate cost according to where each representation is placed in the bundle.This makes activation scope and path weight part of compression rather than implementation detail.
  • Optimization: Sparse shared fragments should remain within affected activation scopes because promoting them to the root adds (1−p)d_x expected tokens before reference overhead.Root promotion is suboptimal when deployment savings are smaller than (1−p)d_x/λ plus reference cost.

B. Conditional Capsules

SkillZip Pro uses guarded capsules to move infrequent conditional content out of always-loaded paths, while requiring explicit triggers and preserving contracts, routes, and deletion evidence.

  • Conditional Capsules: A capsule replaces an always-loaded guarded section with a dispatcher plus on-demand body when the resulting deployment cost decreases.The capsule costs the dispatcher on every load plus the trigger-weighted body cost, with deployment overhead.
  • Conditional Capsules: Capsule candidates must originate from an explicit heading or conditional clause, and their dispatchers preserve the original trigger and relative path.The system does not infer new guards.
  • Conditional Capsules: Shared modules and capsules target different costs: sharing removes repeated branch content, while capsules delay infrequent branches without moving shared content to the root.When both apply, shared content remains within the union of the relevant branches.
  • Evidence and Faithfulness: Every committed removal carries one witness: literal containment, deterministic coverage, or frozen-model entailment.The witness hierarchy makes witness strength, rather than deletion count, the safety boundary for compression.
  • Evidence and Faithfulness: The emitted directory is independently audited for graph closure, contract coverage, path safety, and locked-byte identity before publication.The audit checks the materialized output rather than relying only on in-memory coverage claims.

V. SkillZip Pro

SkillZip Pro extends single-document compression to progressively loaded skill directories, combining graph-wide compression with routing preservation and independent schedule and lifecycle choices.

  • SkillZip Pro: SkillZip Pro compiles a progressively loaded directory as a typed resource graph while leaving the agent harness unchanged.Its output remains an ordinary skill directory using existing readers, paths, and loading behavior.
  • The Two Pillars: The two pillars are cross-file compression and routing preservation: the first creates savings, while the second keeps rewritten branches reachable.Cross-file transformations remove root-supplied or repeated content and place guarded branches into on-demand capsules.
  • The Two Pillars: 1.000 routing fidelity is maintained by SkillZip Pro, whereas root-only and flat compressors drop to 0.000.Routing lines are locked, reference-bearing lines are preserved, and an independent audit rejects unreachable branches.
  • Modes and Lifecycles: Persistent compression rewrites the canonical bundle, while Transient compression keeps it byte-identical and builds a task-specific execution view.Transient views reduce runtime context but not disk usage and preserve shipped-entry usability by construction.
  • Modes and Lifecycles: One-Shot versus Continual controls when optimization runs, while Persistent versus Transient controls whether output replaces the canonical bundle.The two axes combine into four production modes with different storage, reuse, and task-specific execution properties.

F. Mode I: One-Shot Bundle Compression

One-Shot Bundle Compression reconstructs state from the complete source bundle, globally selects audited compression candidates, and falls back safely when the candidate is invalid or worse than the source.

  • One-Shot Bundle Compression: One-Shot mode reconstructs compressor state from the complete source bundle and searches globally.It is intended for initial migration, release packaging, invalid sidecars, and periodic global re-optimization.
  • One-Shot Bundle Compression: The one-shot pipeline resolves the safe graph, extracts typed contracts, estimates load weights, generates candidates, selects a constrained cover, materializes it, and audits it.Candidates include file-level covers, host entailments, activation-scoped sharing, and guarded capsules.
  • One-Shot Bundle Compression: A compressed candidate is published only when its materialized objective is no worse than the source and the disk audit succeeds.Otherwise, the algorithm returns a verbatim copy and records failure state.
  • Continual Updates: Continual compression applies valid patches verbatim, updates an affected closure, reuses digest-identical contracts, and refreshes only affected candidates.Patch units are classified as Absorb, Refine, Extend, or Refactor.
  • Continual Updates: A global repack is triggered by recoverable savings, bundle growth, workload drift, environment changes, or a patch limit.If continual compression fails, the patched uncompressed bundle is published rather than reverting to the previous compressed state.

I. Harness-Agnostic Deployability

SkillZip Pro is evaluated with an unmodified agent across diverse benchmarks and production-oriented settings, measuring cost, quality, loading, knowledge retention, and run overhead. The evaluation also tests routing, public-entry usability, portability, and continual updates.

  • Evaluation scope: SkillZip Pro is evaluated on BFCL-v4, LiveMathematicianBench, and SpreadsheetBench, which stress tool calling, mathematical reasoning, and spreadsheet editing respectively.The evolved skills are specialized by task class, making correct routing necessary.
  • Evaluation harness: The unmodified benchmark agent progressively loads catalog metadata, the selected root, and only linked auxiliary files opened during execution.A wrapper records opened paths and tokens without injecting, hiding, or reordering content.
  • Baselines: The study compares SkillZip Pro with no-skill, human-written, evolved, root-only, flat-concat, and evaluation-guided compression conditions.All compression methods receive the same evolved bundle unless otherwise stated, with savings measured against the uncompressed bundle.
  • Baseline fidelity: Flat-concat SkillZip retains only 0.2% of instruction lines in real evolved libraries, demonstrating that high compression savings can coincide with discarded knowledge and broken reachability.The paper marks this baseline as incomparable with fidelity-preserving methods because it destroys the links that make files reachable.
  • Task quality: SkillZip Pro is the only compressor that keeps quality across 102 pooled held-out tasks, while root-only, flat-concat, SkillReducer, and the expert baseline fall below the predefined margin.Its bootstrap interval against the uncompressed bundle stays above the five-point margin.
  • Metrics: Evaluation measures four cost layers, task-specific loading, broken or unreachable links, retained source instructions, compression resources, and end-to-end run cost.The design separates deployment, progressive loading, routing, knowledge retention, and computational overhead rather than relying on one ratio.

G. Main Result: Task Success and the Four Costs

SkillZip Pro is the only evaluated compressor that reduces all four cost layers while matching the uncompressed bundle on task success. Its savings come from removing repeated content and preserving reachable branches, rather than deleting required skill knowledge.

  • Four-cost comparison: SkillZip Pro is the only method that cuts all four cost layers while matching the uncompressed bundle on task success.The comparison warns that a single ratio can hide regressions in individual layers.
  • Task success: Across 102 pooled held-out tasks, SkillZip Pro has the highest pooled success of any compression method and is the only compressor that keeps quality.The 95% interval against the uncompressed bundle stays above the pre-fixed −0.05 margin.
  • Routing and loading: 0.755 required-resource recall and 0.193 irrelevant loading show loading behavior close to the uncompressed bundle.The larger reachable-file count reflects shared modules and conditional capsules connected to appropriate execution paths.
  • Routing and loading: 1.000 routing-pair preservation distinguishes SkillZip Pro from root-only and Flat-concat SkillZip, which preserve 0.000.The baselines retain branches on disk but remove the routing instructions needed to select them.
  • Retention versus deletion: SkillZip Pro removes the largest share of repeated text while keeping essentially the whole skill, whereas Flat-concat SkillZip retains under a quarter of instruction lines.Its non-recoverable removals are limited to content guaranteed by the environment contract and stored with signed witnesses.
  • Cumulative savings: 17.9% cumulative saving for one task remains 12.1% after 1,000 tasks, exceeding Expert Progressive at 11.1% and SkillReducer at 5.5%.Among methods satisfying the retention criterion, SkillZip Pro is cheapest at every tested workload size.

L. What Happens as the Library Keeps Growing

As self-evolving libraries grow, SkillZip Pro preserves complete skills and routing while keeping per-run cost stable. It trades some shipped-size reduction for execution-aware reuse rather than moving repeated text into the always-loaded root.

  • Growth and trade-offs: SkillZip Pro is the only approach that preserves the complete skill and routing table at every library size while keeping per-run cost flat.Expert Progressive removes more shipped bytes at the largest size, but its growing root-linked file reduces runtime savings.
  • Worked example: The worked example shows linked shared rules and preserved verification, routing, and branch-specific content, unlike Flat-concat’s removed branch.Flat-concat’s displayed ratio comes from deleting the file rather than preserving its executable content.
  • Library composition: 79–84% of the roughly 20,000-token library is repeated text across 17 files and 15 evolution rounds.The repeated material includes output rules, checklists, and accumulated past mistakes.
  • Real evolved libraries: 34.7% of shipped tokens are removed by SkillZip Pro versus 25.0% for the strongest faithful baseline, while preserving the skill and routing list.The baseline makes the always-loaded layer longer by 2.9%; SkillZip Pro improves every layer at full fidelity.
  • Real evolved libraries: 69% and 63% root gains for Root-only and SkillReducer correspond to routing scores of 0.000 and 0.125.These methods obtain root reductions by rewriting away routing, so their larger apparent reductions do not satisfy full retention.
  • Fallback behavior: On one library, SkillZip Pro declines compression and republishes the source byte for byte when the candidate does not improve the objective.Continual mode later reaches 49.9% compression by repacking at a more favorable point in the stream.

N. Continual Compression Over a Long Evolution Stream

Continual compression reduces update work while recovering redundancy across an evolving skill library. Starting compression early matters because repetition accumulates each round, and periodic repacking is needed to consolidate cross-round duplicates.

  • Continual compression: 48.1% of shipped tokens and 28.2% of per-run tokens are removed with Continual repacking using 3.31 compressor calls per round.Rebuilding after every update requires 10 calls per round and takes 0.234 seconds versus 0.068 seconds for Continual mode.
  • Repacking: Periodic repacking recovers cross-round redundancy, whereas no repacking reduces shipped-token saving to 2.7% and per-run saving to 0.8%.Root-only Zip-on-Write uses one call and 389 processed bytes per round but reduces the shipped library by only 2.4%.
  • Why savings compound: 55% ± 3% of content added each round overlaps with existing text across the evaluated libraries.The overlap remains relatively stable across rounds and models, often repeating formats, checklists, and accumulated rules.
  • Why savings compound: SkillZip Pro’s removable share rises from 29% at round 2 to 53% at round 15 as redundancy accumulates.The results report increasing rather than diminishing returns with library age.
  • Why savings compound: The top two of seven shared modules account for 47% of reuse, and the top three account for 64%.Reuse is concentrated in a small number of universal rules such as answer formatting and exact-value handling.
  • Cost and execution: SkillZip Pro takes 0.21 seconds per compression versus 0.11 seconds for Root-only while using 0.02 GB peak memory and no rollouts.The extra time covers graph resolution, cross-file sharing, conditional capsules, and auditing.
  • Cross-model execution: With qwen3.7-max and qwen3.6-plus, task success rises from 0.541 to 0.619 and from 0.608 to 0.656, respectively.Required-resource recall and irrelevant loading remain close to the uncompressed bundle for those models; results are less consistent for kimik2.6.

S. Which Part Does the Work?

The ablations show that scoped cross-file compression supplies most savings, while routing safeguards make those savings deployable across lifecycle modes and public entries.

  • Ablations: Scoped sharing supplies most deployment reduction, while capsules trade lower storage for higher per-run cost.Removing scoped sharing loses most reduction; removing capsules increases per-run cost despite lower storage.
  • Ablations: −0.166: global sharing pushes J below the source and leaves one file unreachable.The failure comes from ignoring branch scope and moving content into the root.
  • Sensitivity: λ=0 to 1: transformations and costs remain identical across the swept storage-weight range.The default λ=0.05 is not tuned to the results.
  • Continual mode: Continual repacking matches full rebuilds with zero drift, about one third of model calls per patch, and fewer rewritten bytes.Between repacks, continual mode reads only the changed file; without repacking, repetition accumulates.
  • Continual mode: A patch-count trigger reaches the same bounded drift at a quarter of the rebuild rate, while rebuilding every patch costs nearly ten times more calls.On this stream, saving and growth triggers do not fire because drift stays below their thresholds.
  • Multi-entry preservation: 0.500 discoverability: removing the multi-entry audit lets persistent compression rename a public subskill, whereas audited and transient modes remain at 1.000.The live rollout likewise shows zero discoverability and standalone success without the audit.
  • Lifecycle choice: Persistent load stays below transient load for every direct-call count; changing bundles favor cached continual transient above roughly one edit per ten runs.A global repack costs 273 ms versus 183 ms for a local transient rebuild.

V. An Example in Industrial Compression Deployment

The production evaluation shows that witnessed, interface-preserving compression reduces bundle and runtime-token costs without measurable decision-quality loss, whereas unprotected compression causes large false-positive-driven accuracy drops. Results also compare lifecycle costs, validate transient views, and show that stronger witnesses enable greater safe compression.

  • Production results: 71.4–75.8% unprotected compression reduced accuracy by 18–26 points, primarily through additional false positives.False positives rose from 10 to 29–35 while false negatives remained between 1 and 3.
  • Lifecycle comparison: Transient local rebuilding is cheaper than persistent global repacking when edit rate U exceeds 0.1, while they tie for a stable bundle.The comparison is based on deterministic sweeps summarized in the lifecycle and transient-view evaluations.
  • Safeguards: 32.7% deployment saving was obtained with restricted entailment witnesses, and restoring interface contiguity reduced saving only slightly to 32.2%.The restoration pass reconstructed one contiguous interface span containing worked examples and the label whitelist.
  • Runtime behavior: Production measurements showed 6%–11% per-run savings, exceeding the loading-weight model’s approximately 3% estimate.A shorter root also changed reading and repeated-reasoning behavior, which the static model does not represent.
  • Production results: 38.1% deployment saving and 10.4% pooled runtime-token saving were achieved with witnessed compression, while accuracy remained within observed uncompressed variation.The final configuration pooled two sessions over n=200 audits.
  • Safeguards: Stronger witnesses increased safe removal from 13.8% to 32.7%, while extending witnessed reasoning to the repeatedly loaded root produced the final 38.1% saving.The progression separates literal or coverage witnesses, restricted entailment, and root-level witnessing.

Appendix A Implementation Details

Appendix A specifies how SkillZip Pro discovers bundle resources, extracts contracts, rewrites content, preserves routing, and handles language-specific protection and interface integrity. It also defines deterministic traversal, locking, sharing, capsule, and publication constraints.

  • Bundle layout: The compiler keeps the authoritative source immutable and stores intermediate and persistent state outside the published runtime bundle.The published layout preserves the entry path while generated capsules and shared modules are placed separately.
  • Discovery and classification: Deterministic traversal normalizes paths to UTF-8 NFC, sorts them bytewise, avoids directory symlinks, and locks code, notebooks, structured data, images, archives, and unknown binaries.Text rewriting is additionally limited by a default 1 MiB per-file guard.
  • Discovery and classification: The resolver follows only host-supported local references, including Markdown links, explicit paths, front-matter fields, and imperative loading clauses.External links remain opaque, while ambiguous guards may be preserved but cannot justify capsule creation or path-specific sharing.
  • Protection mechanisms: Chinese production content exposed English-only requirement markers: only 7 of 264 units were classified as required until script-aware signal sets were introduced.The implementation also locks exemption-bearing boundary units against wording compression and entailment removal.
  • Protection mechanisms: Interface restoration re-inserts each output-contract section as one complete source span and audits that it appears once without fragmentation.The pass removes scattered normalized lines and fixed-template rendering scaffolding.
  • Protection mechanisms: W3 checks whether a candidate reference segment’s decision-relevant content is fully expressed in the root, using deterministic prompts and explicit safeguards for contracts, boundaries, and mutual witnessing.Concrete case facts need not reappear when the rule they demonstrate is preserved.

H. Disk-Level Audit

Appendix H defines the audit and publication controls that make compression verifiable and recoverable. The pipeline re-extracts emitted text, rejects unresolved strict inputs, and uses transactional fallback behavior when optimization or patching fails.

  • Audit: The audit rebuilds both graphs in a new process, rehashes every node, and checks roots, internal targets, contract mappings, and generated artifacts.It is isolated from optimizer objects by accepting only the source path, candidate path, and manifest.
  • Failure handling: One-shot failures publish a verbatim source copy, while continual failures after successful patching publish the verbatim patched bundle; only failed patch transactions retain the previous publication.Failure manifests or rebuilt clean state preserve recoverability.
  • Continual operation: Continual mode invalidates changed nodes, reference ancestors and descendants, affected shared modules and capsules, and changed environment witnesses before rerunning extraction and candidate generation.It requires prior state and an incoming patch, but mismatched state falls back to verbatim patching followed by one-shot compression.
  • Continual operation: Repacking is triggered by configured saving, growth, workload-drift, environment-digest, or patch-count thresholds, with trigger values and causes logged in state.Patch units are classified as Absorb, Refine, Extend, or Refactor.
  • Audit: Unresolved local references prevent strict compression, ensuring every audited local dependency can be validated.The graph format records unresolved edges explicitly.
  • Audit: Most audit checks are deterministic; a model is used only for semantic coverage pairs not discharged by exact normalization.The rewriter itself does not calculate coverage.

G. Transformation Manifest

The transformation manifest records provenance, graph structure, transformations, costs, and audit outcomes for reproducible bundle compression. The protocol fixes evaluation, instrumentation, fallback, loading, and statistical-comparison rules before execution.

  • Manifest contents: The manifest stores source and output digests, model metadata, graph counts, transformations, cost records, and audit status.It is used for provenance, regression testing, and exact reconstruction rather than required at agent runtime.
  • Evaluation controls: The evaluation freezes benchmark inputs, bundle construction, contracts, compressor settings, and held-out execution order to prevent leakage.All methods run on identical source digests, and outputs are audited before held-out execution.
  • Evaluation controls: Each benchmark varies common, rare, verification, and recovery paths under observed, uniform, and 80%-common traffic distributions.These scenarios separate structural effects from gains tied to a single traffic assumption.
  • Resource labeling: Required resources are identified independently by annotators, with disagreements adjudicated and agreement reported using Cohen’s κ and raw agreement.A resource is required when omitting it removes a unique normative unit; invoked scripts count even when their code is not injected.
  • Cost accounting: Cost accounting records catalog, activation, deployment, and path costs from published files and actual load events, including duplicate loads.Mean and P95 costs are paired over identical tasks, while runtime-package counts may exclude the audit manifest.
  • Loading metrics: Required-file recall is one for empty requirement sets, irrelevant-load rate is zero for empty load sets, and active capsules alone count as relevant.Generated shared modules inherit the union of annotations from the source units they cover.
  • Analysis: Quality is macro-averaged across benchmark categories and benchmarks, while compression ratios use summed token costs before averaging and also report median bundle reduction.SkillZip Pro is compared with Evolved Bundle for quality and Root-only SkillZip for mean-path reduction.
  • Analysis: Non-inferiority requires the lower bound of the paired 95% interval to exceed −0.01 before compression superiority is tested.Paired binary outcomes use McNemar’s test, multi-level scores use paired bootstrap or permutation tests, and Holm correction is applied within RQ2–RQ7.

J. Zip-on-Write Replay

The replay evaluates compression as identical evolution patches accumulate, measuring both continual-update behavior and the path-dependent costs of progressively loaded bundles. It also tests how sharing, capsules, traffic assumptions, and semantic limitations affect the resulting trade-offs.

  • Replay protocol: Every evolution patch is applied in identical order to the same authored checkpoint across append-only, One-Shot, root-only Zip-on-Write, and Continual schedules.Checkpoints are created after every patch, alongside measurements of changed contracts and invalidation closure.
  • Replay protocol: Growth plots report absolute tokens, objective regret, cumulative compression cost, closure fraction, and repack triggers across patch index.Rejected compressions must fall back to the verbatim patched snapshot, verified by digest equality.
  • Bundle tracks: The grown track replays evolution patches into named branches that duplicate output rules, verification checklists, and accumulated pitfalls, plus guarded edge cases.Main cost tables use this grown track, while later sections use real libraries.
  • Held-out evaluation: 102 held-out tasks span Math 33, BFCL 21, and SpreadsheetBench 48, with identical tasks per method enabling paired tests.SpreadsheetBench is sampled more densely because strict all-test-case verdicts make small-sample flips unstable; BFCL uses its offline search tool.
  • Configuration: The compressor uses structural extraction and audit without model calls, locks navigation and literal blocks, and applies fixed capsule, factoring, and storage thresholds.All methods receive identical source bundles and environment contracts.
  • Continual replay: Continual replay appends rounds in evolution order, repacks every fourth round after activation, and counts model calls by changed textual node or rebuilt textual node.Drift is measured against rebuilding the whole library at the same round.
  • Continual replay: Start-time ablations switch compression on at rounds 1, 4, 7, 10, or 13, or never, while total cost sums what the evolving library costs at each round.This measures the cost actually paid during evolution rather than only the final bundle size.
  • Compounding analysis: The compounding analysis measures one-shot size reduction, repeated share, and reuse concentration across prefixes of two libraries that pass the never-inflate check.A third library is excluded when fallback would make its ratio reflect the safety guard rather than redundancy.
Loading 2608.30785v1…