DEV Community

Cover image for Skillware 0.5.9: Execution Geometry and Hardware Safety for AI Agents
ARPA Hellenic Logical Systems profile image Ross Peili
Ross Peili for ARPA Hellenic Logical Systems

Posted on

Skillware 0.5.9: Execution Geometry and Hardware Safety for AI Agents

#python #agents #ai #opensource

When building production autonomous agent loops, most developers treat tool use as a flat list of JSON schemas passed to an LLM completion API.

In simple prototypes, this works. In production multi-agent architectures, it breaks quickly:

  • Execution geometry is ambiguous: A single-shot calculator (atomic) is treated identically to an interactive multi-step checkout with approval gates (workflow) or an input sanitizer that must wrap another tool call (middleware).
  • Deployment tiers are hidden: Host agents have no way to distinguish a free, deterministic local regex scanner from an expensive paid cloud API with rate limits.
  • Physical substrate safety is missing: An LLM agent that can dispatch commands to an external physical actuator or robotics bus is treated with the same trust level as a pure software in-memory parser.

Skillware 0.5.9 tackles these challenges head-on by introducing Manifest v2 Universal Taxonomy, the air-gapped data_engineering/telemetry_normalizer skill for heterogeneous IoT and robotics kinematics, and a deterministic office/pdf_form_filler AcroForm engine.

1. What is Manifest v2 Universal Taxonomy?

Every skill bundle in Skillware is defined by a declarative manifest.yaml. In Manifest v2, skill capabilities are structured across four orthogonal dimensions:

id: data_engineering/telemetry_normalizer
name: telemetry_normalizer
version: 0.1.0
tier: core
shape: stream
target: software
tags:
  - telemetry
  - normalization
  - metrics
  - streaming
  - iot
  - sensors
Enter fullscreen mode Exit fullscreen mode

The Four Dimensions:

  1. Shape (Execution Geometry):

    • atomic: Single-step execution returning a deterministic output.
    • workflow: Multi-step flow featuring internal stages, preview diffs, and verification/confirmation gates.
    • middleware: Interceptor that inspects, sanitizes, or filters inputs/outputs before they reach models or downstream tools.
    • stream: Continuous or chunked event processor handling sensor feeds or timeseries telemetry.

  2. Tier (Deployment Model):

    • core: Open-source, local offline compute with zero external cloud dependencies.
    • cloud: Uses remote cloud APIs or hosted models.
    • enterprise: Requires enterprise infrastructure, specialized credentials, or KMS.

  3. Target (Execution Substrate):

    • software: Standard software environments.
    • hardware: Physical actuators, robotics, IoT fleets, or sensor buses.
    • bioware: Biosensors, neural telemetry, or brain-computer interfaces.

  4. Tags (Domain Keywords):

    • 2 to 10 unique, lowercase, domain-specific tags governed by category standards.

2. Dynamic Taxonomy Filtering & Hardware Safety

Host applications can configure a SkillContext to restrict exactly which skills an agent is permitted to discover and execute:

from skillware import SkillContext, SkillwareHardwareSafetyWarning

# Create a restricted runtime context for an untrusted agent
ctx = SkillContext(
    allowed_shapes=["atomic", "middleware"],
    allowed_tiers=["core"],
    allowed_targets=["software"],  # Prevents dispatching to physical hardware
    tags=["privacy", "compliance"],
)

# Discover skills matching the policy
available = ctx.list_skills()
print([s["id"] for s in available])
Enter fullscreen mode Exit fullscreen mode

If an agent attempts to execute a skill targeting physical hardware without explicit authorization:

# Hardware skills are gated by allow_hardware_execution=True
try:
    ctx.execute("robotics/chassis_controller", {"speed": 1.2})
except SkillwareHardwareSafetyWarning as e:
    print(f"Safety gate triggered: {e}")
Enter fullscreen mode Exit fullscreen mode

3. Sensor Telemetry Harmonization (data_engineering/telemetry_normalizer)

Robots, electric vehicle battery fleets, and smart building HVAC arrays generate noisy, heterogeneous telemetry in mixed units (Fahrenheit, psi, rpm). Foundation models frequently make subtle mathematical errors when asked to convert these units on the fly.

Skillware 0.5.9 ships data_engineering/telemetry_normalizer (v0.1.0):

  • Converts customary and mixed units into canonical SI/UCUM units (e.g. °F → °C, psi → Pa, rpm → rad/s).
  • Validates physical boundaries (e.g. negative Kelvin, out-of-spec voltage spikes).
  • Detects stuck sensors and dead-band anomalies.
  • Emits standard W3C SOSA/SSN JSON-LD semantic observations. 
from skillware.core.loader import SkillLoader

bundle = SkillLoader.load_skill("data_engineering/telemetry_normalizer")
skill = bundle["class"]()

result = skill.execute({
    "action": "normalize",
    "schema_profile": "smart_building_hvac",
    "raw_telemetry": {
        "zone_temp_f": 74.5,
        "duct_pressure_psi": 0.45,
        "co2_ppm": 850.0,
        "timestamp": "2026-10-20T08:15:00Z",
    },
})

print(result["status"])  # "valid"
print(result["normalized_observations"]["zone_temp_c"])  # 23.61
print(result["normalized_observations"]["duct_pressure_pa"])  # 3102.64
Enter fullscreen mode Exit fullscreen mode

4. Deterministic AcroForm PDF Engine (office/pdf_form_filler)

Asking LLMs to generate pixel coordinates or edit PDF streams directly leads to formatting corruptions.

Skillware 0.5.9 completely refactors office/pdf_form_filler (v0.1.2) into a host-agnostic, deterministic engine:

  1. inspect: Discovers all form fields, input types (text, checkbox, radio button), and export values.
  2. validate: Validates field values against form schemas and required constraints before writing.
  3. fill: Deterministically populates fields with human confirmation safety gates (confirmed: true) and permanent vector flattening via PyMuPDF (flatten: true).
  4. Dynamic XFA Guards: Fails closed with structured warnings when encountering dynamic XML Forms Architecture documents unsupported by standard AcroForm viewers. 
from skillware.core.loader import SkillLoader

bundle = SkillLoader.load_skill("office/pdf_form_filler")
skill = bundle["class"]()

# Step 1: Inspect form structure
form_meta = skill.execute({"action": "inspect", "pdf_path": "forms/nda.pdf"})
print(f"Form contains {len(form_meta['fields'])} fields.")

# Step 2: Fill and bake
result = skill.execute({
    "action": "fill",
    "pdf_path": "forms/nda.pdf",
    "field_values": {
        "Company_Name": "Acme Robotics",
        "Signer_Title": "VP Engineering",
        "Agree_Terms": True,
    },
    "flatten": True,
    "confirmed": True,
})
print(result["status"])  # "success"
Enter fullscreen mode Exit fullscreen mode

5. Compliance & Security Upgrades

Skillware 0.5.9 includes critical upgrades across enterprise compliance and security:

  • finance/wallet_screening (v1.1.0): Adds paginated Etherscan tokentx (ERC-20) and txlistinternal ingestion (up to 10,000 rows), screening token movements against the bundled OFAC SDN and TRM malicious index.
  • defi/token_security_scanner (v0.2.0): Introduces operator policy profiles returning explicit policy_action verdicts (allow, warn, block) and sequential batch scanning.
  • SPDX Licensing Standardization: Every core module and CLI tool now carries standard SPDX-License-Identifier: MIT and explicit copyright notices enforced by automated CI tests.

Getting Started

Upgrade or install the latest release:

pip install -U skillware
Enter fullscreen mode Exit fullscreen mode

Discover skills filtered by execution geometry:

skillware list --shape middleware
skillware list --tag telemetry
Enter fullscreen mode Exit fullscreen mode

Inspect any skill's taxonomy and constitution:

skillware info data_engineering/telemetry_normalizer
Enter fullscreen mode Exit fullscreen mode

Top comments (0)