Pith. sign in

REVIEW 3 major objections 5 minor 48 references

This paper defines Skillware, a software abstraction that lets persistent natural-language agent capabilities be treated as identifiable, composable, versioned software units with their own lifecycle.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-01 13:47 UTC pith:ER7BDDQC

load-bearing objection The paper's real contribution is a workable ontology and lifecycle for treating agent skills as software; the empirical boundary evidence is thinner than the conceptual frame, but the authors say so themselves. the 3 major comments →

arxiv 2607.18970 v2 pith:ER7BDDQC submitted 2026-07-21 cs.SE cs.AI

Skillware: A Software Ontology and Engineering Lifecycle for Persistent Behavioral Artifacts

Haodi Fan , Zucong Lan This is my paper
classification cs.SE cs.AI
keywords SkillwareAgent Skillsbehavioral artifactsnatural-language programmingsoftware ontologysoftware engineering lifecycleidentity-preserving evolutiondesign pattern transfer
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper tries to establish that agent skills—persistent natural-language task specifications that agents load and execute—have become a distinct kind of software object, and that software engineering can be extended to them through a named abstraction, Skillware. It defines three auditable conditions for membership—behavioral primacy, independent software identity, and an agent-host execution relationship—plus a separate property, Lifecycle Continuity, for whether the same unit survives updates, rollbacks, and removal. The authors argue that a recurring artifact envelope and engineering pressure already exist, evidenced by a frozen corpus of over 138,000 skill files, independent studies, and fixed-revision case reviews. If right, this gives agent capabilities an address, version, provenance, and change process, making them composable and maintainable like conventional software components.

Core claim

The paper claims that persistent natural-language behavioral specifications create a managed software surface in agent systems. It defines Skillware as the software abstraction that extends software engineering to this surface by providing addressable artifacts, independent identity, documented or reconstructed activation relations, engineering structure, and a basis for identity-preserving change. Operationally, membership requires three necessary conditions applied to the same unit: behavioral primacy (the skill source organizes the reusable task contract), independent software identity (a name, address, package, version, or provenance trackable apart from the agent host), and an agent-hos

What carries the argument

The central machinery is an operational definition: a Skillware Unit is the independently managed software identity wrapped around a Skill Artifact, and membership is decided by three necessary conditions—C1 behavioral primacy, C2 independent software identity, C3 agent-host execution—with Lifecycle Continuity evaluated as an orthogonal software-grade property. The definition anchors a chain of responsibilities from behavioral source, through skill artifact and unit, to agent host, runtime, execution trace, and task outcome, which keeps artifact specification separate from runtime interpretation and situated performance.

Load-bearing premise

The load-bearing premise is that the sampled skill files and reviewed cases fairly represent the broader ecosystem; if the registry-heavy corpus and purposively selected cases are unrepresentative, or if other analysts would classify the boundaries differently, the claimed universality of the Skillware ontology is not established.

What would settle it

Have independent raters apply C1-C3 to a random, revision-frozen sample of skill-bearing repositories, including ones with heavy executable support; if a substantial share fail C2 (no independently trackable identity) or C3 (no skills-compatible agent host activation path), or if raters disagree systematically on C1, then the claim that persistent behavioral artifacts form a recurring managed software surface would be refuted.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Agent skills can be treated as identifiable software units, so acquisition, installation, activation, update, and removal become managed operations rather than ad-hoc file copying.
  • The three conditions give an auditable boundary that distinguishes Skillware from prompts, tools, plugins, indexes, and session-bound configurations.
  • Lifecycle Continuity makes 'the same skill across versions' a measurable property, enabling versioned release, rollback, and maintenance tracking.
  • Established design patterns and engineering mechanisms can transfer to natural-language behavioral source, giving architects known structures for building and testing skill-based systems.
  • Engineering Consolidation and Identity-Preserving Evolution describe how a text-first skill can mature into a hybrid system with scripts, tests, events, and governed change while keeping one identity.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the ontology is adopted, natural-language behavioral specifications could eventually be published with semantic versioning and compatibility declarations, letting agents check whether a skill will work before activation.
  • The C1-C3 boundary suggests a practical diagnostic: many files in skill registries may fail C2 or C3, meaning the true population of Skillware units could be much smaller than file counts imply.
  • A testable extension would measure Lifecycle Continuity across a random sample of skill repositories; low continuity would indicate that most skills are still disposable prompts rather than managed software.
  • The ontology implies a clean division between artifact quality and runtime quality, which could change how failures are attributed in agent systems—ambiguous source versus model, context, or tool problems.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes Skillware, a software ontology and engineering lifecycle for persistent behavioral artifacts (Agent Skills) in AI agent systems. It defines a Behavioral Artifact and a Skillware Unit, with three necessary conditions for category membership (C1 behavioral primacy, C2 independent software identity, C3 Agent Host execution relationship), plus a separate Lifecycle Continuity property. Evidence combines the Agent Skills specification, a frozen corpus of 138,133 SKILL.md records, independent empirical studies, 15 purposively selected category-boundary cases, 13 fixed-revision technical cases, and constructive design-pattern fixtures. The central claim is that persistent natural-language behavioral specifications create a managed software surface, and Skillware is the abstraction that provides addressable artifacts, independent identity, activation relations, engineering structure, and a basis for identity-preserving change.

Significance. If the central claim holds, the paper supplies a useful definitional anchor for a fast-moving area: it makes a coherent proposal for what counts as a Skillware Unit, separates structural from lifecycle concerns, and connects Agent Skills to established software-engineering concepts. The paper is generally careful to bound its claims (no prevalence claims, no behavioral-equivalence claims, explicit inference limits per evidence layer). Concrete strengths are the frozen corpus with pinned hashes and repository revisions, the auditable case-review protocol with counterevidence fields, and the explicit admission of limitations in §7.2. The definitional contribution is plausible and could support future empirical and theoretical work. The main risk is that the empirical support for the 'recurring artifact envelope' is weaker than the presentation sometimes implies, because the case classifications rely on a subjective C1 judgment with no inter-rater reliability.

major comments (3)
  1. [§4.4, §7.2] The load-bearing empirical claim that C1–C3 identify a stable, auditable category rests on purposively selected cases. §4.4 explicitly states 'It supplies no estimate of inter-rater reliability,' and §7.2 concedes that primacy can be difficult to judge in packages with substantial executable services and that different analysts may select different unit boundaries. Since C1 is a judgment about which artifact is primary in behavior, routing, and user-facing identity, static source inspection alone does not verify it. The paper's own limitation statements do not repair this. I do not think this invalidates the conceptual proposal, but it does mean the 'empirical evidence establishes a recurring artifact envelope' framing in §7.4 overstates what the case review supports. The authors should either (a) rescope the claim to 'the case review demonstrates that the category can be operationalized
  2. [§5.3, Table 5] The design-pattern transfer evidence is presented as software-continuity evidence, but the main-text mappings combine the authors' own constructive fixtures (e.g., the release-subject fixture in §5.3.4, the evidence-strategy fixture in §5.3.6) with selected open-source correspondences. Table 5 itself marks most mappings as 'candidate' or 'constructive.' This shows constructibility, which is a legitimate contribution, but it does not establish recurrence in the ecosystem. The paper mostly says this ('Ecosystem frequency and comparative benefit remain empirical questions'), so the main issue is presentation: the conclusion (§7.4) lists 'documented or reconstructed activation relations' as evidence for the central claim. Recommended fix: separate 'constructibility' from 'recurrence' more sharply in the abstract and conclusion.
  3. [§4.2, Table 3] The 138,133-record corpus is registry-heavy and used for narrow claims, which the paper acknowledges. However, the abstract and §7.4 say the evidence 'establishes a recurring artifact envelope' and 'engineering pressure.' The corpus signals (98.73% frontmatter, 23.2% path tokens, median 169 lines) show that SKILL.md files have a structured envelope and explicit references, but they cannot establish the C1–C3 conjunction for any unit. Given that Definition 1's membership requires all three conditions, the leap from 'structured SKILL.md files exist at scale' to 'Skillware exists at scale' should be explicitly qualified in the conclusion. This is a framing rather than a correctness issue, but it matters because readers may attribute more empirical support to the central claim than the evidence design warrants.
minor comments (5)
  1. [§3.3, Definition 1] The definition has a mild circularity risk: it defines Skillware in terms of 'primary Behavioral Artifact' and C1 operationalizes primacy. The paper's operational tests help, but it would be cleaner to state upfront that the definition is an analytical stipulation with an empirical operationalization, not a discovered natural kind. This is already implicit in §7.2, but a one-sentence clarification at Definition 1 would help.
  2. [§5.3.1] The quoted Facade rule ('1% chance... MUST invoke') is used as evidence of a declarative operation. It could also be read as an over-triggering prompt-injection risk. A brief note acknowledging this as a design tradeoff would prevent the reader from mistaking the example for a best practice.
  3. [§6.2–6.3] The distinction between Self-Evolution (candidate generation) and Collaborative Evolution (governance topology) is clear, but §6.3's 'Deployment and Field Adaptation Hypothesis' is explicitly prospective. This is fine, but the section placement between evolution theory and limitations makes it easy to over-read as a finding. Suggest labeling it as 'hypothesis' in the section header.
  4. [§4.1] The evidence supplement is described as containing the boundary review and technical review, but the paper does not state how many coders performed the classifications or how disagreements would be resolved. Even reporting the coding procedure in detail would help auditability and would partially address the inter-rater concern.
  5. [General] The paper uses 'skills-compatible agent' from the Agent Skills specification for C3. It would be helpful to clarify whether this is a formal compatibility certification or simply a working discovery/activation capability.

Circularity Check

1 steps flagged

No significant circularity in the central ontology; only a minor self-referential constructibility element in the design-pattern transfer evidence.

specific steps
  1. other [§5.3 (Design Pattern Transfer), §7.2 (Threats to Validity), ref. [42]]
    "We admit a transfer when seven elements are available: source intent, design forces, participant correspondence, consequences, implementation evidence, focused verification, and a misuse discriminator. ... Each example includes a real SKILL.md, participant map, mapping-specific artifact, structurally close misuse, and focused tests."

    The transfer-admission protocol is authored by the same team, and the 'constructive fixtures' in the authors' own repository [42] are built to satisfy that protocol. The evidence therefore demonstrates self-consistent constructibility rather than independent recurrence or external transferability. The paper limits the claim to implementability ('Constructive examples establish implementability and misuse discrimination while leaving prevalence and benefit unresolved'), so this is minor and not load-bearing for the main ontology claim.

full rationale

The central derivation is not circular. Definition 1 is an explicit proposed abstraction: Skillware is defined as a Skillware Unit around an Agent Skill or coherent Skill suite satisfying C1–C3. RQ1 is definitional, and the paper does not claim to derive Skillware from the corpus. The C1–C3 membership tests are operational criteria applied to declared units; the 15 boundary cases and 13 fixed-revision cases are classified under those criteria and the paper explicitly concedes that they are purposively selected and that no inter-rater reliability is estimated (§4.4, §7.2). That is an external-validity limitation, not a circular reduction. Corpus measurements (frontmatter frequency, path tokens, document lengths) are descriptive and the paper carefully bounds them ('This measurement supports one narrow conclusion...'). Independent empirical studies [22–26] supply reuse, maintenance, quality, verification, and runtime pressure, and these are external to the authors' own definitions. The only self-referential element is the pattern-transfer supplement [42], where the authors' own admission protocol and their own constructive fixtures are used to show that GoF-style patterns can be realized in Skillware. Because the paper restricts this to constructibility and does not use it as evidence for prevalence or for the existence of the artifact envelope, this is a minor self-reference rather than a forced derivation. Overall circularity is therefore low.

Axiom & Free-Parameter Ledger

0 free parameters · 4 axioms · 3 invented entities

The paper's central claim depends on: (1) the external Agent Skills specification accurately describing the ecosystem; (2) the stipulation that C1–C3 are the necessary conditions; (3) natural-language behavioral source being a legitimate primary carrier of behavior; and (4) the samples being sufficient to generalize. There are no fitted numerical parameters. The main invented conceptual entities are Skillware Unit, Behavioral Artifact, and Lifecycle Continuity.

axioms (4)
  • domain assumption The Agent Skills specification [6] and skills-compatible agent behavior [27] accurately reflect the dominant artifact envelope and activation model in the ecosystem.
    The ontology is built on this external specification; if it misdescribes the ecosystem, Skillware classifications inherit the error.
  • ad hoc to paper C1–C3 are necessary conditions for category membership (Definition 1, §3.3).
    The paper stipulates these conditions rather than deriving them from prior theory; another analyst could choose different necessary conditions.
  • domain assumption Natural-language behavioral source can legitimately be the primary carrier of reusable task behavior, with code/resources as optional support (§3.1).
    This is the central premise of the behavioral-primary condition; if natural-language instructions are merely config for code, the category collapses.
  • domain assumption The fixed-revision case set and SkillMD-138K corpus are sufficient to support the 'recurring artifact envelope' generalization (§4).
    The corpus is registry-heavy and the case set is purposive; the paper admits external-validity limits.
invented entities (3)
  • Skillware Unit independent evidence
    purpose: Independent software identity and lifecycle management for one Skill Artifact or a coherent skill suite.
    Operationalized by C1–C3 and observable in pinned public repositories; but it is a stipulated abstraction, not a measured object.
  • Behavioral Artifact independent evidence
    purpose: Addressable artifact whose primary source is reusable natural-language task behavior.
    Describes existing SKILL.md artifacts; the term is new but the referent is observable.
  • Lifecycle Continuity independent evidence
    purpose: Software-grade property recording whether the same unit identity persists through update, rollback, maintenance, and removal.
    It is a newly named property with an operational test (LC), and evidence could be read from repository histories and release records.

pith-pipeline@v1.3.0-alltime-deepseek · 17269 in / 13116 out tokens · 120827 ms · 2026-08-01T13:47:14.538946+00:00 · methodology

0 comments
read the original abstract

Agent Skills have become persistent behavioral artifacts across independent AI agent systems. They combine natural-language task specifications with metadata and optional references, scripts, assets, hooks, package manifests, tests, and companion interfaces. Existing studies explain how Skills are specified, executed, maintained, and evolved, but lack an ontology that defines these artifacts as independent software objects. This paper introduces Skillware as the software abstraction that extends software engineering to persistent Behavioral Artifacts in agent systems. A Skill Artifact specifies reusable task behavior; a Skillware Unit manages that artifact as software through an independent identity and lifecycle. A compatible Agent Host activates the unit for runtime interpretation. Three necessary conditions operationalize category membership: behavioral primacy, independent software identity, and an Agent Host execution relationship. Lifecycle Continuity records whether the same unit identity persists through update, maintenance, rollback, and removal as a separate software-grade property. Evidence combines the Agent Skills specification, a frozen corpus of 138,133 content-deduplicated SKILL.md records associated with 20,556 repository identifiers, independent empirical studies, 15 category-boundary cases, and 13 fixed-revision engineering implementations. The evidence establishes a recurring artifact envelope, separable software identities, documented or reconstructed activation paths, and lifecycle engineering pressure. Skillware provides the software ontology and engineering lifecycle through which agent capabilities can become identifiable, composable, and maintainable software artifacts with an explicit basis for future evolution. Public design-pattern and evidence materials are available at https://github.com/MetaInFLow/skillware-patterns.

Figures

Figures reproduced from arXiv: 2607.18970 by Haodi Fan, Zucong Lan.

Figure 1
Figure 1. Figure 1: Three computational substrates and their software abstractions. Code-, model-, and behavior-centric [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Skillware ontology. Managed software identity, behavioral source, activation environment, runtime [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Evidence design. Corpus, case, specification, and independent-study results retain distinct units and [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Atomic is the baseline configuration of a Skillware Unit. Six orthogonal and composable dimensions [PITH_FULL_IMAGE:figures/full_fig_p014_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Structural and lifecycle dimensions of Skillware. A unit’s implementation profile is a snapshot; [PITH_FULL_IMAGE:figures/full_fig_p018_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: A possible Skillware engineering lifecycle. The path organizes creation, adoption, evidence-driven [PITH_FULL_IMAGE:figures/full_fig_p019_6.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

48 extracted references · 2 canonical work pages

  1. [1]

    Learning representations by back-propagating errors,

    D. E. Rumelhart, G. E. Hinton, and R. J. Williams, “Learning representations by back-propagating errors,”Nature, vol. 323, pp. 533–536, 1986. [Online]. Available: https://doi.org/10.1038/323533a0

    doi:10.1038/323533a0 1986

  2. [2]

    Deep learning,

    Y . LeCun, Y . Bengio, and G. Hinton, “Deep learning,”Nature, vol. 521, pp. 436–444, 2015. [Online]. Available: https://doi.org/10.1038/nature14539

    doi:10.1038/nature14539 2015

  3. [3]

    On the opportunities and risks of foundation models,

    R. Bommasani, D. A. Hudson, E. Adeliet al., “On the opportunities and risks of foundation models,” arXiv preprint arXiv:2108.07258, 2021. [Online]. Available: https://arxiv.org/abs/2108.07258

    Pith/arXiv arXiv 2021

  4. [4]

    On the criteria to be used in decomposing systems into modules,

    D. L. Parnas, “On the criteria to be used in decomposing systems into modules,”Communications of the ACM, vol. 15, no. 12, pp. 1053–1058, 1972. [Online]. Available: https://doi.org/10.1145/361598.361623

    arXiv 1972

  5. [5]

    Szyperski, D

    C. Szyperski, D. Gruntz, and S. Murer,Component Software: Beyond Object-Oriented Programming, 2nd ed. Addison-Wesley Professional, 2002

    2002

  6. [6]

    Agent skills specification,

    Agent Skills, “Agent skills specification,” 2025. [Online]. Available: https://agentskills.io/specification

    2025

  7. [7]

    Build skills,

    OpenAI, “Build skills,” 2026. [Online]. Available: https://learn.chatgpt.com/docs/build-skills

    2026

  8. [8]

    Agent skills in the claude agent sdk,

    Anthropic, “Agent skills in the claude agent sdk,” 2026. [Online]. Available: https: //code.claude.com/docs/en/agent-sdk/skills

    2026

  9. [9]

    About agent skills,

    GitHub, “About agent skills,” 2026. [Online]. Available: https://docs.github.com/en/copilot/concepts/ agents/about-agent-skills 23

    2026

  10. [10]

    Working with skills in hermes agent,

    Nous Research, “Working with skills in hermes agent,” 2026. [Online]. Available: https: //github.com/NousResearch/hermes-agent/blob/main/website/docs/guides/work-with-skills.md

    2026

  11. [11]

    Superpowers,

    J. Vincent and contributors, “Superpowers,” GitHub repository, 2026, evaluated at fixed revision 896224c4b1879920ab573417e68fd51d2ccc9072. [Online]. Available: https://github.com/obra/ superpowers/tree/896224c4b1879920ab573417e68fd51d2ccc9072

    2026

  12. [12]

    Tan and contributors, “gstack,” GitHub repository, 2026, evaluated at fixed revision 11de390be1be6849eb9a15f91ff4922dd16c589a

    G. Tan and contributors, “gstack,” GitHub repository, 2026, evaluated at fixed revision 11de390be1be6849eb9a15f91ff4922dd16c589a. [Online]. Available: https://github.com/garrytan/ gstack/tree/11de390be1be6849eb9a15f91ff4922dd16c589a

    2026

  13. [13]

    [Online]

    ECC contributors, “ECC,” GitHub repository, 2026, evaluated at fixed revision 2bc924faf2f8e893bfe0af86b1931283693c30ae. [Online]. Available: https://github.com/affaan-m/ECC/ tree/2bc924faf2f8e893bfe0af86b1931283693c30ae

    2026

  14. [14]

    OpenMontage,

    calesthio, “OpenMontage,” GitHub repository, 2026, evaluated at fixed revision db91727598d08d40919d7d68a47864a5467bd448. [Online]. Available: https://github.com/calesthio/ OpenMontage/tree/db91727598d08d40919d7d68a47864a5467bd448

    2026

  15. [15]

    Prompt programming for large language models: Beyond the few-shot paradigm,

    L. Reynolds and K. McDonell, “Prompt programming for large language models: Beyond the few-shot paradigm,” inExtended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems, 2021, pp. 1–7. [Online]. Available: https://doi.org/10.1145/3411763.3451760

    arXiv 2021

  16. [16]

    Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing,

    P. Liu, W. Yuan, J. Fu, Z. Jiang, H. Hayashi, and G. Neubig, “Pre-train, prompt, and predict: A systematic survey of prompting methods in natural language processing,”ACM Computing Surveys, vol. 55, no. 9, pp. 1–35, 2023. [Online]. Available: https://doi.org/10.1145/3560815

    doi:10.1145/3560815 2023

  17. [17]

    Prompting is programming: A query language for large language models,

    L. Beurer-Kellner, M. Fischer, and M. Vechev, “Prompting is programming: A query language for large language models,”Proceedings of the ACM on Programming Languages, vol. 7, no. PLDI, pp. 1946–1969, 2023. [Online]. Available: https://doi.org/10.1145/3591300

    doi:10.1145/3591300 1946

  18. [18]

    ReAct: Synergizing reasoning and acting in language models,

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y . Cao, “ReAct: Synergizing reasoning and acting in language models,” inInternational Conference on Learning Representations, 2023. [Online]. Available: https://openreview.net/forum?id=WE_vluYUL-X

    2023

  19. [19]

    Agent skills for large language models: Architecture, acquisition, security, and the path forward,

    R. Xu and Y . Yan, “Agent skills for large language models: Architecture, acquisition, security, and the path forward,”arXiv preprint arXiv:2602.12430, 2026. [Online]. Available: https://arxiv.org/abs/2602.12430

    Pith/arXiv arXiv 2026

  20. [20]

    A comprehensive survey on agent skills: Taxonomy, techniques, and applications,

    Y . Zhou, W. Shu, Y . Su, W. Du, Y . Fang, and X. Lin, “A comprehensive survey on agent skills: Taxonomy, techniques, and applications,”arXiv preprint arXiv:2605.07358, 2026. [Online]. Available: https://arxiv.org/abs/2605.07358

    Pith/arXiv arXiv 2026

  21. [21]

    SkillOS: Learning skill curation for self-evolving agents,

    S. Ouyang, J. Yan, Y . Chen, R. Han, Z. Wanget al., “SkillOS: Learning skill curation for self-evolving agents,”arXiv preprint arXiv:2605.06614, 2026. [Online]. Available: https://arxiv.org/abs/2605.06614

    Pith/arXiv arXiv 2026

  22. [22]

    Skills are the new apps—now it’s time for skill OS,

    L. Chen, Z. Wang, W. Zheng, E. Feng, D. Du, Y . Xia, and H. Chen, “Skills are the new apps—now it’s time for skill OS,” Feb. 2026, preprints.org, version 1, posted February 13, 2026. [Online]. Available: https://doi.org/10.20944/preprints202602.1096.v1

    arXiv 2026

  23. [23]

    From registry to repository: How ai agent skills are written, adapted, and maintained,

    H. Gao, J. L. Lulla, H. Y . Lin, S. Baltes, C. Treude, and M. Zahedi, “From registry to repository: How ai agent skills are written, adapted, and maintained,”arXiv preprint arXiv:2607.00911, 2026. [Online]. Available: https://arxiv.org/abs/2607.00911 24

    Pith/arXiv arXiv 2026

  24. [24]

    From anatomy to smells: An empirical study of SKILL.md in agent skills,

    D. B. Hong, A. Imani, and I. Ahmed, “From anatomy to smells: An empirical study of SKILL.md in agent skills,”arXiv preprint arXiv:2607.01456, 2026. [Online]. Available: https://arxiv.org/abs/2607.01456

    Pith/arXiv arXiv 2026

  25. [25]

    Skills as verifiable artifacts: A trust schema and a biconditional correctness criterion for human-in-the-loop agent runtimes,

    A. Metere, “Skills as verifiable artifacts: A trust schema and a biconditional correctness criterion for human-in-the-loop agent runtimes,”arXiv preprint arXiv:2605.00424, 2026. [Online]. Available: https://arxiv.org/abs/2605.00424

    Pith/arXiv arXiv 2026

  26. [26]

    SkillFab: An agent-native skill production platform,

    A. Xu, Y . Cai, Y . Li, Z. Wang, Z. Zhang, J. Chen, R. Xu, and L. Wang, “SkillFab: An agent-native skill production platform,”arXiv preprint arXiv:2607.03780, 2026. [Online]. Available: https://arxiv.org/abs/2607.03780

    Pith/arXiv arXiv 2026

  27. [27]

    How to add skills support to your agent,

    Agent Skills, “How to add skills support to your agent,” 2025. [Online]. Available: https://agentskills.io/client-implementation/adding-skills-support

    2025

  28. [28]

    Architecture,

    Model Context Protocol, “Architecture,” 2025. [Online]. Available: https://modelcontextprotocol.io/ specification/2025-06-18/architecture

    2025

  29. [29]

    VS Code agent host architecture,

    Microsoft, “VS Code agent host architecture,” 2026. [Online]. Available: https://code.visualstudio.com/ docs/agents/concepts/agent-host

    2026

  30. [30]

    Build plugins,

    OpenAI, “Build plugins,” 2026. [Online]. Available: https://learn.chatgpt.com/docs/build-plugins

    2026

  31. [31]

    Agent runtime architecture,

    OpenClaw contributors, “Agent runtime architecture,” 2026. [Online]. Available: https: //docs.openclaw.ai/agent-runtime-architecture

    2026

  32. [32]

    Agent loop,

    ——, “Agent loop,” 2026. [Online]. Available: https://docs.openclaw.ai/agent-loop

    2026

  33. [33]

    FederatedSkill: Federated learning for agentic skill evolution,

    J. Yang, G. Yao, Y . Zhang, R. R. Kompella, G. Liu, and S. Chang, “FederatedSkill: Federated learning for agentic skill evolution,”arXiv preprint arXiv:2606.03143, 2026. [Online]. Available: https://arxiv.org/abs/2606.03143

    Pith/arXiv arXiv 2026

  34. [34]

    ISO/IEC/IEEE 12207:2017: Systems and software engineering—software life cycle processes,

    ISO/IEC/IEEE, “ISO/IEC/IEEE 12207:2017: Systems and software engineering—software life cycle processes,” 2017. [Online]. Available: https://www.iso.org/standard/63712.html

    2017

  35. [35]

    Programs, life cycles, and laws of software evolution,

    M. M. Lehman, “Programs, life cycles, and laws of software evolution,”Proceedings of the IEEE, vol. 68, no. 9, pp. 1060–1076, 1980. [Online]. Available: https://doi.org/10.1109/PROC.1980.11805

    arXiv 1980

  36. [36]

    Gamma, R

    E. Gamma, R. Helm, R. Johnson, and J. Vlissides,Design Patterns: Elements of Reusable Object- Oriented Software. Reading, MA: Addison-Wesley, 1994

    1994

  37. [37]

    Buschmann, R

    F. Buschmann, R. Meunier, H. Rohnert, P. Sommerlad, and M. Stal,Pattern-Oriented Software Archi- tecture, Volume 1: A System of Patterns. Chichester, UK: John Wiley & Sons, 1996

    1996

  38. [38]

    Evans,Domain-Driven Design: Tackling Complexity in the Heart of Software

    E. Evans,Domain-Driven Design: Tackling Complexity in the Heart of Software. Boston, MA: Addison-Wesley, 2003

    2003

  39. [39]

    An experimental study of natural language programming,

    A. W. Biermann, B. W. Ballard, and A. H. Sigmon, “An experimental study of natural language programming,”International Journal of Man-Machine Studies, vol. 18, no. 1, pp. 71–87, 1983. [Online]. Available: https://doi.org/10.1016/S0020-7373(83)80005-4

    work page doi:10.1016/s0020-7373(83)80005-4 1983

  40. [41]

    The ambivalent ontology of digital artifacts,

    J. Kallinikos, A. Aaltonen, and A. Marton, “The ambivalent ontology of digital artifacts,”MIS Quarterly, vol. 37, no. 2, pp. 357–370, 2013. [Online]. Available: https://doi.org/10.25300/MISQ/2013/37.2.02

    work page doi:10.25300/misq/2013/37.2.02 2013

  41. [42]

    Skillware patterns: Executable, bilingual pattern-transfer records for skillware,

    A. Fan and N. Lan, “Skillware patterns: Executable, bilingual pattern-transfer records for skillware,” GitHub repository, release v0.1-paper-v1, 2026, paper-bound release at commit cf328ba6ccaf3102cb3857bc5d88990bd161ba91. [Online]. Available: https://github.com/MetaInFLow/ skillware-patterns/releases/tag/v0.1-paper-v1

    2026

  42. [43]

    SkillMD-138K: A large public collection of agent skill files,

    FayeZC, “SkillMD-138K: A large public collection of agent skill files,” Hugging Face dataset, 2026, snapshot revision 0d73048abf2fb6ee91f6f9f5ac598d5be8d6bdd7. [Online]. Available: https://huggingface.co/datasets/FayeZC/SkillMD-138K

    2026

  43. [44]

    SkillOpt: Optimizing agent skills from execution evidence,

    Microsoft, “SkillOpt: Optimizing agent skills from execution evidence,” GitHub repository, 2026, evaluated at fixed revision b860a5cf88ce75e2bd02ca981ac21fb28cffba83. [Online]. Available: https://github.com/microsoft/SkillOpt/tree/b860a5cf88ce75e2bd02ca981ac21fb28cffba83

    2026

  44. [45]

    Gödel machines: Fully self-referential optimal universal self-improvers,

    J. Schmidhuber, “Gödel machines: Fully self-referential optimal universal self-improvers,” inArtificial General Intelligence, ser. Cognitive Technologies. Springer, 2007, pp. 199–226. [Online]. Available: https://doi.org/10.1007/978-3-540-68677-4_7

    doi:10.1007/978-3-540-68677-4_7 2007

  45. [46]

    Darwin gödel machine: Open-ended evolution of self-improving agents,

    J. Zhang, S. Hu, C. Lu, R. T. Lange, and J. Clune, “Darwin gödel machine: Open-ended evolution of self-improving agents,” inInternational Conference on Learning Representations, 2026. [Online]. Available: https://openreview.net/forum?id=pUpzQZTvGY

    2026

  46. [47]

    Two case studies of open source software development: Apache and mozilla,

    A. Mockus, R. T. Fielding, and J. D. Herbsleb, “Two case studies of open source software development: Apache and mozilla,”ACM Transactions on Software Engineering and Methodology, vol. 11, no. 3, pp. 309–346, 2002. [Online]. Available: https://doi.org/10.1145/567793.567795

    arXiv 2002

  47. [48]

    The emergence of governance in an open source community,

    S. O’Mahony and F. Ferraro, “The emergence of governance in an open source community,” Academy of Management Journal, vol. 50, no. 5, pp. 1079–1106, 2007. [Online]. Available: https://doi.org/10.5465/amj.2007.27169153 26

    arXiv 2007

  48. [2021]

    Available: https://arxiv.org/abs/2108.07732 25

    [Online]. Available: https://arxiv.org/abs/2108.07732 25

    Pith/arXiv arXiv