Stop forcing LLMs to write disposable Python scripts on the fly. Here is how deterministic capability bundles slash token burn by 84.8%, cut costs by 97.3%, and let 8B local models outperform GPT-5 and Claude Sonnet 5.

Right now, the AI engineering world is trapped in a very expensive delusion: the prompt-driven execution paradigm.

We give an auto-regressive language model a massive markdown dump of API docs, tell it to dynamically synthesize Python or bash scripts on the fly, and pray that it respects security boundaries because we wrote "IMPORTANT: DO NOT DELETE PROD" in all caps in the system prompt.

When it works, it feels like magic. When it hits production, it's a disaster. You get Prompt Rot (switching models breaks all your tool shims), Quadratic Attention Tax (paying frontier rates to re-read static OpenAPI schemas on every turn), and the dreaded Context Poisoning Cliff—where an agent fails a script attempt, dumps a massive stack trace into its own context window, and spirals into terminal hallucination by attempt #8.

In a new paper from ARPA Hellenic Logical Systems ("Don't Prompt Your Agents. Equip Them: Skillware as a Modular Standard for Sovereign, Auditable, and Deterministic Capability Execution for Logical Systems", arXiv:2611.07652v1, we formalize the antidote: Capability Engineering.

The RPG Hotkey Analogy

Think about how skills work in an RPG like Morrowind or Diablo. When your character casts a spell or triggers an ability, you don't open a chat box and negotiate with the game engine to invent the physics of a fireball at runtime.

You press a hotkey. If the preconditions hold (you have the mana, you're outside a sanctuary town, targeting a valid hostile), the engine executes pre-compiled, deterministic logic and produces the exact same state transition every time.

Skillware brings this exact discipline to AI agents:

The Principle of Separation of Cognition and Capability: The model decides when to act and selects the parameters; the capability bundle governs how the action is executed. The assistant is a guest in this case, while the hard function does the work.

What is a Skillware Bundle?

Instead of loose SKILL.md files or brittle prompt wrappers, Skillware packages capabilities into self-contained, versioned, 5-role software bundles:

  1. Contract (manifest.yaml): Typed JSON Schema inputs/outputs, required env vars, cryptographic publisher identity, and an immutable Constitution (e.g., confirmed: true gates for destructive actions).
  2. Effect (skill.py): Pre-compiled, deterministic Python logic subclassing BaseSkill. Zero runtime code synthesis.
  3. Directive (instructions.md): Progressive disclosure guidance loaded Just-In-Time (JIT) only when needed.
  4. Assurance (test_skill.py): Hermetic offline pytest suites that verify the Effect honors the Contract in <100ms without calling a single LLM API.
  5. Corpus & Presentation (data/, card.json): Static offline datasets (like OFAC sanctions lists or statutory lexicons) bundled right next to the code for 100% air-gapped execution.

Universal In-Process Adapters (Zero IPC Latency)

Unlike MCP (which requires spinning up and supervising out-of-process client-server daemons over stdio/HTTP sockets), Skillware executes in-process in CPython in <1.2ms. Its universal interface morphisms (to_gemini_tool(), to_claude_tool(), to_openai_tool(), to_ollama_prompt()) automatically translate your manifest.yaml into any provider's native tool dialect on the fly.

from skillware.core import SkillLoader # 1. Load a verified, offline-tested capability bundle bundle = SkillLoader.load_skill("finance/wallet_screening") skill = bundle["class"]() # 2. Auto-transmute contract to host dialect (Gemini, Claude, OpenAI, Ollama) tools = [SkillLoader.to_gemini_tool(bundle)] # 3. Pre-flight AST schema validation + deterministic local execution try: result = skill.execute(dict(call.args)) except SkillwareParamValidationError as exc: result = {"error": f"Invalid arguments: {exc}"}

The SLM Parameter Paradox: 8B Local > Frontier Cloud

We evaluated 23 frontier and open-weight models across 368 benchmark conditions (SKILLWARE-BENCH), testing multi-step email handling, UK corporate registry resolution, on-chain sanctions screening, and adversarial prompt injection.

The headline finding? The SLM Parameter Paradox.

When you stop forcing models to write disposable code and restrict them strictly to semantic routing and schema parameter selection, 3B–8B local models equipped with Skillware consistently outperform unequipped frontier giants (including GPT-5 and Claude Sonnet 5):

  • 97.3% Cost Reduction: Dropping from $15.58 (Frontier LLM dynamically writing code) to $0.42 per 1,000 turns using a local 8B SLM + Skillware.
  • 84.0% Context Excision: Progressive JIT disclosure (mode="brief") compresses tool signatures to ~30 tokens, slashing total token burn by up to 84.8%.
  • Zero Parameter Corruption: Pre-flight JSON Schema validation drops parameter errors from 18.5% down to 0.0% and eliminates all 464 runtime script debugging loops.
  • 56.2% Lift for Open-Weight Models: Meta Llama 4 Maverick jumps from a 37.5% pass rate (vanilla) to 93.8% when equipped, while Qwen 3.8 Flash and Gemma 4 (31B) hit 100.0%.
  • 1.2ms Zero-Token Firewall: Instead of using a second LLM to audit incoming text for prompt injection (which doubles your cost and still gets jailbroken), Skillware uses a 3-stage deterministic normalization pipeline (stripping zero-width Unicode smuggling, Cyrillic/Greek homoglyphs, and hidden DOM spans) in 1.2ms with 0 tokens burned.

From Python Loops to Drones and Neural Interfaces

Why does sub-millisecond, in-process determinism matter beyond saving API budget? Because software agents are only Scale I.

Under ISO 13849 SIL-3 safety standards, physical fault mitigation in robotics and industrial Digital Twins must execute within 10ms, and high-frequency robotic/UAV control loops run at 500Hz (1–2ms). You cannot run a drone or a surgical neuroprosthetic over a 2.5-second cloud LLM loop or an out-of-process JSON-RPC socket.

By establishing a formal Clock-Domain Crossing (CDC) between slow cognitive deliberation (~1s) and sub-millisecond deterministic motor schemas (<1.2ms), Skillware lays the foundation for installing verified capabilities across autonomous IoT, embodied robotics, and eventually Brain-Computer Interfaces (BCIs).

Try It Out

The era of prompt engineering is closing; the era of Capability Engineering has begun. Stop renting disposable logic by the token.