skillbot

An agentic bot powered by skills. Skillbot uses an LLM as its brain and Agent Skills as extensible capabilities, communicating via the A2A protocol.

Tech Stack

Category	Tool
Language	Python >= 3.13
Package Manager	uv
Build Backend	Hatchling
Linter & Formatter	Ruff
Type Checker	mypy (strict mode)
Testing	pytest
Commit Convention	Commitizen (Conventional Commits)
Git Hooks	pre-commit
CI/CD	GitHub Actions
Package Registry	PyPI
Agent Framework	LangGraph
LLM Provider	LangChain OpenAI
Agent Protocol	A2A SDK
Web Framework	FastAPI
CLI	Click
Containerization	Podman

Quick Start

Install skillbot from PyPI — no need to clone this repo.

Prerequisites

• Python >= 3.13
• Podman

1. Install skillbot

pip install skillbot

2. Initialize and configure

# macOS only: ensure the Podman machine is running
podman machine start

skillbot init

This creates ~/.skillbot/skillbot.config.json. Edit it to add your OpenAI API key under model-providers.openai.api-key.

The generated config points to the GHCR image by default:

{
  "container": {
    "enabled": true,
    "image": "ghcr.io/madarauchiha-314/skillbot-runtime:latest"
  }
}

3. Start skillbot

skillbot start --user-id my-user

The runtime container image is pulled automatically on first run if it isn't already available locally.

Architecture

Skillbot follows a structured agent loop:

START -> Find Relevant Skills -> Load Skills -> Load Memories
      -> Plan & Execute -> Reflect -> [Complete?]
          -> Yes: Create Memories -> END
          -> No:  Summarize -> loop back to Find Skills

The loop is implemented as a LangGraph StateGraph with persistent checkpointing via SQLite.

Local Development

Prerequisites

• Python >= 3.13
• uv
• Podman (skill scripts run inside containers)

Setup

Clone the repository and install dependencies:

git clone https://github.com/MadaraUchiha-314/skillbot.git
cd skillbot
uv sync --dev

This creates a .venv virtual environment and installs all runtime and dev dependencies.

Installing Pre-commit Hooks

Pre-commit hooks run linting, type checking, unit tests, and commit message validation automatically on every commit. Install them with:

uv run pre-commit install
uv run pre-commit install --hook-type commit-msg

You can also run all hooks manually against the entire codebase:

uv run pre-commit run --all-files

Common Commands

# Run unit tests
uv run pytest

# Run linter
uv run ruff check .

# Auto-fix lint issues
uv run ruff check . --fix

# Format code
uv run ruff format .

# Run type checker
uv run mypy skillbot

# Run all pre-commit hooks
uv run pre-commit run --all-files

Commit Messages

This project follows Conventional Commits. Commit messages are validated by Commitizen via a commit-msg hook. Use the format:

<type>(<optional scope>): <description>

[optional body]

[optional footer]

Examples:

feat: add user authentication
fix(parser): handle empty input gracefully
docs: update README with setup instructions

Project Structure

skillbot/
├── skillbot/
│   ├── agents/             # Agent implementations
│   │   ├── prompts/        # Prompt templates (.prompt.md)
│   │   └── agent_executor.py # Default agent executor
│   ├── channels/           # Communication channels
│   │   └── chat.py         # Shared A2A chat primitives
│   ├── cli/
│   │   ├── cli.py          # CLI commands (init, start)
│   │   └── tui.py          # Rich TUI components
│   ├── config/
│   │   └── config.py       # Config loading & dataclasses
│   ├── framework/
│   │   ├── agent.py        # AgentFramework (LangGraph graph)
│   │   └── state.py        # AgentState TypedDict
│   ├── memory/
│   │   └── memory.py       # User memory read/write
│   ├── server/
│   │   └── a2a_server.py   # A2A protocol server (FastAPI)
│   ├── container/
│   │   └── manager.py      # Podman container management
│   ├── skills/
│   │   └── loader.py       # Skill discovery & loading
│   └── tools/              # Tool infrastructure
├── tests/                  # Test suite
├── docs/                   # Documentation
├── .github/workflows/      # CI/CD pipelines
│   ├── pr.yml
│   └── release.yml
├── Containerfile              # Base image for skill execution
├── pyproject.toml
└── .pre-commit-config.yaml

Running the CLI Locally

During development, use uv run to invoke the CLI. This uses the editable install from .venv so your local code changes are reflected immediately without reinstalling.

1. Initialize configuration

# Initialize config in a local directory (avoids writing to ~/.skillbot)
uv run skillbot init --root-dir ./local-config

2. Configure your API key

Edit ./local-config/skillbot.config.json and add your OpenAI API key under model-providers.openai.api-key.

3. Build the container image

All skill scripts run inside Podman containers. For local development, build the image from the Containerfile instead of pulling from GHCR:

# Ensure the Podman machine is running (macOS only)
podman machine start

# Build the runtime image
podman build -t skillbot-runtime:latest -f Containerfile .

Then use --image to point skillbot at your local build:

uv run skillbot start --user-id dev --image skillbot-runtime:latest --config ./local-config/skillbot.config.json

The --image flag overrides the GHCR image from the config file for that run. No config edits needed.

Skillbot will refuse to start if container.enabled is set to false.

4. Start skillbot

# Start the server and open the chat interface
uv run skillbot start --user-id my-user --config ./local-config/skillbot.config.json

# Or start the server in the background only (no chat)
uv run skillbot start --background --config ./local-config/skillbot.config.json

If you prefer, you can also activate the virtualenv and run skillbot directly:

source .venv/bin/activate
skillbot --help

Hot-Reload (Development)

Use the --reload flag to automatically restart the server whenever you change code under skillbot/. This is the recommended way to run during development:

uv run skillbot start --config ./local-config/skillbot.config.json --reload

The server watches the skillbot/ directory for file changes and restarts automatically, so you don't need to manually stop and restart after each edit.

Skill Permissions and Dependencies

Skills can declare network access and dependencies in their SKILL.md frontmatter:

---
name: my-skill
description: Does something useful
permissions:
  network: true      # allow network access inside the container
dependencies:
  pip:
    - requests
  npm:
    - cheerio
---

The container is created with --network=none by default. If any configured skill declares permissions.network: true, the container gets network access via slirp4netns. Dependencies from all configured skills are installed inside the container at startup.