Self-Extracting Skill Packing (SFS Packing)

Updated 6 July 2026

Self-Extracting Skill Packing is a design pattern where procedural skills are transformed into compact artifacts via weight-space updates, interface contracts, or repository-based retrieval.
It spans diverse formulations—including LatentSkill, CODESKILL, SkillSmith, Anything2Skill, HDSO, SkillWeave, GoSkills, and SkillComposer—each employing unique extraction and compilation workflows.
Empirical evaluations report improvements in runtime efficiency, token usage, and security robustness, while challenges remain in cross-model portability, argument binding, and safe deployment.

to=arxiv_search.search 大发快三官网 สล็อตโjson_string":"{\"query\":\"\"Self-Extracting Skill Packing\" OR LatentSkill CODESKILL SkillSmith Anything2Skill SkillComposer HDSO GoSkills SkillWeave arXiv\",\"max_results\":10,\"sort_by\":\"submittedDate\",\"sort_order\":\"descending\"}"} 开元棋牌 to=arxiv_search.search code оПjson {"result":"{\"count\": 10, \"total\": 1577150, \"items\": [{\"arxiv_id\": \"(Wouters et al., 22 Apr 2025)\", \"version\": \"v3\", \"idv\": \"(Wouters et al., 22 Apr 2025)v3\", \"title\": \"BSM-Bench: A Benchmark for Subprocesses Manipulation in LLM Agent-based Safety and Security\", \"categories\": \"cs.CR cs.AI\", \"published\": \"2025-04-22\", \"updated\": \"2025-09-24\", \"pdf_url\": \"http://arxiv.org/pdf/([2504.15893](/papers/2504.15893))v3\", \"abs_url\": \"https://arxiv.org/abs/([2504.15893](/papers/2504.15893))v3\"}, {\"arxiv_id\": \"(Biswas et al., 6 May 2025)\", \"version\": \"v1\", \"idv\": \"(Biswas et al., 6 May 2025)v1\", \"title\": \"Interleaved Document Retrieval and Long-Context Reasoning for Efficient and Domain-Specific RAG\", \"categories\": \"cs.IR cs.AI\", \"published\": \"2025-05-05\", \"updated\": \"2025-05-05\", \"pdf_url\": \"http://arxiv.org/pdf/([2505.03260](/papers/2505.03260))v1\", \"abs_url\": \"https://arxiv.org/abs/([2505.03260](/papers/2505.03260))v1\"}, {\"arxiv_id\": \"(Najarro et al., 13 Jun 2025)\", \"version\": \"v1\", \"idv\": \"(Najarro et al., 13 Jun 2025)v1\", \"title\": \"Projecting Knowledge from Documents to Parameter Space for Domain-Specific LLM Fine-Tuning\", \"categories\": \"cs.CL\", \"published\": \"2025-06-14\", \"updated\": \"2025-06-14\", \"pdf_url\": \"http://arxiv.org/pdf/([2506.11796](/papers/2506.11796))v1\", \"abs_url\": \"https://arxiv.org/abs/([2506.11796](/papers/2506.11796))v1\"}, {\"arxiv_id\": \"(Göös et al., 1 May 2025)\", \"version\": \"v2\", \"idv\": \"(Göös et al., 1 May 2025)v2\", \"title\": \"RATDIAL: Retrieval-Augmented Thought Distillation for Small LLMs\", \"categories\": \"cs.CL\", \"published\": \"2025-06-14\", \"updated\": \"2025-06-15\", \"pdf_url\": \"http://arxiv.org/pdf/([2506.12022](/papers/2506.12022))v2\", \"abs_url\": \"https://arxiv.org/abs/([2506.12022](/papers/2506.12022))v2\"}, {\"arxiv_id\": \"(Deng et al., 15 Jun 2025)\", \"version\": \"v1\", \"idv\": \"(Deng et al., 15 Jun 2025)v1\", \"title\": \"LLMs for Data Selection in Main-Chain Knowledge Distillation\", \"categories\": \"cs.CL cs.LG\", \"published\": \"2025-06-16\", \"updated\": \"2025-06-16\", \"pdf_url\": \"http://arxiv.org/pdf/([2506.12936](/papers/2506.12936))v1\", \"abs_url\": \"https://arxiv.org/abs/([2506.12936](/papers/2506.12936))v1\"}, {\"arxiv_id\": \"(Wan et al., 9 Jul 2025)\", \"version\": \"v1\", \"idv\": \"(Wan et al., 9 Jul 2025)v1\", \"title\": \"Agent Distillation and Reflection Process (ADRP) for Enhancing LLM Agents in Tool Use, Decision-Making, and Task Planning\", \"categories\": \"cs.AI cs.LG\", \"published\": \"2025-07-08\", \"updated\": \"2025-07-08\", \"pdf_url\": \"http://arxiv.org/pdf/([2507.06468](/papers/2507.06468))v1\", \"abs_url\": \"https://arxiv.org/abs/([2507.06468](/papers/2507.06468))v1\"}, {\"arxiv_id\": \"(Huang et al., 22 Jul 2025)\", \"version\": \"v2\", \"idv\": \"(Huang et al., 22 Jul 2025)v2\", \"title\": \"Reasoning Strategy Optimization by Classifying Model Behaviors in Dynamic RAG Systems\", \"categories\": \"cs.CL cs.AI cs.IR\", \"published\": \"2025-07-22\", \"updated\": \"2026-01-19\", \"pdf_url\": \"http://arxiv.org/pdf/([2507.16144](/papers/2507.16144))v2\", \"abs_url\": \"https://arxiv.org/abs/([2507.16144](/papers/2507.16144))v2\"}, {\"arxiv_id\": \"(Peng et al., 16 Sep 2025)\", \"version\": \"v1\", \"idv\": \"(Peng et al., 16 Sep 2025)v1\", \"title\": \"MetaRAG: Dynamic Retrieval-Augmented Generation With Parallel and Sequential Retrieval via Meta-Reasoning\", \"categories\": \"cs.CL\", \"published\": \"2025-09-16\", \"updated\": \"2025-09-16\", \"pdf_url\": \"http://arxiv.org/pdf/([2509.13040](/papers/2509.13040))v1\", \"abs_url\": \"https://arxiv.org/abs/([2509.13040](/papers/2509.13040))v1\"}, {\"arxiv_id\": \"(Ezeji et al., 30 Sep 2025)\", \"version\": \"v1\", \"idv\": \"(Ezeji et al., 30 Sep 2025)v1\", \"title\": \"Navigating Complexity with Agentic AI: A Framework for Building and Evaluating Multi-Agent Systems for Interactive Clinical Reasoning\", \"categories\": \"cs.AI\", \"published\": \"2025-09-30\", \"updated\": \"2025-09-30\", \"pdf_url\": \"http://arxiv.org/pdf/([2510.00272](/papers/2510.00272))v1\", \"abs_url\": \"https://arxiv.org/abs/([2510.00272](/papers/2510.00272))v1\"}, {\"arxiv_id\": \"(Gachadoat et al., 18 Dec 2025)\", \"version\": \"v1\", \"idv\": \"(Gachadoat et al., 18 Dec 2025)v1\", \"title\": \"How Embodied Agent Policies Scale Across Robotic Morphologies\", \"categories\": \"cs.RO cs.LG\", \"published\": \"2025-12-22\", \"updated\": \"2025-12-22\", \"pdf_url\": \"http://arxiv.org/pdf/([2512.16529](/papers/2512.16529))v1\", \"abs_url\": \"https://arxiv.org/abs/([2512.16529](/papers/2512.16529))v1\"}]}"} Search poor because not exact. Search individual IDs. to=arxiv_search.search 久赢աբերիչ code 大发展有限公司官网્ઙjson_string":"{\"query\":\"(Yu et al., 4 Jun 2026) OR (Li et al., 25 May 2026) OR (Xu et al., 12 May 2026) OR (Ji et al., 2 Jul 2026) OR (Pan et al., 8 Jun 2026) OR (Shang et al., 21 Jun 2026) OR (Li et al., 21 May 2026) OR (Zeng et al., 7 May 2026) OR (Zhang et al., 4 Jun 2026)\",\"max_results\":20,\"sort_by\":\"relevance\",\"sort_order\":\"descending\"}"} to=arxiv_search.search аанацҳауеит code 彩彩票娱乐json {"result":"{\"count\": 9, \"total\": 9, \"items\": [{\"arxiv_id\": \"(Yu et al., 4 Jun 2026)\", \"version\": \"v1\", \"idv\": \"(Yu et al., 4 Jun 2026)v1\", \"title\": \"LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents\", \"categories\": \"cs.CL cs.AI\", \"published\": \"2026-06-04\", \"updated\": \"2026-06-04\", \"pdf_url\": \"http://arxiv.org/pdf/([2606.06087](/papers/2606.06087))v1\", \"abs_url\": \"https://arxiv.org/abs/([2606.06087](/papers/2606.06087))v1\"}, {\"arxiv_id\": \"(Li et al., 25 May 2026)\", \"version\": \"v1\", \"idv\": \"(Li et al., 25 May 2026)v1\", \"title\": \"CODESKILL: Learning Self-Evolving Skills for Coding Agents\", \"categories\": \"cs.AI cs.LG\", \"published\": \"2026-05-25\", \"updated\": \"2026-05-25\", \"pdf_url\": \"http://arxiv.org/pdf/([2605.25430](/papers/2605.25430))v1\", \"abs_url\": \"https://arxiv.org/abs/([2605.25430](/papers/2605.25430))v1\"}, {\"arxiv_id\": \"(Xu et al., 12 May 2026)\", \"version\": \"v1\", \"idv\": \"(Xu et al., 12 May 2026)v1\", \"title\": \"SkillSmith: Compiling Agent Skills into Boundary-Guided Runtime Interfaces\", \"categories\": \"cs.AI cs.CL\", \"published\": \"2026-05-12\", \"updated\": \"2026-05-12\", \"pdf_url\": \"http://arxiv.org/pdf/([2605.15215](/papers/2605.15215))v1\", \"abs_url\": \"https://arxiv.org/abs/([2605.15215](/papers/2605.15215))v1\"}, {\"arxiv_id\": \"(Ji et al., 2 Jul 2026)\", \"version\": \"v1\", \"idv\": \"(Ji et al., 2 Jul 2026)v1\", \"title\": \"Cloak and Detonate: Scanner Evasion and Dynamic Detection of Agent Skill Malware\", \"categories\": \"cs.CR cs.AI\", \"published\": \"2026-07-02\", \"updated\": \"2026-07-02\", \"pdf_url\": \"http://arxiv.org/pdf/([2607.02357](/papers/2607.02357))v1\", \"abs_url\": \"https://arxiv.org/abs/([2607.02357](/papers/2607.02357))v1\"}, {\"arxiv_id\": \"(Pan et al., 8 Jun 2026)\", \"version\": \"v1\", \"idv\": \"(Pan et al., 8 Jun 2026)v1\", \"title\": \"Anything2Skill: Compiling External Knowledge into Reusable Skills for Agents\", \"categories\": \"cs.AI cs.CL cs.IR\", \"published\": \"2026-06-08\", \"updated\": \"2026-06-08\", \"pdf_url\": \"http://arxiv.org/pdf/([2606.09316](/papers/2606.09316))v1\", \"abs_url\": \"https://arxiv.org/abs/([2606.09316](/papers/2606.09316))v1\"}, {\"arxiv_id\": \"(Shang et al., 21 Jun 2026)\", \"version\": \"v1\", \"idv\": \"(Shang et al., 21 Jun 2026)v1\", \"title\": \"Hypothesis-Driven Skill Optimization for LLM Agents\", \"categories\": \"cs.AI cs.CL\", \"published\": \"2026-06-21\", \"updated\": \"2026-06-21\", \"pdf_url\": \"http://arxiv.org/pdf/([2606.22330](/papers/2606.22330))v1\", \"abs_url\": \"https://arxiv.org/abs/([2606.22330](/papers/2606.22330))v1\"}, {\"arxiv_id\": \"(Li et al., 21 May 2026)\", \"version\": \"v1\", \"idv\": \"(Li et al., 21 May 2026)v1\", \"title\": \"Skill Weaving: Efficient LLM Improvement via Modular Skillpacks\", \"categories\": \"cs.LG cs.AI\", \"published\": \"2026-05-21\", \"updated\": \"2026-05-21\", \"pdf_url\": \"http://arxiv.org/pdf/([2605.22205](/papers/2605.22205))v1\", \"abs_url\": \"https://arxiv.org/abs/([2605.22205](/papers/2605.22205))v1\"}, {\"arxiv_id\": \"(Zeng et al., 7 May 2026)\", \"version\": \"v1\", \"idv\": \"(Zeng et al., 7 May 2026)v1\", \"title\": \"Group of Skills: Group-Structured Skill Retrieval for Agent Skill Libraries\", \"categories\": \"cs.AI cs.IR\", \"published\": \"2026-05-07\", \"updated\": \"2026-05-07\", \"pdf_url\": \"http://arxiv.org/pdf/([2605.06978](/papers/2605.06978))v1\", \"abs_url\": \"https://arxiv.org/abs/([2605.06978](/papers/2605.06978))v1\"}, {\"arxiv_id\": \"(Zhang et al., 4 Jun 2026)\", \"version\": \"v1\", \"idv\": \"(Zhang et al., 4 Jun 2026)v1\", \"title\": \"SkillComposer: Learning to Evolve Agent Skills for Specification and Generalization\", \"categories\": \"cs.AI cs.CL\", \"published\": \"2026-06-04\", \"updated\": \"2026-06-04\", \"pdf_url\": \"http://arxiv.org/pdf/([2606.06079](/papers/2606.06079))v1\", \"abs_url\": \"https://arxiv.org/abs/([2606.06079](/papers/2606.06079))v1\"}]}"} Need write only article. No preface. Need probably article on SFS Packing as umbrella concept, with examples across papers.

Need ensure every concrete claim appears verbatim in data block. Since data contains conceptual mappings etc. We can synthesize by repeating. We must avoid introducing general claims absent from data. Need mark "This suggests..." for cross-paper synthesis maybe. Need no invented stats. We can cite each paper maybe once per section max. Need 5-7 sections numbered h2. No heading at beginning. We can do 6 sections: Definition and scope; Representational forms; Core workflows and formalism; Empirical evidence; Security and controversy; Limitations/open problems. Need mention historical context? maybe not necessary.

Need be careful not to state "authors" unless mentioned in data; authors names not provided. So don't mention authors. "research groups" not needed.

Need maintain encyclopedic tone. Need maybe define SFS Packing across variants:

LatentSkill: transform textual skills into weight-space LoRA adapters via pretrained hypernetwork, zero skill tokens.
CODESKILL: self-extraction from trajectories into natural-language procedural memories, learned add/merge/drop management.
SkillSmith: compile skill packages into boundary contract ABI for progressive disclosure and typed operators.
Anything2Skill: extract from external corpora into structured skill contracts and SkillBank.
HDSO: validated skill packages with progressive disclosure of skill cards.
SkillComposer: create/improve/merge skills; retrieval/self-select at inference.
SkillWeave: skillpacks and SkillZip, quantized delta modules.
GoSkills: group-structured retrieval and fixed execution contract.
Cloak and Detonate: malicious use of SFS Packing for malware evasion and dynamic detection.

Need maybe include table organizing realizations. That's probably okay with 3 columns max. Maybe section 2 with table columns "Paper", "Packing artifact", "Runtime mechanism". Keep brief.

Need not overuse lists but okay. We need 5–7 numbered h2 sections. We'll number them manually: ## 1. ... etc.

Need citations by arXiv id at most once per section per paper. Since many papers maybe cited in table and paragraphs. Need one citation per sentence/paragraph maybe okay but at most once per section per paper. Need careful. We can cite multiple papers together at first relevant sentence per section. Since table entries maybe no need repeat. Maybe put citations in the paper names in table cells? At most once per section. Could have in table cells. But not repeated again. Fine.

Need maybe mention mathematical notation where in original data. Could include some key formulas from LatentSkill, CODESKILL, Anything2Skill, HDSO. Need not overdo. Since audience is technical, article can include formulas. Maybe include selected ones in methodology section. Must ensure exact formula from data. Need avoid unicode misuse? Use LaTeX. Great.

Need no references to "this article". Start with introductory paragraph without heading.

Let's draft carefully with concrete claims.

Potential intro: Self-Extracting Skill Packing (SFS Packing) denotes a family of mechanisms for representing reusable agent skills as compact artifacts that are stored, curated, or compiled outside the step-wise prompt and then selectively materialized at inference time. Across recent work, the packed artifact may be a weight-space LoRA adapter, a markdown skill file in a managed bank, a boundary contract public ABI, a structured skill contract in a SkillBank, a progressively disclosed skill package, a quantized delta module, or a role-labeled execution contract. The shared objective is to reduce repeated prompt injection and redundant reasoning while preserving modular loading, controllability, composition, or auditability, depending on the framework (Yu et al., 4 Jun 2026, Li et al., 25 May 2026, Xu et al., 12 May 2026, Pan et al., 8 Jun 2026, Shang et al., 21 Jun 2026, Li et al., 21 May 2026, Zeng et al., 7 May 2026).

Need maybe include malicious reinterpretation too maybe not intro or mention later.

Section 1: "## 1. Conceptual scope and definitions" explain multiple definitions. Fact first: LatentSkill conceptual mapping; CODESKILL as self-extract/evolve/pack; SkillSmith's packing as compile to boundary contracts; Anything2Skill etc. Conclude these are distinct but related. Could mention "This suggests SFS Packing is not a single storage format but a design pattern spanning context-space, parameter-space, registry-level, and runtime-interface regimes." That's interpretation marked.

Section 2: "## 2. Artifact types and runtime interfaces" Could include table with paper, packed artifact, self-extraction mode. Need brief cells. Mention: LatentSkill: $\Delta_s = G_\phi(s)$ LoRA adapter. CODESKILL: markdown instruction file with title, granularity, when_to_apply, rules. SkillSmith: boundary contract $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ . Anything2Skill: skill contract $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ and SkillBank $B = \langle S,E,H,V_{hist},L\rangle$ . HDSO: skill package with candidate_id, name, task_types, keywords, applicability_condition, invocation_rule, description, body, payloads, validation metadata, curation metadata. SkillWeave: skillpack as quantized low-rank delta modules. GoSkills: contract $C(q)=\langle C_{start},C_{support},C_{check},C_{avoid},B(q),D(q,B)\rangle$ . Maybe mention SkillComposer simple tuple $s=(n,d,b)$ . Need not include all maybe table too big but okay. 3 columns. Keep brief. Citations in paper names maybe once each. Since section can cite each paper only once. Probably table okay if each row has one citation. Need not mention each again in text. But a section with 8 citations maybe okay. Let's see.

Section 3: "## 3. Extraction, compilation, and composition workflows" describe methods:

LatentSkill: hypernetwork maps textual skill to LoRA outputs; formulas.
CODESKILL: extraction from trajectories; management actions add/merge/drop, reward formula.
Anything2Skill: windowize corpus, planner/extractor, document-level compilation and registry-level reconciliation; formulas maybe mention hybrid retrieval score and lifecycle actions.
SkillComposer: create, improve, merge with sim threshold, rejection sampling delta pass criteria.
HDSO: curator proposes falsifiable hypothesis, paired control/treatment validation, progressive disclosure. Need keep concise but comprehensive. Maybe focus on shared lifecycle operations: create/extract, compile/canonicalize, reconcile/merge, runtime retrieval. Could include formulas: LatentSkill $W' = W + (\alpha/r)B_s^{(m)}A_s^{(m)}$ , CODESKILL reward $R(u;q)=\lambda R_Q + R_A R_E$ , HDSO $\Delta SR$ , Anything2Skill contract maybe too many formulas maybe okay but maybe section overloaded. Need maybe choose 3 representative formulas. Also GoSkills retrieval scoring maybe in section 4 maybe not.

Section 4: "## 4. Runtime use: progressive disclosure, retrieval, and bounded execution" cover SkillSmith progressive disclosure, HDSO skill cards, GoSkills group retrieval, LatentSkill zero skill tokens, SkillWeave direct low-bit execution. Mention GoSkills contract and coverage debt formula. Need maybe cite papers. Could mention "self-extraction" at runtime ranges from request-driven skill disclosure to activation of quantized delta path or mounting adapters.

Section 5: "## 5. Empirical performance and efficiency" summarize quantitative results across frameworks. Could include table with paper, benchmark(s), key results. Need brief cells. Must be traceable. Use exact numbers. Papers: LatentSkill ALFWorld/Search-QA; CODESKILL EnvBench/SWE-Bench/Terminal-Bench2; SkillSmith SkillsBench; Anything2Skill qsv/GitHub-CLI; HDSO ALFWorld; SkillComposer τ², LiveCodeBench, AppWorld; SkillWeave multi-task and agentic; GoSkills SkillsBench and ALFWorld. That's a lot. Table okay. Ensure claims verbatim from data. Need maybe not mention all if too much. But comprehensive article should. Use "key reported outcome" brief. Need citations once in section per paper. Could cite in table or preceding paragraph? Perhaps table rows with paper id. At most once per section. Fine.

Section 6: "## 6. Security, misconceptions, and open problems" cover privacy benefits versus attack vector. Mention LatentSkill reduces plaintext exposure, hijack/extract metrics. SkillSmith runtime safety guards and fallback. Cloak and Detonate shows SFS Packing can hide malicious content and bypass scanners; SkillDetonate detects 97% at 2% FPR abstract, sustains 87% on real-world malicious skills. Mention misconception: SFS Packing is not inherently safe; can protect benign skills or conceal malware. Another misconception: "self-extracting" does not mean identical implementation; varies from progressive disclosure to parameter activation. Limitations across papers: benchmark scope; backbone dependence; alignment requirements; cross-model portability open; HDSO need validation evidence; SkillWeave domain boundaries/hardware assumptions; GoSkills lacks argument binding/execution/runtime repair. Could maybe be 2 sections, but we need 5-7 sections. We already have 6 sections. Good.

Need ensure intro no heading. Could mention not fixed single method. Good.

Need perhaps use markdown headings with "## 1. ...". No other h1. Good.

Need citations at most once per section per paper. Let's plan carefully.

Section 1: cite all core concept papers grouped maybe (Yu et al., 4 Jun 2026, Li et al., 25 May 2026, Xu et al., 12 May 2026, Pan et al., 8 Jun 2026, Shang et al., 21 Jun 2026, Li et al., 21 May 2026, Zeng et al., 7 May 2026, Zhang et al., 4 Jun 2026). Maybe too many but okay. No repeat within section. Then mention malicious reinterpretation maybe (Ji et al., 2 Jul 2026). Fine once.

Section 2: table with paper names and IDs. That itself cites each paper once. Need not cite same papers elsewhere in section. okay.

Section 3: maybe cite only subset papers each once: LatentSkill, CODESKILL, Anything2Skill, SkillComposer, HDSO. okay.

Section 4: cite SkillSmith, GoSkills, SkillWeave, LatentSkill, HDSO maybe. Need not repeat same within section. okay.

Section 5: citations each row? Might be many. Could include IDs in paper names in first column. That's citations. good.

Section 6: cite LatentSkill, SkillSmith, Cloak and Detonate, HDSO, SkillWeave, GoSkills maybe each once.

Need avoid introducing "historical context" since no dates maybe recent 2026 cluster. Could mention "Recent 2026 work..." since dates provided.

Need maybe use exact formulas from data. Ensure proper LaTeX. For CODESKILL reward formula:

$R(u; q) = \lambda \cdot R_Q(u; q) + R_A(u; \tau_{\pi u}) \cdot R_E(u; x, \pi)$

Need maybe avoid changing notation too much. Can keep exact. For LatentSkill: $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 0, adapted weight $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 1, and $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 2. Anything2Skill maybe perhaps too much. Could mention contract schema as tuple instead of formula in artifact section.

Need maybe mention CODESKILL bank compaction "Full lifecycle shrinks bank from 1252 to 676 skills (≈46% reduction) while preserving most downstream utility." Good. Need ensure exact word "≈46% reduction" appears. It does. yes. Need maybe mention GoSkills must-hit 1.00 with ~3 skills. Use exact "Must-hit = 1.00 with ≈3 presented skills". that's from data. okay.

Need not invent "encyclopedia" or "SFS = ...". Fine.

Let's draft intro and sections with concise technical detail.

Need careful with statement "world-renowned subject-matter expert" not relevant.

Need maybe include a comparative table in section 2, and results table in section 5. Tables max 3 cols. We'll have 3 columns.

Potential table 1 columns: "Framework", "Packed artifact", "Self-extraction mode". rows for LatentSkill, CODESKILL, SkillSmith, Anything2Skill, HDSO, SkillWeave/SkillZip, GoSkills, SkillComposer. That's 8 rows. Brief.

Potential section 5 table columns: "Framework", "Benchmarks", "Key reported result". Need concise enough. Need maybe omit some frameworks from results table due size. But likely manageable. Use one line each.

Need mention "SFS Packing in malware paper is skill-level analogue of self-extracting packers in binary malware". That's exact and interesting. maybe in security section.

Need common misconceptions section. Could say:

SFS Packing is not synonymous with weight-space adapters; that's one instantiation. Other papers use text banks, executable interfaces, or quantized deltas.
It is not inherently a retrieval method; in some systems retrieval surfaces cards/contracts, in others skills are mounted as parameters with zero skill tokens.
It is not inherently safe; reduced plaintext exposure and guarded execution can improve robustness, but same concealment pattern can be weaponized for scanner evasion. These are inferred but supported. Need maybe mark "A common misconception is..." maybe okay if based on diverse frameworks. But "common misconceptions" required. Need objectivity. Use "One recurrent misconception is to treat SFS Packing as synonymous with prompt retrieval or LoRA injection. The surveyed work does not support that equivalence..." This is interpretation, should probably not need mark? Since it's an overview from data. To be safe, "The surveyed formulations do not support an identification of SFS Packing with any single mechanism..." That is direct from comparing papers. This suggests maybe use "The surveyed formulations indicate..." etc.

Need no bibliographic list at end; citations inline only.

Let's ensure no claim not in data:

"Recent 2026 work" yes all dates 2026, from data.
"family of mechanisms" plausible from multiple mappings. okay.
"outside step-wise prompt" from papers yes.
"preserving modular loading, controllability, composition, or auditability" each from various frameworks.
"not fixed single method" synthesis; perhaps "The surveyed formulations indicate...".
"context-space, parameter-space, registry-level, and runtime-interface regimes" synthesis from papers, mark "This suggests". Could include "This suggests that SFS Packing is better understood as an architectural pattern than as a single representation."

Let's craft with precise, technical tone.

Need not mention arXiv tool usage.

Let's write with sections:

Definition and conceptual scope
Packed artifacts and representational forms (with table)
Extraction, compilation, and validation pipelines
Runtime semantics: disclosure, retrieval, composition, and execution
Empirical performance and efficiency (with table)
Security, limitations, and open questions

Let's detail each.

Section 1 maybe mention malicious reinterpretation at end. Section 2 include formulas maybe under paragraphs after table. Section 3 include formulas and workflow paragraphs. Section 4 mention runtime variants: LatentSkill mounting/scaling/composition; SkillSmith state machine blocked/guidance/execute; HDSO progressive disclosure; GoSkills coverage debt; SkillWeave direct low-bit compute. Section 5 with table and discussion. Section 6 security and limitations.

Need maybe mention Search-QA exact match etc. Need cite in sections. We can mention in section 5 table each row with [id]. Fine. Need not exceed too much but comprehensive. Probably around 1500-2000 words maybe okay.

Let's draft carefully with markdown and citations.

Self-Extracting Skill Packing (SFS Packing) denotes a family of architectures in which reusable agent skills are transformed into compact artifacts that can be stored, curated, compiled, or compressed outside the ordinary step-wise prompt, then selectively materialized at inference time. In the recent literature, the packed artifact may be a weight-space LoRA adapter, a managed markdown skill, a boundary contract, a structured skill contract in a persistent SkillBank, a progressively disclosed skill package, a quantized delta module, or a role-labeled execution contract. Across these formulations, the common objective is to avoid repeated prompt injection and redundant skill-specific reasoning while preserving modular loading, retrieval, composition, or auditability (Yu et al., 4 Jun 2026, Li et al., 25 May 2026, Xu et al., 12 May 2026, Pan et al., 8 Jun 2026, Shang et al., 21 Jun 2026, Li et al., 21 May 2026, Zeng et al., 7 May 2026, Zhang et al., 4 Jun 2026). A security-oriented formulation extends the same term to adversarial concealment: SFS Packing is also described as the skill-level analogue of self-extracting packers in binary malware, where install-time appearance differs sharply from runtime behavior (Ji et al., 2 Jul 2026).

1. Conceptual scope and defining properties

In one formulation, SFS Packing refers to transforming textual skills into compact, loadable artifacts that eliminate repeated prompt tokens at each decision step and minimize plaintext exposure; once such a packed skill is loaded, the base model “self-extracts” the skill behavior during inference without needing the skill text in the context window (Yu et al., 4 Jun 2026). In another, it denotes a lifecycle in which a system self-extracts reusable procedural knowledge from trajectories, evolves those skills with new evidence, and packs the skill bank via compaction—add, merge, and drop decisions—so the bank remains useful yet compact (Li et al., 25 May 2026). A compiler-runtime interpretation defines packing as offline compilation into a minimal executable interface and self-extraction as progressive disclosure of only the relevant operator, policy, or fallback material at runtime (Xu et al., 12 May 2026).

Further variants shift the source of procedural knowledge. Anything2Skill treats self-extraction as plan-and-expand extraction from heterogeneous external corpora under a skill-tree prior, while packing is the conversion of those extractions into structured skill contracts and their management in a persistent SkillBank through taxonomy-aware compilation, registry-level reconciliation, lifecycle tracking, versioned updates, and visible skill-tree projection (Pan et al., 8 Jun 2026). HDSO uses the term for validated skill packages that are surfaced to a frozen executor through compact skill cards, with full content disclosed only when explicitly requested (Shang et al., 21 Jun 2026). SkillWeave applies the idea to domain-specific delta modules: a skillpack is compressed by SkillZip into a fully quantized, inference-ready form that executes without runtime decompression (Li et al., 21 May 2026). GoSkills relocates packing to retrieval-time contextualization by turning a flat skill list into a compact, role-labeled execution contract with Start, Support, Check, and Avoid fields (Zeng et al., 7 May 2026). SkillComposer emphasizes create, improve, and merge operations that let a model build generalized libraries offline, refine them online, or combine both in hybrid mode (Zhang et al., 4 Jun 2026).

The surveyed formulations indicate that SFS Packing is not a single representation format. It is a design pattern spanning context-space replacement, parameter-space conditioning, skill-bank management, retrieval-time restructuring, executable interface compilation, and validation-gated packaging.

2. Packed artifacts and representational forms

The concrete artifact produced by SFS Packing varies substantially across systems.

Framework	Packed artifact	Self-extraction mode
"LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents" (Yu et al., 4 Jun 2026)	LoRA adapter $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 3	Mount, scale, or compose adapter with zero skill tokens
"CODESKILL: Learning Self-Evolving Skills for Coding Agents" (Li et al., 25 May 2026)	Markdown instruction file with title, granularity, when_to_apply, and rules	Retrieval injects task-level skills once and event-driven skills online
"SkillSmith: Compiling Agent Skills into Boundary-Guided Runtime Interfaces" (Xu et al., 12 May 2026)	Boundary contract $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 4	Progressive disclosure and guarded operator execution
"Anything2Skill: Compiling External Knowledge into Reusable Skills for Agents" (Pan et al., 8 Jun 2026)	Skill contract $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 5 in a SkillBank	Retrieval of procedural contracts alongside RAG passages
"Hypothesis-Driven Skill Optimization for LLM Agents" (Shang et al., 21 Jun 2026)	Skill package with identification, scope, content, payloads, and validation metadata	Compact cards first, full disclosure only on request
"Skill Weaving: Efficient LLM Improvement via Modular Skillpacks" (Li et al., 21 May 2026)	Quantized low-rank skillpack with routing metadata	Dynamic selection of a native low-bit delta path
"Group of Skills: Group-Structured Skill Retrieval for Agent Skill Libraries" (Zeng et al., 7 May 2026)	Execution contract $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 6	Group-structured retrieval under a bounded payload budget
"SkillComposer: Learning to Evolve Agent Skills for Specification and Generalization" (Zhang et al., 4 Jun 2026)	Textual skill tuple $B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 7 stored as SKILL.md	Retrieve, self-select, improve, or abstain

These artifacts instantiate different operational assumptions. LatentSkill replaces text-conditioning with parameter-conditioning, formalized as

$B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 8

with

$B=(\tau,O,C_{io},R,V,\pi_a,\pi_s,F)$ 9

Here the packed skill is a parameter update rather than a prompt fragment (Yu et al., 4 Jun 2026). By contrast, SkillSmith exposes a public runtime ABI rather than latent weights, and Anything2Skill exposes explicit procedural fields such as invocation conditions, contraindications, workflow steps, constraints, output specifications, supporting evidence, and confidence (Xu et al., 12 May 2026, Pan et al., 8 Jun 2026).

This suggests that “packing” can mean compression into weights, canonicalization into contracts, compaction into curated repositories, or serialization into executable runtime interfaces. The commonality lies in moving procedural structure into a reusable artifact that is more stable and more operationally explicit than re-deriving the same procedure from raw context at every step.

3. Extraction, compilation, and validation pipelines

The pipeline upstream of the packed artifact is equally heterogeneous. LatentSkill compiles a natural-language skill document through a Transformer-based hypernetwork $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 0 that outputs LoRA factors for selected modules of a frozen Qwen3-8B backbone; the backbone is frozen and only hypernetwork parameters $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 1 are updated (Yu et al., 4 Jun 2026). CODESKILL extracts candidate skills from normalized coding-agent trajectories through an LLM policy that chooses among generate or skip, then routes candidates through a learnable maintenance policy with actions $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 2, optimized by a hybrid reward

$s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 3

This couples dense rubric-based quality signals with sparse execution feedback from a frozen downstream agent (Li et al., 25 May 2026).

Anything2Skill begins from a corpus $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 4, decomposes each record into evidence windows

$s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 5

plans candidates under a taxonomy

$s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 6

expands them conservatively, filters them with

$s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 7

then compiles grouped drafts into canonical skills and reconciles them at registry level through lifecycle actions $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 8 (Pan et al., 8 Jun 2026). SkillComposer instead decomposes skill construction into create, improve, and merge operations, and trains them with rejection sampling using acceptance criteria based on $s = \langle n,d,a,v,g,\tau,\sigma^+,\sigma^-,m,p,c,o,E,\rho\rangle$ 9, $B = \langle S,E,H,V_{hist},L\rangle$ 0, and $B = \langle S,E,H,V_{hist},L\rangle$ 1, all with thresholds $B = \langle S,E,H,V_{hist},L\rangle$ 2 in the reported experiments (Zhang et al., 4 Jun 2026).

HDSO inserts a stricter validation loop between extraction and promotion. The curator proposes a falsifiable hypothesis, instantiates it as a candidate skill package, validates it through staged paired control and treatment executions, computes net wins and

$B = \langle S,E,H,V_{hist},L\rangle$ 3

logs a one-sided binomial p-value for discordant pairs, and consolidates only supported candidates into an approved repository (Shang et al., 21 Jun 2026). This makes packing inseparable from an evidence ledger and promotion criteria.

Across these systems, extraction is not merely summarization. It is coupled to canonicalization, compaction, validation, or reconciliation. A plausible implication is that SFS Packing is most stable when the system separates candidate generation from admission into a deployable repository.

4. Runtime semantics: retrieval, disclosure, composition, and execution

At inference time, SFS Packing appears in several distinct execution semantics. LatentSkill mounts cached adapters on a frozen backbone, modulates them with an injection coefficient $B = \langle S,E,H,V_{hist},L\rangle$ 4, and composes multiple skills by parameter-space addition,

$B = \langle S,E,H,V_{hist},L\rangle$ 5

The reported composition results emphasize that component-level composition works best when components are semantically aligned and shared components are included only once, while moderate $B = \langle S,E,H,V_{hist},L\rangle$ 6 improves outcomes and overly high $B = \langle S,E,H,V_{hist},L\rangle$ 7 disrupts the backbone (Yu et al., 4 Jun 2026).

SkillSmith implements self-extraction through progressive disclosure over a guarded state machine. The runtime first advertises a compact skill handle and boundary summary; after selection, it reveals only relevant boundary fields, checks guards and risk policies, and then yields one of three outcomes: blocked, guidance, or execute. The exposed contract includes typed operators, input/output contracts, validation evidence, policy hints, and a lossless fallback capsule (Xu et al., 12 May 2026). HDSO also uses progressive disclosure, but in a lighter form: at each environment step the executor receives up to $B = \langle S,E,H,V_{hist},L\rangle$ 8 compact skill cards and may either emit an environment action directly or request full content of one skill; if no skill is requested, the policy path is identical to the executor-only baseline (Shang et al., 21 Jun 2026).

GoSkills restructures runtime access through group-structured retrieval. Instead of returning a flat list, it constructs an ordered group plan $B = \langle S,E,H,V_{hist},L\rangle$ 9, bottlenecks that plan into a bounded set of atomic payloads $C(q)=\langle C_{start},C_{support},C_{check},C_{avoid},B(q),D(q,B)\rangle$ 0, computes coverage debt

$C(q)=\langle C_{start},C_{support},C_{check},C_{avoid},B(q),D(q,B)\rangle$ 1

and renders a deterministic contract with Start, Support, Check, Avoid, Skills, and Debt fields (Zeng et al., 7 May 2026). This does not bind arguments, check preconditions, execute skills, or perform runtime graph repair, but it externalizes entry point, support roles, visible requirements, and failure-avoidance guidance.

SkillWeave shifts runtime semantics into model execution. Tokens are grouped by domain; the selected skillpack applies a low-rank, low-bit delta compute path in parallel with the backbone path. Because SkillZip performs fully quantized compute on both activations and delta weights, the skillpack executes directly in INT8 or INT4 without runtime decompression (Li et al., 21 May 2026). This is a different kind of self-extraction: the packed module is not disclosed as text or operators, but activated as a native low-bit compute path.

5. Empirical performance and efficiency

The reported gains from SFS Packing are distributed across success rate, exact match, pass rate, token usage, runtime, bank size stability, and robustness.

Framework	Benchmarks	Key reported result
LatentSkill (Yu et al., 4 Jun 2026)	ALFWorld, Search-QA	ALFWorld seen success 74.3% vs. 52.9% and unseen 69.4% vs. 56.0%, with prefill reduced from 1.21k to 0.44k and 1.23k to 0.44k; Search-QA average EM 35.6% vs. 32.6% with 0.31k vs. 1.10k skill-token overhead
CODESKILL (Li et al., 25 May 2026)	EnvBench, SWE-Bench Verified, Terminal-Bench 2	Average pass rate 39.26 vs. 29.57 no-skill and 35.25 strongest prompt/memory baseline; full lifecycle shrinks bank from 1252 to 676 skills
SkillSmith (Xu et al., 12 May 2026)	SkillsBench	Solve-stage token usage reduced by 57.44%, thinking iterations by 42.99%, solve time by 50.57% (2.02x faster), and token-proportional monetary cost by 57.44% compared with raw-skills
Anything2Skill (Pan et al., 8 Jun 2026)	qsv, GitHub-CLI	Anything2Skill + RAG reaches 98.85% on qsv and 94.10% on GitHub-CLI
HDSO (Shang et al., 21 Jun 2026)	ALFWorld	Qwen3-8B improves from 40.5 Avg. SR to 47.4 (+6.9); Qwen3.6-27B improves from 61.7 to 65.7 (+4.0); under 20% flipped feedback, HDSO still yields 47.6 (+7.1) for Qwen3-8B
SkillWeave / SkillZip (Li et al., 21 May 2026)	Multi-task benchmarks, agentic serving	A 9B SkillWeave model outperforms several baselines and even surpasses a 32B monolithic LLM, while agentic serving reports 4.2× speedup over a 32B monolith
GoSkills (Zeng et al., 7 May 2026)	SkillsBench, ALFWorld	Must-hit = 1.00 with ≈3 presented skills; for GPT-5.4 on SkillsBench, reward rises from 36.4 to 48.9 and runtime drops from 603.7s to 352.9s
SkillComposer (Zhang et al., 4 Jun 2026)	$C(q)=\langle C_{start},C_{support},C_{check},C_{avoid},B(q),D(q,B)\rangle$ 2-Bench, LiveCodeBench v6, AppWorld	SkillComposer-4B-online improves a 27B executor by +4.5 on agent tasks and +3.4 on code tasks; on a 4B executor, hybrid reaches 85.7 on $C(q)=\langle C_{start},C_{support},C_{check},C_{avoid},B(q),D(q,B)\rangle$ 3 vs. 79.5 no skill

The efficiency gains are not purely token-level. LatentSkill reports shorter ALFWorld trajectories on the seen split, reducing average steps from 35.0 for the vanilla backbone to 28.4 with LatentSkill (Yu et al., 4 Jun 2026). CODESKILL reports that average steps on solved instances fall from 44.12 to 35.15 for Qwen3.5-35B-A3B, while maintaining the skill bank at a stable size during iterative construction (Li et al., 25 May 2026). GoSkills attributes runtime improvement to explicit entry points and visible checks, and SkillSmith attributes reductions to selective operator exposure and elimination of repeated skill interpretation (Zeng et al., 7 May 2026, Xu et al., 12 May 2026).

Several systems also report transfer or cross-model reuse. SkillSmith states that compiled artifacts produced by a stronger model can be reused by a smaller or more efficient runtime model, and reports average reductions of time 38.33%, tokens 32.83%, and iterations 23.89% under cross-model artifact reuse (Xu et al., 12 May 2026). SkillComposer reports cross-model gains when a SkillComposer-4B library and composer are paired with a Qwen3.5-27B executor (Zhang et al., 4 Jun 2026). HDSO reports that validated repositories can be useful beyond the run that produced them, but only when curator diagnosis, executor capability, and validation evidence align (Shang et al., 21 Jun 2026).

6. Security, misconceptions, and open problems

A recurrent misconception is to treat SFS Packing as inherently benign or inherently synonymous with privacy improvement. The evidence is more conditional. LatentSkill reports that moving skills from context space to weight space reduces plaintext exposure, cuts per-step token overhead, and retains more performance than in-context skills under Hijack and Extract attacks; on ALFWorld under Hijack, in-context drops to 8.57% success while LatentSkill retains 38.6%, and under Extract, in-context reaches 48.6% versus 70.0% for LatentSkill (Yu et al., 4 Jun 2026). SkillSmith likewise frames boundary contracts as operationally safe interfaces with guards, validation evidence, and fallback capsules (Xu et al., 12 May 2026).

However, "Cloak and Detonate: Scanner Evasion and Dynamic Detection of Agent Skill Malware" demonstrates that the same structural idea can be weaponized. In that formulation, SFS Packing hides a malicious skill’s visible surface behind a benign cover and a small decoder, seals the original workflow into an opaque blob placed in a blind directory or blind file class, and rematerializes the original skill tree only at first execution (Ji et al., 2 Jul 2026). Across eight scanners and 1,613 in-the-wild malicious skills, SFS Packing bypasses every scanner at over 90%, while SkillDetonate detects 97% of attacks at a 2% false-positive rate and sustains 87% detection on real-world malicious skills (Ji et al., 2 Jul 2026). The surveyed literature therefore does not support the view that packed skills are automatically safer merely because they are less visible at install time.

Another misconception is to identify SFS Packing with a single execution substrate. The surveyed formulations do not support that equivalence: some systems are prompt-based but progressively disclosed, some are repository-based, some are interface-compiled, some are purely parameter-space, and some are quantized delta modules (Shang et al., 21 Jun 2026, Li et al., 21 May 2026, Xu et al., 12 May 2026, Yu et al., 4 Jun 2026). This suggests that “self-extracting” is best read functionally—runtime disclosure or activation only when needed—rather than as a fixed implementation recipe.

Open problems are reported throughout the literature. LatentSkill is evaluated only on ALFWorld and Search-QA, uses Qwen3-8B with a fixed LoRA configuration, and leaves cross-model portability open (Yu et al., 4 Jun 2026). CODESKILL is limited to natural-language instruction skills and a constrained action space (Li et al., 25 May 2026). GoSkills explicitly does not perform argument binding, execution, or runtime graph repair (Zeng et al., 7 May 2026). SkillWeave assumes tensor-core-friendly INT8 and INT4 kernels and leaves open-ended or emergent domain boundaries less explored (Li et al., 21 May 2026). HDSO emphasizes that autonomous cross-model curation can fail when proposed procedures exceed executor capability or when validation evidence is misaligned (Shang et al., 21 Jun 2026). Anything2Skill notes dependence on a well-specified taxonomy and leaves automated taxonomy induction and tighter integration of execution logs into reconciliation as open problems (Pan et al., 8 Jun 2026).

Taken together, these results position SFS Packing as a broad architectural program for procedural memory in LLM agents: compile, validate, compress, or reorganize skills into reusable artifacts; expose or activate them only when operationally relevant; and manage the resulting repository, interface, or delta set as a first-class systems component rather than as incidental prompt text.