Skip to content

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

🕒 Published (v1): 2026-07-21 11:03 UTC · Source: Arxiv · link

Why this paper was selected

First software ontology treating agent skills as persistent artifacts with lifecycle and metadata

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

Skillware proposes a formal software ontology and engineering lifecycle for Agent Skills—the persistent natural-language behavioral artifacts that define reusable task behavior in AI agent systems like Claude Code, Codex, and GitHub Copilot. It defines the Skillware Unit as the independently managed software identity around a Skill Artifact and introduces three auditable membership conditions plus a Lifecycle Continuity grade. The work grounds its claims in a frozen corpus of 138,133 deduplicated SKILL.md records across 20,556 repositories and 15 boundary case reviews.

Problem

Agent Skills (SKILL.md directories bundling natural-language instructions, metadata, scripts, assets, hooks, tests, and companion interfaces) have proliferated as persistent behavioral artifacts across independent agent systems, yet no software ontology treats them as first-class software objects. Existing research addresses specification, execution, curation, quality, and governance in isolation, leaving no shared abstraction that assigns identity, a lifecycle boundary, and engineering accountability to the artifact itself.

Method

The paper defines Skillware through three layers:

  1. Ontology chain: Behavioral Source → Skill Artifact → Skillware Unit, activated by an Agent Host, interpreted by an Agent Runtime, producing an execution trace \(\pi\): $\(\pi = R_H(S, \tau, M, C, T, P, \sigma)\)$ where \(S\) is the Skillware Unit, \(H\) the Agent Host, \(\tau\) the task, \(M\) the model, \(C\) assembled context, \(T\) tools, \(P\) permission policy, and \(\sigma\) state.

  2. Three necessary membership conditions:

  3. C1 (Behavioral primacy): One Skill or coherent Skill suite carries and organizes the primary reusable task interface.
  4. C2 (Independent software identity): The unit is independently addressable—name, address, version, compatibility, provenance—apart from any Agent Host.

  5. C3 (Agent Host execution relationship): At least one compatible Host (Codex, Claude Code, GitHub Copilot, Hermes, OpenClaw) can discover, activate, load, and use the unit.

  6. Lifecycle Continuity (LC): A separately reported software-grade property recording whether the same unit identity survives update, maintenance, rollback, and removal.

Evidence spans: the Agent Skills specification, a frozen corpus of 138,133 content-deduplicated SKILL.md records (20,556 repository identifiers), independent empirical studies (Chen et al., Gao et al., Hong et al.), 15 category-boundary case reviews, and 13 fixed-revision engineering implementations.

Key Contributions

  • Skillware Ontology: A cross-project software abstraction linking Behavioral Source, Skill Artifact, Skillware Unit, Agent Host, Agent Runtime, situated performance, and task outcome as distinct analytical objects.
  • Skillware Engineering Lifecycle: An initial workflow through which behavioral artifacts acquire engineering structure (identity, version, provenance, compatibility) while remaining managed software units.
  • Identity-Preserving Evolution: A governed change model allowing human contributions, agent-generated proposals, and deployment evidence to produce new versions without losing software identity.
  • Operational membership tests (C1–C3 + LC): Auditable, falsifiable criteria applicable to positive, negative, and boundary cases in the existing Agent Skills ecosystem.
  • Boundary case taxonomy: 15 cases distinguishing Skillware from prompts, MCP servers, plugins, workflows, and Agent Hosts.

Results

  • Corpus size: 138,133 content-deduplicated SKILL.md records, 20,556 repository identifiers—establishing observable scale of the artifact class.
  • Gao et al. (cited as independent evidence): 18,463 registry Skills + 23,199 personal-use Skills from 5,876 GitHub repositories; 3,709 detected reuse links; modifications after reuse documented, demonstrating lifecycle engineering pressure.
  • Hong et al. (cited): 238 Skills analyzed for anatomy and measurable quality smells, confirming engineering-grade problems analogous to those in conventional software.
  • Chen et al. (cited): 97,755 Skills analyzed under a Skill OS framing, motivating a runtime abstraction compatible with the Skillware category.
  • 15 boundary cases classified under C1–C3 (positive, negative, compound); 13 fixed-revision implementations reviewed—no aggregate pass/fail count reported in the available text.

Limitations

  • The paper explicitly makes no population estimate of high-quality Skillware and no universal adoption claim.
  • No behavioral-equivalence claim across Agent Hosts—execution semantics are context-relative and non-deterministic.
  • Cross-Host compatibility (C3 tests one host; parity across hosts is a separate open question).
  • Conventions, compatibility contracts, evaluation methods, and lifecycle infrastructure remain unsettled in the ecosystem; the ontology is proposed against an emerging, not stable, substrate.
  • The LC property is assessed separately from membership—many corpus artifacts may satisfy C1–C3 without demonstrating software-grade lifecycle management.
  • Evidence is observational/corpus-based; no controlled experiments measuring whether Skillware framing improves engineering outcomes.

Relevance to Agentic AI / LLM Agents

Skillware directly addresses the missing software infrastructure layer for agent capability modularization: it provides the vocabulary (Unit, Host, Runtime, Lifecycle Continuity) needed to treat agent skills as first-class, composable, and maintainable software rather than ephemeral prompts. For researchers tracking agentic AI, this work is foundational for understanding how capabilities can be versioned, reused across agent systems, and governed at scale—questions that become critical as agent ecosystems (Claude Code, Codex, Copilot) converge on compatible skill loading paths. The Identity-Preserving Evolution model is directly relevant to multi-agent and federated settings where skills must be updated without breaking downstream consumers. It also frames the emerging tension between behavioral primacy (natural language) and tool/code primacy (MCP servers, plugins), which is a live design question in current agentic architectures.