Don't Prompt Your Agents. Equip Them: Skillware as a Modular Standard for Sovereign, Auditable, and Deterministic Capability Execution for Logical Systems

Vladimiros Peilivanidis

cs.AINov 5, 2026

Don't Prompt Your Agents. Equip Them: Skillware as a Modular Standard for Sovereign, Auditable, and Deterministic Capability Execution for Logical Systems

Authors: Vladimiros Peilivanidis

Organizations: ARPA Hellenic Logical Systems

Abstract

Current autonomous logical systems rely on a fragile assumption: that language models should dynamically write code, guess API payloads, and memorize operational constraints through prompt engineering. In practice, this burns massive context windows, inflates API bills, and produces brittle agents that fail unpredictably in production. In this work, we present Skillware, an open architectural framework and capability registry that formally separates what an agent wants to do from how that task is executed. Instead of prompting models with loose text instructions or markdown files baptized as 'skills', Skillware equips them with modular, versioned software capability bundles. Much like skill hotkeys in video games that execute deterministically under fixed world rules, each bundle combines a typed JSON input contract, deterministic Python code, task directives, bundled datasets, and automated unit tests. In-process adapters translate these capabilities into native tool declarations for any model, from frontier cloud APIs to local open-weight runtimes with zero network latency. Evaluating 23 frontier and open-weight models across 368 benchmark conditions, we show that small local models (3B to 8B parameters) equipped with Skillware consistently outperform unequipped frontier models on complex multi-step workflows. They cut token usage by up to 84.8%, slash inference costs by up to 97.3%, and eliminate parameter errors entirely. True agent reliability does not come from larger models or longer prompts, but from equipping logical systems with verified, deterministic software. Finally, we articulate the trajectory of capability bundles across an invariant continuum of information processing systems: from digital logical systems today, to IoT, drones, and embodied robotics tomorrow, establishing a foundation for auditable, real-time capability execution.

Figures & tables

Figure 1: The Skillware ecosystem architecture. Self-contained registry bundles decompose capability know-how into five first-class primitives (Contract, Effect, Directive, Assurance, Corpus), executed in-process with automated host adapter transmutation.

Figure 2: Anatomy of a concrete Skillware bundle ( finance/uk_companies_house ): Contract ( manifest.yaml ), Effect ( skill.py ), Directive ( instructions.md ), Assurance ( test_skill.py ), and Corpus ( data/ ) with zero external API dependencies.

Figure 3: Deterministic directed acyclic graph (DAG) chaining across specialized capabilities in the Tier 4 crucible ( pii_masker $\to$ gate $\to$ uk_companies_house $\to$ token_limiter ) with AURA attestation.

Figure 4: Protocol trace of an Office Mail Tier 2 invocation under Skillware-Bench : speculative script synthesis ( $28{,}041$ tokens, $41.8\,\text{s}$ , crashes) vs. Skillware deterministic schema execution ( $6{,}194$ tokens, $11.7\,\text{s}$ , zero crashes).

Figure 5: The Debugging Hazard Curve across 368 vanilla conditions in Skillware-Bench : recovery collapses after attempt 7 ( $50\%\to 0\%$ ) due to context poisoning. Skillware completely eliminates this curve by removing runtime script synthesis ( $464\to 0$ ).

Figure 6: Layer call survival flow across 1,000 emitted calls under Skillware-Bench : Skillware elevates clean first-pass completions from $71.2\%$ to $94.1\%$ and reduces hard aborts by $87.7\%$ ( $57\to 7$ ).

Figure 7: Run-to-run score variance across 40 seeded replays under Skillware-Bench : Skillware delivers a $5.1\times$ determinism tightening ( $\sigma=4.1\to 0.8$ ).

Figure 8: Resident context excision under Skillware JIT progressive disclosure: slashing prompt volume by $84.0\%$ and eliminating quadratic attention overhead ( $\mathcal{O}(L^{2})$ ).

Figure 9: Cost cascade per 1,000 tasks under Skillware-Bench : transitioning from cloud frontier models ($15.58) to equipped local SLMs ($0.42) yields a $97.3\%$ ( $37\times$ ) operating cost reduction. — Figure 9: Cost cascade per 1,000 tasks under Skillware-Bench : transitioning from cloud frontier models ( $15.58) to equipped local SLMs ($ 0.42) yields a $97.3\%$ ( $37\times$ ) operating cost reduction.

Figure 10: Per-call token ledger audit under Skillware-Bench : caching preambles and removing code repair loops yields a $70.6\%$ per-call token reduction ( $5{,}520\to 1{,}620$ ).

Figure 11: Completion tokens per task under Skillware-Bench : disposable boilerplate and replanning ( $984$ tokens) vs. actionable structured tool dispatch ( $556$ tokens).

Figure 12: Task pass rate under strict token budgets (736 conditions): Skillware reaches $82.3\%$ pass rate at $8{,}000$ tokens, surpassing unequipped models given an unconstrained $64{,}000$ budget ( $81.5\%$ )—an $8\times$ efficiency advantage.

Figure 13: The SLM Parameter Paradox across scale under Skillware-Bench : equipped compact models hold a $+32.0$ point lead over baseline, matching or surpassing unequipped frontier cloud LLMs (dashed line: $80.0$ frontier baseline).

Table 1: Representative benchmark standings evaluated under Skillware-Bench : equipping models elevates pass rates across all 8 evaluated architectures with up to $77.1\%$ token savings.

Table 2: Four-Axis Master Summary across 12 evaluated architectures under Skillware-Bench : average $51.4\%$ token reduction, $1.60\times$ speedup, and zero runtime script debugging ( $464\to 0$ ).

Figure 14: End-to-end latency anatomy across 500 median replay runs: unequipped monolithic baseline ( $14.2\,\text{s}$ , TTFT $1.9\,\text{s}$ ) vs. Skillware-equipped compact model ( $6.3\,\text{s}$ , TTFT $0.4\,\text{s}$ ), delivering a $55.6\%$ net speedup.

Figure 15: Empirical task latency CDF across 368 tasks under Skillware-Bench : equipping agents compresses median latency by $31.5\%$ ( $12.4\,\text{s}\to 8.5\,\text{s}$ ) and collapses P99 tail latency from $100.3\,\text{s}$ to $54.8\,\text{s}$ .

Figure 16: Pareto dominance across evaluated architectures: cost vs. pass rate under Skillware-Bench . Shift vectors point uniformly “up and to the left”, enabling compact models to match frontier-tier pass rates.

Figure 17: The “Equip Any Model” capability uplift across 14 architectures under Skillware-Bench : pass rate comparisons demonstrate disproportionate gains for compact open-weight and edge models (up to $+56.2\%$ ).

Figure 18: Epistemic calibration diagram across 10 confidence bins and 2,317 execution steps under Skillware-Bench : pre-flight contract verification forces calibration alignment, collapsing ECE from $14.5\%$ to $2.9\%$ .

Table 3: Cross-crucible token consumption across 23 models under 736 conditions in Skillware-Bench : Skillware compresses token expenditure by $17.2\%\text{--}73.6\%$ ( $51.4\%$ average savings, $1.59\text{M}$ tokens) and eliminates $464$ debugging loops.

Table 4: Adversarial telemetry across Tier 4 conditions (92 experimental setups): zero-token firewall gating and constitutional contracts elevate mean defense from $82.6\%$ to $92.4\%$ with zero unconfirmed actions and $1.72\times$ speedup.

Figure 19: Security radar profile across 23 models and 138 conditions under Skillware-Bench : mean defense elevates from

84.1\%

92.0\%

across six attack vectors via offline zero-token firewalling and typed contracts.

Figure 20: Constraint compliance across 368 conditions under Skillware-Bench : verified Skillware contracts cut failure rates across all vulnerability vectors, reducing total fleet failure rate from $18.5\%$ to $8.4\%$ (a 54.4% error reduction ).

Figure 21: The cross-scale capability continuum: scaling cognitive intent vs. deterministic execution across four time-scales ( $500\,\text{ms}\to 50\,\mu\text{s}$ ) from software to digital twins, robotics, and neuroprosthetics.

LLM Agents

Large language model agents use language models to plan, use tools, and act across multi-step tasks and environments.

See all 740 papers

Feb 24, 2026

SoK: Agentic Skills -- Beyond Tool Use in LLM Agents

Agentic systems increasingly rely on reusable procedural capabilities, a.k.a., agentic skills, to execute long-horizon workflows reliably. These capabilities are callable modules that package procedural knowledge with explicit applicability conditions, execution policies, termination criteria, and reusable interfaces. Unlike one-off plans or atomic tool calls, skills operate (and often do well) across tasks. This paper maps the skill layer across the full lifecycle (discovery, practice, distillation, storage, composition, evaluation, and update) and introduces two complementary taxonomies. The first is a system-level set of seven design patterns capturing how skills are packaged and executed in practice, from metadata-driven progressive disclosure and executable code skills to self-evolving libraries and marketplace distribution. The second is an orthogonal \textbf{representation

\times

scope} taxonomy describing what skills are (natural language, code, policy, hybrid) and what environments they operate over (web, OS, software engineering, robotics). We analyze the security and governance implications of skill-based agents, covering supply-chain risks, prompt injection via skill payloads, and trust-tiered execution, grounded by a case study of the ClawHavoc campaign in which nearly 1{,}200 malicious skills infiltrated a major agent marketplace, exfiltrating API keys, cryptocurrency wallets, and browser credentials at scale. We further survey deterministic evaluation approaches, anchored by recent benchmark evidence that curated skills can substantially improve agent success rates while self-generated skills may degrade them. We conclude with open challenges toward robust, verifiable, and certifiable skills for real-world autonomous agents.

Yanna Jiang, Delong Li, Haiyu Deng +4

University of Technology Sydney · CSIRO Data61

Agentic AI LLM Agent Skill Learning LLM Agent Security

Ask PDF

May 19, 2026

Formal Skill: Programmable Runtime Skills for Efficient and Accurate LLM Agents

Large Language Model (LLM) agents increasingly act inside real workspaces, where tools and skills determine whether model reasoning becomes reliable action. Existing skills remain largely informal: Markdown skills and instruction packs encode procedures as long natural-language documents, while function calling, Model Context Protocol (MCP) servers, and framework tools structure individual actions but usually leave workflow state, policy enforcement, and completion discipline outside the skill itself. We introduce Formal Skill, a runtime-native abstraction that represents reusable capability with JSON metadata and action schemas, reliable Python executors, hook-governed control logic, Formal Skill routing, and skill-local runtime state. By moving reusable procedure from repeated prompt text into executable state machines and hook policies, Formal Skill gives agents a token-efficient and enforceable control surface. We implement the abstraction in FairyClaw, an open-source event-driven runtime for executable, observable, and composable Formal Skills. On Harness-Bench, FairyClaw obtains highly competitive average scores while using substantially fewer tokens, with especially strong results on tasks that expose the role of Formal Skill.

Xi Zhang, Meijun Gao, Yuntian Zhao +6

Tool-Using Agents LLM Agents

Ask PDF

Sep 23, 2026

SkillGym: Internalizing Human Skills into LLMs for Real-World Problem Solving

Human-written agent skills encode rich workflows for real-world problem solving, but are typically used as external inference-time instructions rather than internalized as reusable model capabilities. We introduce SkillGym, a framework that transforms these skills into executable, verifiable training environments for large language model agents. Its skill-to-task pipeline instantiates concrete tasks, verifies outcomes with code-based checkers, and assesses empirical skill dependence through contrastive executions. We construct and release 2,756 environments across 12 categories and collect 8,364 successful trajectories from multiple models and harnesses, averaging 49 tool calls and over 60k logged text tokens. These resources support supervised fine-tuning on verified workflows and reinforcement learning with outcome-based rewards. Under Claude Code, supervised fine-tuning improves Qwen3.5-35B-A3B by 199 Elo on GDPval-AA v2, 19.10 percentage points on Terminal-Bench 2.1, and 28.13 and 12.38 points on SkillsBench v1.1 with and without skills, respectively. Our 35B SkillGym-Agent reaches 51.47% on skill-assisted SkillsBench, exceeding reported scores for Claude Sonnet 4.6, GPT-5.4 Mini, and DeepSeek V4 Pro. Without skills, it also surpasses skill-assisted bases under Codex and Claude Code, suggesting reusable procedural competence.

Zhilong Ge, Yuting Shao, Yutao Yang +6

School of Computer Science and Technology, East China Normal University, Shanghai · Shanghai AI Laboratory

Tool-Augmented Language Model Agents LLM Agent Skill Learning AI Agent Benchmarks LLM Agent Training RL for LLM Agents

Ask PDF

Abstract

LLM Agents

Explore similar work

SoK: Agentic Skills -- Beyond Tool Use in LLM Agents

Formal Skill: Programmable Runtime Skills for Efficient and Accurate LLM Agents

SkillGym: Internalizing Human Skills into LLMs for Real-World Problem Solving