PaperlayerView exact revision on arXiv

Source-linked AI summary

SkillZip: Contract-Preserving Graph Compression for Scalable Agent Skill Libraries

Xingyu Tan, Xiaoyang Wang, Qing Liu, Xiwei Xu, Xin Yuan, Liming Zhu, Wenjie Zhang

arXiv:2608.05604v1cs.CLcs.AI

TL;DR

Skill libraries need to expose the smallest sufficient executable context while preserving procedural contracts, but existing systems operate mainly on whole skill packages. SkillZip compresses recurring section-level graph motifs into reversible, contract-preserving macros and consistently outperforms strong baselines across technical and embodied benchmarks, with gains of up to 12.2 points.

  • Problem

    Existing systems retrieve whole skill packages instead of the smallest execution-complete subsets, limiting reuse below the skill level under tight context budgets.

  • Method

    SkillZip represents skills as section-level procedural graphs and rewrites recurring contract-valid motifs into reversible macros while preserving dependencies, verifier reachability, and source expansion.

  • Results

    SkillZip consistently achieves the best end-to-end performance across technical and embodied benchmarks, improving episode success rate by 12.2 points over SkillDAG.

  • Takeaways & Limitations

    SkillZip improves skill-library scalability while maintaining executable structure for efficient and reliable skill reuse in long-horizon agent tasks.

  • Takeaways & Limitations

    The compression guarantee recovers recorded interfaces, dependencies, verifier paths, and provenance but does not establish unrecorded behavioral equivalence or verifier correctness.

Abstract

from arXiv · show

Large Language Models (LLMs) increasingly act as agents whose procedural knowledge is stored in reusable skill packages and loaded at inference time. As skill libraries grow, a central challenge is to expose the smallest sufficient executable context under a limited context budget. Existing systems struggle to reuse routines below the whole-skill level, preserve procedural contracts during compression, keep compressed routines executable and expandable, and update the compressed library as skills evolve. These challenges reveal a unit mismatch: skills are retrieved as packages, compressed as text, and converted into execution graphs only after retrieval, whereas reliable reuse requires a contract-bearing procedural unit. We propose SkillZip, an execution-aware procedural abstraction framework that performs contract-preserving compression over section-level graphs. SkillZip rewrites recurring contract-valid motifs into reversible ported macros while preserving boundary signatures, dependency closure, verifier reachability, and source-level expansion. At inference time, it hydrates a compact, dependency-closed context and expands macros only when required. ReZip further integrates new skills and revises risky macros using execution evidence. Comprehensive experiments1 on technical and embodied agent benchmarks show SkillZip consistently outperforms the strongest baseline by up to 12.2 points, while achieving a 3.46x compression ratio with 99.2% dependency preservation and 98.7% verifier reachability. Scaling analyses further confirm robust retrieval across skill libraries ranging from 200 to 100K skills.

1 INTRODUCTION

SkillZip addresses the mismatch between whole-package retrieval, text compression, and post-retrieval graph construction by treating contract-bearing section subgraphs as the shared unit of procedural reuse. It provides contract-preserving graph compression, budgeted context hydration, and execution-aware incremental maintenance for scalable agent skill libraries.

  • Motivation: Skill libraries provide editable external procedural memory for LLM agents, whose task success often depends on procedures for operations and verification rather than factual knowledge.Skill packages store instructions, resources, and execution and verification rules, allowing procedures to change without retraining.
  • Problem: The central problem is retrieving the smallest sufficient executable context under a tight budget as skill libraries grow and overlapping packages increase.Providers must avoid incomplete or redundant context while selecting task-relevant procedures.
  • Problem: Existing whole-skill retrieval misses execution-complete section subsets whose typed dependencies and verifier hooks define the skill’s procedural contract.The introduction argues for retrieving shared contract-compatible procedures once and adding only task-specific sections.
  • Contribution: SkillZip unifies retrieval, compression, and execution around source-grounded, contract-bearing section-level graphs, rewriting recurring procedural motifs into ported macros while preserving contracts, dependencies, verifiers, and provenance.The framework changes the representation unit from whole skill packages to section-level units connected by procedural dependencies.
  • Contribution: SkillZip hydrates compact dependency-closed subgraphs and expands macros only when needed, while ReZip-style maintenance matches new skills, promotes residual motifs, and revises risky macros using execution evidence.These mechanisms keep compressed procedures executable, expandable, and aligned with evolving skills.

2 RELATED WORK

Prior work develops agent skills and procedural memory for reusable executable knowledge, while graph mining and summarization methods compress repeated structure. However, agent skill libraries additionally require preservation of execution interfaces, dependency closure, verifier reachability, and source provenance.

  • Agent skills and procedural memory: Agent skills and procedural memory support reusable executable knowledge beyond individual tool calls, including accumulated programs, distilled experience, and workflows retrieved from prior trajectories [38] [45] [46] [57].Tool-augmented agents combine LLM reasoning with external actions through prompting, learned tool invocation, and large API collections [18] [34] [35] [53].
  • Graph mining and summarization: Graph mining and summarization offer methods for discovering and compressing repeated structure, including frequent-subgraph mining, MDL-based summaries, grammar-based replacement, and incremental maintenance [5] [12] [13] [14] [15] [26].
  • Limitations of existing methods: Agent skill libraries require compression that preserves execution interfaces, dependency closure, verifier reachability, and source provenance.

3 PRELIMINARIES

SkillZip models agent skill libraries as executable procedural graphs at section-level granularity rather than retrieving only whole packages. Its typed nodes, dependencies, ports, contracts, provenance, and reversible macros define the representation and validity conditions for compression.

  • 3 PRELIMINARIES: A skill library retains package-level retrieval and provenance while representing each source occurrence as a finer-grained procedural section node.Section nodes carry execution roles, content, typed inputs and outputs, resources, guards or verifiers, and pointers to original skill sources.
  • 3 PRELIMINARIES: Nine operational roles characterize procedural function, while compatible occurrences may link to canonical prototypes without losing skill membership, multiplicity, or source pointers.The roles are Intent, Trigger, Input, Precondition, Operation, Resource, Failure, Verifier, and Output.
  • 3 PRELIMINARIES: The procedural skill graph combines occurrence nodes and prototypes with typed dependency, skill-membership, resource, and equivalence edges; ports expose external subgraph contracts.Dependency relations include Requires, Binds, UsesResource, Verifies, and Repairs, supporting multi-input and multi-output procedures.
  • 3 PRELIMINARIES: A procedural contract jointly specifies interface, execution, and verification, while source provenance enables reversible expansion.Interface covers typed I/O and resource bindings; execution covers preconditions, dependencies, guards, effects, and failures; verification covers success conditions and verifier hooks.
  • 3 PRELIMINARIES: A valid macro compresses a connected section subgraph into ported inputs and outputs while retaining its contract and source-backed expansion.Validity also requires every state-changing operation or macro to retain a reachable verifier across compatible occurrences.

4 METHOD

SkillZip preserves executable procedural contracts by converting skill packages into source-grounded section graphs, compressing contract-valid motifs into reversible macros, and hydrating dependency-closed contexts under a token budget. ReZip extends this pipeline by promoting new abstractions only after repeated contract-compatible execution evidence.

  • Sec2Graph: Sec2Graph converts heterogeneous skill packages into source-grounded procedural subgraphs with typed sections, explicit contracts, dependencies, guards, verifiers, roots, terminals, and cross-skill prototype links.Each section records typed inputs and outputs, resources, guards, verifier conditions, and source provenance, while skill membership and endpoint nodes structure execution.
  • MotifZip: MotifZip replaces recurring typed subgraphs only when stable interfaces, closed dependencies, and preserved execution-to-verifier relationships support a reversible macro contract.Macros retain typed ports, occurrence-specific mappings, executable contracts, and source-grounded expansion; selection also rewards frequency and cross-skill reuse while penalizing boundary loss and risk.
  • Correctness and scope: MotifZip’s lifting guarantee recovers recorded interfaces, dependencies, verifier paths, and source provenance, but does not establish unrecorded behavioral equivalence or verifier correctness.The guarantee is structural and depends on non-conflicting accepted motif occurrences whose internal nodes are rewritten and expanded compositionally.
  • PathHydrate: PathHydrate maps task anchors to section seeds and compiles executable context subject to anchor coverage, dependency closure, verifier reachability, and token budget constraints.It combines skill-level and node-level rankings to balance fine-grained precision with package coherence before selecting sections or macros for hydration.
  • ReZip: ReZip updates the compressed library by reusing established macros immediately and promoting new abstractions only after repeated cross-skill, contract-compatible evidence passes the same validity checks.Promotion depends on minimum distinct-source support, compression gain, and port, dependency-closure, and verifier validation.

5 EXPERIMENTS

Across SkillsBench and ALFWorld, SkillZip achieves the best end-to-end performance across both evaluated backbone LLMs while preserving executable structure under compression. Ablations show that section-level representations and adaptive, globally rescued hydration materially support retrieval, reward, and token efficiency.

  • RQ1: End-to-end performance: SkillZip achieves the best end-to-end performance across SkillsBench and ALFWorld and both evaluated backbone LLMs, reaching 96.4% success on ALFWorld with gpt-5.2-codex.With MiniMax-M2.7, SkillZip obtains a task reward of 33.
  • RQ3: Executable structure: 1.43× compression from exact-text deduplication remains limited because it merges only surface-identical sections.The comparison is reported for SkillsBench compression and structural fidelity.
  • RQ3: Executable structure: Text compression reaches the same rounded compression ratio as SkillZip but reduces DPR to 65.0, VR to 60.0, and reward to 25.5.It also causes 45.0% of queries to require recovery from original sections, showing that shorter context alone does not guarantee executability.
  • RQ4: Component ablation: Replacing section-level nodes with skill-level nodes causes the largest ablation drop: Ret@1 falls 6.9 points, reward falls 5.4 points, and rendered context rises 59.9%.Section-level procedures are the input to later stages.
  • RQ4: Component ablation: Removing global section rescue reduces Ret@1 to 68.2 and reward to 30.4, while disabling adaptive hydration preserves DPR and VR but uses 33.3% more tokens.PathHydrate renders 1,941 tokens per task, 72.1% fewer than top-5 whole-skill loading.

6 CONCLUSION … A.5 ReZip

SkillZip compresses agent skills as contract-preserving section-level procedural graphs, hydrates compact task-specific contexts, and incrementally updates the compressed library. The paper reports improved end-task performance and source-skill retrieval over strong baselines on SkillsBench and ALFWorld, while the appendix details the algorithms and evaluation scope.

  • 6 CONCLUSION: SkillZip outperforms strong retrieval and graph-based baselines on end-task performance and source-skill retrieval across SkillsBench and ALFWorld.The conclusion summarizes the framework’s overall empirical advantage on both task outcomes and recovery of source skills.
  • APPENDIX OUTLINE: The appendix outlines evaluations of compression fidelity, retrieval scalability, procedural overlap, hydration quality, lifecycle cost, ReZip maintenance, reliability, failures, and case studies.The listed research questions cover compression, retrieval, domain applicability, context budgets, system cost, evolving libraries, repeated runs, backbone generalization, failure origins, and three case studies.
  • A.1 SkillZip Workflow: SkillZip’s workflow builds section graphs, compresses repeated motifs, hydrates budgeted executable contexts, and maintains the library as new skills or execution traces arrive.Algorithm 1 organizes these operations into Sec2Graph, MotifZip, PathHydrate, and ReZip stages.
  • A.2 Sec2Graph: Sec2Graph converts each skill package into a typed procedural graph with explicit roles, input/output signatures, resources, guards, verifiers, and source pointers.It adds ordering, input-binding, requirement, verifier, and repair edges; verifier links are conservative and require reachable evidence.
  • A.3 MotifZip: MotifZip accepts repeated motifs only when boundary signatures, dependencies, and verifier reachability remain valid, creating reversible macros while leaving invalid occurrences explicit.Signature instability, missing dependencies, weak verifier support, contradictory bindings, and nonpositive compression gain block macro creation.
  • A.4 PathHydrate: PathHydrate constructs connected task-specific contexts by anchoring queries, fusing skill evidence, repairing scaffolds and closures, enforcing the budget, and choosing macro rendering levels.Macros may be rendered as a name, contract, outline, or full source, while filling stops once task anchors, dependencies, and verifier reachability are covered.
  • A.5 ReZip: ReZip assimilates new skills through existing macros and revises risky macros when execution traces show repeated expansion needs or downstream failures.Revision applies the same port, dependency-closure, and verifier tests, increases hydration detail before splitting or retiring a macro, and retains source expansion.
  • A.5 ReZip: The compressed library therefore preserves the same lifting invariant during incremental maintenance as during offline compression.ValidContract reuses MotifZip’s port, dependency-closure, and verifier checks for updated macros.

A.6 Evaluation-facing Metrics · B ADDITIONAL EXPERIMENTS

Algorithm 6 converts framework logs into evaluation quantities that test whether SkillZip preserves structural conditions, not merely retrieval performance. It evaluates paired compressed and uncompressed executions using task, structural, and downstream-execution metrics.

  • A.6 Evaluation-facing Metrics: Algorithm 6 converts framework-level logs into empirical evaluation quantities without adding a retrieval mechanism.It checks whether the compressed representation preserves SkillZip’s claimed structural conditions.
  • A.6 Evaluation-facing Metrics: The evaluation takes queries, raw and compressed graphs, macro dictionary, executor, profile, and budget, then returns per-query logs and an aggregate report.
  • A.6 Evaluation-facing Metrics: For each query, SkillZip hydrates a budgeted compressed context, renders the uncompressed context, and executes both under the evaluation executor.
  • A.6 Evaluation-facing Metrics: The evaluation checks dependency preservation, verifier reachability, macro expansion requirements, and full-source fallback before aggregating task and structural metrics.
  • A.6 Evaluation-facing Metrics: The aggregate report covers task success, token reduction, dependency preservation, verifier reachability, macro expansion, full-source fallback, and downstream execution inflation.These structural metrics test whether compact contexts remain executable rather than merely shorter.
  • A.6 Evaluation-facing Metrics: Downstream inflation compares paired compressed and uncompressed executions under the same executor seed using J(τ) = n_repair(τ) + n_tool(τ) + 2n_vfail(τ).The reported percentage is 100 max{0, J(τ_q) − J(τ_full q)}/max{1, J(τ_full q)}.
  • A.6 Evaluation-facing Metrics: Macro expansion and full-source fallback are aggregated as query-level indicators, with full-source fallback treated as a strict subset of expansion.

B.1 Compression Fidelity and Contract Robustness

SkillZip’s compression audit jointly evaluates storage reduction and downstream recovery on a 1K-skill library, showing that contract validation preserves low recovery overhead. Removing validation saves only 0.5 MB but sharply increases fallback and downstream inflation.

  • Compression Fidelity: The audit measures active storage, retained source packages, fallback expansion, and downstream inflation on the same 1K-skill library.Active storage counts the represented graph, while retained source packages support reversible expansion and downstream inflation is measured against raw-graph execution.
  • Contract Robustness: Fallback rises from 7.2% to 24.7% and downstream inflation from 2.7% to 23.4% when contract checks are removed, despite saving only 0.5 MB.This indicates that contract validation prevents storage gains from being repaid during execution.
  • Compression Fidelity: Table 4 evaluates active-storage compression and downstream recovery while retaining source data for reversible expansion.The table covers the 1K-skill SkillsBench library and defines downstream inflation relative to raw-graph execution.
  • Contract Robustness: Figure 3 reports field-level F1 and exact match for contract extraction on an annotated subset.Dashed lines denote macro averages.
  • Contract Robustness: Table 5 tests robustness under synthetic contract corruption by removing or replacing contract fields and measuring expansion and fallback rates.Fallback requires original-source restoration.

B.2 Retrieval Scalability and Ambiguity · B.3 Procedural Overlap and Domain Applicability

SkillZip scales retrieval more robustly than SkillDAG as libraries grow, while procedural overlap increases compression without materially reducing execution fidelity. Its section-level compression also improves reported task metrics across the evaluated procedural domains.

  • B.2 Retrieval Scalability and Ambiguity: SkillZip Ret@1 drops 13.2 points, from 78.3 to 65.1, versus SkillDAG’s 30.3-point drop, from 72.1 to 41.8, as libraries grow to 100K skills.The performance gap widens from 6.2 points at 200 skills to 23.3 points at 100K skills.
  • B.2 Retrieval Scalability and Ambiguity: SkillZip’s similar-skill confusion rate rises from 4.2% to 12.4%, while SkillDAG’s increases from 8.5% to 48.2% as the library expands.The results indicate that section-level matching better distinguishes concrete operations, dependencies, and constraints amid overlapping skill descriptions.
  • B.2 Retrieval Scalability and Ambiguity: SkillZip’s compression ratio increases from 2.31× to 4.29×, while online retrieval and hydration latency rises from 18.4 ms to 248.3 ms per query.Latency remains below 250 ms even at 100K skills.
  • B.3 Procedural Overlap and Domain Applicability: Higher procedural overlap raises mean macro support from 2.3 to 9.7 occurrences and compression ratio from 1.18× to 4.63×.The controlled variants hold library size and query distribution fixed while increasing recurring contract-compatible motifs.
  • B.3 Procedural Overlap and Domain Applicability: Across overlap levels, DPR stays above 99.1, VR stays above 98.8, and reward changes by only 1.1 points.SkillZip therefore adapts compression to reusable structure while maintaining stable execution fidelity.
  • B.3 Procedural Overlap and Domain Applicability: SkillZip improves the reported task metric over SkillDAG in every evaluated procedural domain with a matched baseline.The evaluation partitions 1,000 SkillsBench skills into four named domains and a miscellaneous category, and separately tests ALFWorld.
  • B.3 Procedural Overlap and Domain Applicability: Across domains, SkillZip’s reward gains over SkillDAG range from 4.8 to 6.7 points where matched baselines are available.ALFWorld is evaluated as an independently structured embodied skill library, while a dash denotes unavailable category-level baselines.

B.4 Hydration Quality and Context Compactness

PathHydrate reaches most of its task reward with a compact hydrated context rather than by filling the executor budget. Under the default 3,000-token allowance, it renders substantially less context than whole-skill retrieval while preserving task-critical dependencies and verifier reachability.

  • Hydration Quality: 33.3 reward at 3,000 tokens, versus 22.4 at 1,000 and only 0.8 additional points at 5,000, shows diminishing returns from expanding hydrated context.The curve rises sharply through 2,000 tokens as execution-critical dependencies and verifier conditions are recovered, then flattens.
  • Context Compactness: 1,941 rendered tokens per task on average (median 1,947) under the 3,000-token budget demonstrates compact context delivery versus full rendering of retrieved skill packages.The comparison uses the same queries’ top-K retrieved packages and the default setting used in Tables 2 and 3.
  • Context Compactness: 51.7% of tasks use fewer than 2,000 tokens and 74.7% fewer than 2,500, while 26.4% fall in the modal 1,000–1,500-token interval.The distribution indicates that compactness is not an averaging artifact and that hydration usually stops before the allowance is exhausted.
  • Context Compactness: PathHydrate treats the 3,000-token budget as a selection allowance, terminating after task anchors are covered, dependencies are closed, and a verifier remains reachable.This stopping rule explains why delivered contexts remain below the maximum budget rather than being greedily filled.

B.5 System Cost across the Skill Lifecycle · B.6 Streaming ReZip Maintenance

Across the skill lifecycle, SkillZip combines cacheable offline construction and lightweight task-time retrieval with lower-cost, more successful end-to-end execution. Streaming ReZip evaluates maintenance under arriving skills and contract drift using only evidence available at each update.

  • B.5 System Cost across the Skill Lifecycle: Offline structural construction remains cacheable and reaches 100K skills with 4.77M cached section nodes in 178 s.The measured local stage takes 274 ms for 100 skills, 1.44 s for 1K skills, and 16.1 s for 10K skills; LLM inference is excluded.
  • B.5 System Cost across the Skill Lifecycle: SkillZip’s modest extra graph operations at retrieval are offset by a smaller executable context that reduces downstream repeated context and interaction costs.The downstream effects include fewer irrelevant branches, missing dependencies, repair attempts, and tool calls across multi-turn execution.
  • B.5 System Cost across the Skill Lifecycle: Reward rises from 27.3 to 33.3 over SkillDAG while total prompt processing falls 47.0%, from 2.78M to 1.47M tokens.Completion tokens also decrease from 31,963 to 20,601, a 35.5% reduction.
  • B.5 System Cost across the Skill Lifecycle: Across the lifecycle, offline construction is one-time and cacheable, task-time retrieval remains lightweight, and end-to-end execution becomes cheaper and more successful.The conclusion concerns both the tokens shown to the executor and the downstream interaction required to use the library correctly.
  • B.6 Streaming ReZip Maintenance: ReZip evaluates streaming maintenance by adding the remaining 50% of a 1K-skill pool in ten fixed, non-overlapping batches and injecting contract drift after the fifth batch.The drift targets a fixed, domain-stratified subset of active macros under a tightened source-grounded verifier condition.
  • B.6 Streaming ReZip Maintenance: At each update, ReZip uses only cached section records and observed execution traces, excluding one-time LLM extraction from update cost.It is compared with a fixed compressed graph, append-only updates without recompression, and periodic full-library recompression.
  • B.6 Streaming ReZip Maintenance: After ten arriving-skill batches, the static graph reaches 28.7 reward and 91.2 VR as old macros degrade under library evolution.Table 12 reports cumulative update cost normalized by periodic full recompression and drift-recovery delay in batches.

B.7 Reliability across Runs and Backbones

SkillZip’s gains remain statistically stable across repeated agent runs and generalize across six LLM backbones and two benchmarks. These results indicate that executable section retrieval, rather than executor identity or strength alone, drives the benefit.

  • Reliability across repeated runs: Across five matched runs, SkillZip preserves the main-results ordering in all four settings, with paired gains of 2.8 to 12.2 points and every 95% confidence interval excluding zero.Table 13 reports mean±standard deviation over five matched runs and paired bootstrap confidence intervals over task or episode outcomes.
  • Reliability across repeated runs: Even in the conservative ALFWorld–gpt-5.2-codex setting, SkillZip raises success from 93.6 to 96.4, a paired gain of 2.8 points with p= .031.The result supports persistence beyond a single trajectory when the baseline already has high success and little remaining headroom.
  • Generalization across LLM backbones: SkillZip outperforms Vector Skills in all twelve benchmark–backbone settings, improving SkillsBench reward by 19.9 to 26.2 points and achieving 2.0×–3.2× relative gains.The largest relative gain occurs with MiniMax-M2.7, increasing reward from 10.4 to 33.3.
  • Generalization across LLM backbones: On SkillsBench, SkillZip improves reward for every backbone, including Claude Sonnet 4.5 from 26.2 to 52.4, Gemini 3 Pro from 19.3 to 44.4, and gpt-5.2-codex from 21.5 to 43.0.The gains remain large for stronger backbones, indicating that executor strength alone does not eliminate the need for executable section context.
  • Generalization across LLM backbones: On ALFWorld, SkillZip improves every backbone, with MiniMax-M2.7 rising from 50.7 to 79.3 and stronger models reaching 97.9–99.1 success.The cited stronger-model results are 97.9 for Kimi K2.5, 99.0 for Claude Sonnet 4.5, 99.1 for Gemini 3 Pro, and 96.4 for gpt-5.2-codex.

B.8 Failure Analysis

SkillZip attributes remaining failures to their earliest blocking stage, separating procedural-context errors from downstream execution errors. Most failures arise within SkillZip-controlled stages, especially retrieval ambiguity, while execution remains the largest single category.

  • Failure Attribution: Failures are assigned to the earliest blocking stage, preventing upstream retrieval misses from being counted again as later contract, hydration, or execution failures.This decomposition distinguishes procedural-context errors from downstream execution errors under the default 1K-skill SkillsBench setting.
  • Failure Attribution: 58% of remaining failures occur in SkillZip-controlled stages: retrieval contributes 26%, contract extraction 18%, and hydration 14%.Retrieval errors mainly involve ambiguous anchors or omitted candidate sections; contract errors cluster around implicit preconditions, resource requirements, and underspecified verifier hooks.
  • Failure Attribution: 33% of failures arise during agent execution, while infrastructure errors account for 9% after context retrieval and hydration.Execution failures include invalid action ordering, tool misuse, and failure to recover after verifier rejection; infrastructure failures include environment, timeout, and tool-interface errors.

C CASE STUDIES

The case studies show SkillZip resolving retrieval ambiguity, preserving executable contracts during compression, and maintaining abstractions as execution evidence reveals risk. Across these workflows, section-level retrieval reduces irrelevant context, contract checks constrain reusable macros, and ReZip adapts compression over time.

  • Case study 1: Resolving skill-level ambiguity: Section-level retrieval maps the query to operation and verifier anchors, hydrates dependency-closed context, and excludes unrelated continuations, reducing ambiguity and context size.For header normalization, SkillZip retains the reusable ingest macro and row-count verifier while excluding competing routines.
  • Case study 2: Preserving contracts during compression: MotifZip compresses only contract-compatible CSV routines, preserving typed ports, dependencies, source maps, and verifier links while rejecting the workbook occurrence.Pivot aggregation remains outside the macro and reconnects through its output port because the workbook routine would alter formula preservation.
  • Case study 3: Maintaining compression under library evolution: ReZip promotes repeatedly compatible residuals without full recompression and demotes or splits risky macros after repeated expansion, repair, or verifier failure.The library remains compact where reuse is stable while increasing hydration or localizing risk for formula-bearing export tasks.

D EXPERIMENTAL DETAILS · E DETAILED RELATED WORK · F PROMPTS

The paper evaluates SkillZip on procedural artifact-construction and embodied-interaction benchmarks using retrieval, structural-fidelity, recovery, and cost metrics. It situates the method among graph-based skill retrieval systems and specifies prompts that extract contracts, normalize data flow, anchor tasks, and support executable context use.

  • D EXPERIMENTAL DETAILS: SkillZip is evaluated on SkillsBench and ALFWorld, covering verifiable artifact construction and long-horizon interactive tasks under a 1,000-skill setting.SkillsBench uses executable verifiers, while ALFWorld measures episode success; verifier information is withheld until post-execution scoring.
  • D EXPERIMENTAL DETAILS: The evaluation reports end-task reward, retrieval quality, structural fidelity, recovery behavior, and system cost using task-specific reward definitions plus Ret@k and MRR.Structural metrics include dependency preservation and verifier reachability; measured final Tok is used when whole-skill packages exceed the target budget.
  • D EXPERIMENTAL DETAILS: Baselines span whole-skill disclosure, semantic and graph retrieval, exact-text deduplication, task-agnostic text compression, and other representation-level compression variants.All methods receive the same agent-visible task brief and benchmark metadata, without verifier code or assertion excerpts.
  • D EXPERIMENTAL DETAILS: Experiments match backbone, executor, and retrieval settings within comparison blocks while separating cached extraction, local graph construction, online retrieval, execution, and token-accounting costs.Library-scaling experiments enlarge only the candidate library, using fixed queries and annotations with strict-superset construction.
  • E DETAILED RELATED WORK: Related work progresses from reusable agent experience and progressive disclosure to dependency-aware skill graphs, reusable subunits, adaptive retrieval levels, and post-retrieval execution DAGs.The cited systems include Voyager [45], Reflexion [38], ExpeL [57], Graph-of-Skills [24], Group-of-Skills [54], SkillRAE [27], SkillLens [29], SkillDAG [1], and GRASP [48].
  • F PROMPTS: Sec2Graph extracts section roles, contracts, signatures, effects, and verifier hooks offline, while shared vocabulary normalization gives cross-section artifacts canonical names.The resulting structured records are cached with the library, and prompts operate at temperature zero.
  • F PROMPTS: PathHydrate converts technical and embodied task briefs into a common structured task object with ordered subgoals, signature-matched outputs, and explicit action chains.It fuses signature-oriented subgoal matching with raw task wording, then hydrates executable context; ALFWorld can request missing procedural detail within a fixed expansion budget.
  • F PROMPTS: Benchmark interfaces expose hydrated context to executors that either act directly or request targeted expansion, with SkillsBench tool search constrained and ALFWorld limited to one action or expansion request.The ALFWorld interface requires explicit navigation, manipulation, and state-changing steps rather than invented tools or implicit placements.
Loading 2608.05604v1…