skillware 0.5.8

A Python framework for modular, self-contained skill management for machines.

Skillware is an open-source framework and registry for modular, actionable Agent capabilities. It installs know-how for AI agents, or modular Skills (code, contract, and host guidance) decoupling capability from intelligence. In short, don't prompt your agents, equip them.

"I know Kung Fu." - Neo

Mission

Every new agent stack tends to reinvent tool schemas, system prompts, and safety rules. Skillware packages each capability as a self-contained bundle and adapts it to Gemini, Claude, OpenAI, Ollama, and other OpenAI-compatible hosts. For the full story and roadmap, see Vision.

A Skill in this framework provides everything a host agent needs to use a capability in a domain:

1. Contract: Constitution, safety boundaries, and typed I/O baked into the bundle.
2. Effect: Executable Python so agents run real work, not guess it.
3. Directive: System instructions and cognitive maps so any host uses the capability as intended.
4. Assurance: Offline tests that Effect honors Contract before a skill joins the registry.
5. Interface: Standardized tool schemas for any LLM or agent runtime.

Optional Corpus and Reference assets extend bundles when needed. Every bundled registry skill also ships Presentation (card.json) for catalog and UI metadata. Full reference: Introduction — Skill anatomy.

Skill library

Browse capabilities by category in Supported Agent Skill Categories, the Skill library, the documentation sitemap, or on our site ↗.

How it works

flowchart LR
    Registry[Registry] -->|Load| Loader[Loader]
    Loader -->|Adapt| AnyHost["Any Host"]

Install the registry once. Skillware loads a bundle, adapts it to your host's tool format, and your app runs the agent loop (Gemini, Claude, Ollama, custom scripts, …). See the Introduction for loader details, Agent loops for the execution pattern, and Skill chaining for multi-skill sessions (SkillContext, named chains:).

Architecture

This repository is organized into a core framework, a registry of skills, and documentation. Runnable provider scripts are indexed in examples/README.md.

Skillware/
├── docs/                       # Introduction, testing, category hubs (docs/skills/<category>/), usage guides (docs/usage/)
├── examples/                   # Provider reference scripts — usage demos, not pytest (see examples/README.md)
├── skills/                     # Skill Registry
│   └── category/               # Domain boundaries (e.g., finance)
│       └── skill_name/         # The Skill bundle
│           ├── manifest.yaml   # Contract: schema, constitution, issuer
│           ├── skill.py        # Effect: deterministic execution
│           ├── instructions.md # Directive: host guidance
│           ├── card.json       # Presentation: catalog / UI metadata
│           └── test_skill.py   # Assurance (required for registry skills)
├── skillware/                  # Core Framework Package
│   ├── cli.py                  # Command-line interface
│   ├── context.py              # SkillContext — multi-skill registry host context
│   ├── chains.py               # Named skill chain runner (run_chain, validate_chain)
│   └── core/
│       ├── base_skill.py       # Abstract Base Class for skills
│       ├── chains_config.py    # chains: YAML parsing
│       ├── env.py              # Environment Management
│       └── loader.py           # Universal Skill Loader and Model Adapter
├── templates/                  # Boilerplate templates for new skills
│   └── python_skill/           # Standard template with required files
└── tests/                      # Clone-repo tests (framework + optional maintainer skill tests)
    ├── test_*.py               # Framework tests (loader, CLI, issuer, …)
    └── skills/                 # Optional maintainer skill tests (edge cases)

Supported Agent Skill Categories

Category hubs live under docs/skills/<category>/. Full catalog: Skill library. Crawl map: documentation sitemap.

Quick Start

Requires Python 3.10 or newer (see requires-python in pyproject.toml).

1. Installation

You can install Skillware directly from PyPI:

pip install skillware

Or for development, clone the repository and install in editable mode:

git clone https://github.com/arpahls/skillware.git
cd skillware
pip install -e ".[dev,all]"

For documentation-only work, pip install -e ".[dev]" is enough. Skill and framework contributors should use [dev,all] to match CI (see TESTING.md and Install extras).

Note: Every skill has a dedicated pip extra (pip install "skillware[category_skill]"). The SkillLoader validates manifest.yaml on load and suggests the matching extra when packages are missing. See Install extras.

2. Verify your installation

skillware list
skillware paths

You should see a table of bundled registry skills and a paths summary confirming install and discovery. Bundled skills from pip install skillware are always available — an empty local skills/ folder does not disable them.

For path tiers, shadowing, config files, and the interactive menu, see CLI — paths & tiers, CLI — config, and Finding skills on disk. If skillware is not on your PATH, use python -m skillware list (CLI Reference).

3. Configuration

Skill paths (optional): copy .skillware.yaml.example to .skillware.yaml in your project root, or use the interactive menu (4 / paths) to persist project and external skill roots. Inspect merged settings with skillware config show. See CLI — config.

API keys: copy the environment template and add your keys.

Unix / macOS:

cp .env.example .env

Windows (PowerShell):

Copy-Item .env.example .env

Edit .env with agent keys (for example Gemini) and any keys your skills need. Agent keys power your LLM client; skill keys are declared per skill in the Skill library. Operator files (skillware addressbook init, skillware evm init) live under ~/.config/skillware/ and survive upgrades. See API keys for skills for .env setup, Address book operator config, and skillware doctor.

4. Usage Example (Gemini + Gmail)

pip install "skillware[office_gmail_handler,gemini]"

Set GOOGLE_API_KEY, GMAIL_ADDRESS, and GMAIL_APP_PASSWORD in .env (API keys). Then run the interactive loop:

python examples/gemini_gmail_minimal.py

Minimal wiring:

from skillware.core.env import load_env_file
from skillware.core.loader import SkillLoader
import google.genai as genai
from google.genai import types

load_env_file()
bundle = SkillLoader.load_skill("office/gmail_handler")
skill = bundle["class"]()
chat = genai.Client().chats.create(
    model="gemini-3.5-flash",
    config=types.GenerateContentConfig(
        tools=[SkillLoader.to_gemini_tool(bundle)],
        system_instruction=bundle["instructions"],
    ),
)
# Loop: chat.send_message(user) → skill.execute(tool args) → from_function_response

What happens: SkillLoader loads the bundle (manifest, instructions.md, Effect class) and adapts it to a Gemini tool → Gemini receives your message plus the skill directive and calls the tool → skill.execute() runs structured Gmail actions (resolve recipients from the address book, search/read inbox, preview or send mail) over your dedicated agent mailbox → results (status, previews, agent_hint) return to Gemini via from_function_response so the model can confirm with you before sends and continue the conversation.

More providers and patterns: usage guides.

Documentation

Contributing

Skills, docs, tests, and framework fixes are welcome. Start with Contributing, the glossary, Agent Native Workflow, and Testing. See the Agent Code of Conduct. Open PRs with the pull request template.

Comparison

Skillware differs from the Model Context Protocol (MCP), and Agent Skills (SKILL.md) in several ways:

• Model Agnostic: Native adapters for Gemini, Claude, Ollama, and OpenAI.
• Code-First: Skills are executable Python bundles, not just server specs.
• Runtime-Focused: Provides tools for the application, not just recipes for an IDE.

Read the full comparison here.

Stats

PyPI download counts measure install activity from public aggregators (including CI and mirrors), not unique users. Use the badge links above for charts and version breakdowns.

Citing

If you use Skillware in research or products, please cite it using CITATION.cff (GitHub Cite this repository) or the Zenodo concept DOI above. That DOI is stable across releases. For reproducibility, also record the Skillware version you used (PyPI or Git tag, for example 0.5.8).

Contact

For questions, suggestions, or contributions, please open an issue or reach out to us:

• Email: skillware-os@arpacorp.net
• Enterprise: skills@arpacorp.net — enterprise skills, chaining, and forward deployed engineering
• Security: security@arpacorp.net — report bugs, vulnerabilities, or other sensitive issues (see SECURITY.md)
• Issues: GitHub Issues

For skill-specific questions or reaching a skill's maintainer, check issuer and author details on the skill card, in the repo Skill Library, or on our website's skills catalog ↗.

Built & Maintained by ARPA Hellenic Logical Systems & the Community