In modern AI engineering, "Skills" have become the dominant design pattern for extending LLM agent capabilities. Typically organized as folders containing an instruction sheet (SKILL.md) and a set of utility scripts (like Python or shell scripts), these skills teach agents how to perform complex, multi-step actions—such as downloading molecular databases or rendering videos.

However, using these skills programmatically is fragile. Developers are forced to write verbose custom boilerplate to trigger the scripts, manually manage command-line arguments, and hand-write execution flows. Moreover, running raw scripts on a host machine poses a massive security risk, as AI-generated code might execute dangerous side effects without sandboxing.

To solve this, we are thrilled to introduce Agentic Skill Blocks in INTHON v0.2. This new feature includes a compiler-level converter tool that dynamically translates unstructured skills into first-class, type-safe INTHON workflow functions and structured agent templates.

The Challenge: Unstructured Capabilities

Consider a typical biological research skill like alphafold-database-fetch-and-analyze. It contains scripts to download 3D protein structures and perform confidence analysis. Under traditional architectures, executing this requires parsing user prompts to find variables (like the UniProt ID), formatting a shell command string, and executing a subprocess.

This process lacks static verification, is highly error-prone, and exposes the system to command-injection vulnerabilities.

The INTHON Solution: Compiling Skills into Code

With the new INTHON release, you can compile any skill folder into type-safe language declarations using a single command: 

python -m inthon convert-skill path/to/skill_folder

This command triggers a multi-stage compilation pipeline:

  1. Metadata Extraction: The compiler parses the YAML frontmatter inside SKILL.md to extract the skill's name and goal description.
  2. AST-Based Argparse Parsing: The converter scans the skill's scripts/ directory. For Python scripts, it uses Python's Abstract Syntax Tree (ast) to analyze the code and dynamically discover parameters, defaults, and descriptions configured via argparse.ArgumentParser.
  3. Workflow Generation: It outputs a complete .inth workflow file containing dotted tool references (e.g. use tool skill.alphafold_fetch.fetch_structure), a structured agent block with security policies, and ready-to-run helper functions.
  4. JSON Schema Registry: It saves a JSON schema definition of the skill's interface into the workspace's .inthon/skills/ registry folder.

An Example Workflow

When you run convert-skill on a protein analysis skill, INTHON auto-generates the following code structure: 

// Auto-generated INTHON workflow for skill: alphafold-analysis
use tool skill.alphafold_analysis.fetch_structure
use tool skill.alphafold_analysis.analyze_plddt

agent AlphaFoldAgent {
    goal "Retrieve and analyze AlphaFold predicted structures for a protein."
    
    inputs {
        uniprot_id: str
        output_dir: str
    }
    outputs {
        result: str
    }
    
    policy {
        allow_network: true
        max_tool_calls: 10
    }
    
    plan {
        // Enforces type-safety on tool calls!
        let metadata_path = skill.alphafold_analysis.fetch_structure(uniprot_id: uniprot_id, output_dir: output_dir)
        let report = skill.alphafold_analysis.analyze_plddt(metadata_file: metadata_path)
        return report
    }
}

Dynamic Registration & Safety Sandbox

At runtime, the INTHON engine automatically loads all JSON schemas present in .inthon/skills/ and registers them in the ToolRegistry. When the INTHON program calls one of these skill tools, the runtime intercepts the invocation and executes it via a secure subprocess runner under the hood.

Crucially, because the tool is registered within INTHON's runtime, it respects the agent's capability-based policies. If the agent's policy blocks shell access or network communication, the tool call is instantly blocked, preventing malicious code traversal.

Summary

By treating prompt-level skills as standard, compileable modules, INTHON v0.2 makes agentic workflows reproducible, type-safe, and secure. Developers can now leverage complex scripts as simple function calls, unlocking a new level of productivity in AI-native engineering.