中文文档

A lightweight AI Agent Skills secure engine with built-in native system-level sandbox, zero dependencies, and local execution.

[]

┌────────────────────────────────────────────────────┐
│  Agent demo Layer (optional & demo)                │
│  Built-in chat, planning, memory, tools            │
│  Binary: skilllite (full)                          │
├────────────────────────────────────────────────────┤
│  Core Layer                                        │
│  Sandbox + security scan + skills management + MCP │
│  Binary: skilllite-sandbox (lightweight)           │
└────────────────────────────────────────────────────┘

Measured on macOS ARM64, release build. Sandbox RSS is dominated by the embedded Python process. The Agent layer adds memory only when chat, planning, or memory features are actively used.

Core principle: Scan before install, enforce after install. (先判毒，再落地；落地后防改)

Most sandbox solutions only provide runtime isolation — a single layer. SkillLite is the lightweight engine that defends across the entire skill lifecycle:

┌─────────────────────────────────────────────────┐
│ Layer 1 — Install-time Scanning                 │
│ ├─ Static rule scan (regex pattern matching)    │
│ ├─ LLM-assisted analysis (suspicious → confirm) │
│ └─ Supply-chain audit (PyPI / OSV vuln DB)      │
├─────────────────────────────────────────────────┤
│ Layer 2 — Pre-execution Authorization           │
│ ├─ Two-phase confirm (scan → user OK → run)     │
│ └─ Integrity check (hash tamper detection)      │
├─────────────────────────────────────────────────┤
│ Layer 3 — Runtime Sandbox                       │
│ ├─ OS-native isolation (Seatbelt / bwrap)       │
│ ├─ Process-exec whitelist (interpreter only)    │
│ ├─ Filesystem / network / IPC lockdown          │
│ └─ Resource limits (rlimit CPU/mem/fork/fsize)  │
└─────────────────────────────────────────────────┘

Other solutions focus on runtime isolation only. SkillLite adds install-time and pre-execution layers — three lines of defense in a single binary.

# Reproduce: run security comparison tests
cd benchmark && python3 security_vs.py

3-5x faster execution, 10x lower memory footprint vs Docker/SRT.

cd benchmark/
python benchmark_runner.py --compare-levels --compare-ipc -n 100 -c 10

# Cold start comparison
python benchmark_runner.py --cold-start --compare-ipc

# Full test: cold start + high concurrency
python benchmark_runner.py --cold-start --cold-iterations 20 --compare-levels --compare-ipc -o results.json

Claude/Anthropic's Claude Code Sandbox (Oct 2025) uses the same underlying tech (Seatbelt + bubblewrap) — SkillLite adds full-chain supply-chain defense on top.

pip install skilllite
skilllite init        # sandbox binary + .skills/ + download skills
skilllite list        # verify installation

Zero-config quick start (auto-detect LLM, setup skills, launch chat):

skilllite quickstart

from skilllite import chat

result = chat("Calculate 15 * 27", skills_dir=".skills")
print(result)

Or use the CLI: skilllite chat

cp .env.example .env   # Edit: BASE_URL, API_KEY, MODEL

Platform Support: macOS, Linux, and Windows (via WSL2 Bridge).

👉 View All Tutorials

from skilllite import run_skill

result = run_skill("./.skills/calculator", '{"operation": "add", "a": 15, "b": 27}')
print(result["text"])

skilllite add owner/repo                    # Add all skills from a GitHub repo
skilllite add owner/repo@skill-name         # Add a specific skill by name
skilllite add ./local-path                  # Add from local directory
skilllite list                              # List all installed skills
skilllite remove <skill-name>               # Remove an installed skill

pip install langchain-skilllite   # LangChain adapter

from langchain_skilllite import SkillLiteToolkit
from langgraph.prebuilt import create_react_agent

tools = SkillLiteToolkit.from_directory(
    "./skills",
    sandbox_level=3,  # 1=no sandbox, 2=sandbox only, 3=sandbox+scan
    confirmation_callback=lambda report, sid: input("Continue? [y/N]: ").lower() == 'y'
)
agent = create_react_agent(ChatOpenAI(model="gpt-4"), tools)

See 05. LlamaIndex Integration for LlamaIndex usage.

Each Skill is a directory with a SKILL.md:

my-skill/
├── SKILL.md           # Skill metadata (required)
├── scripts/main.py    # Entry script
├── references/        # Reference documents (optional)
└── assets/            # Resource files (optional)

---
name: my-skill
description: My custom Skill that does something useful.
license: MIT
compatibility: Requires Python 3.x with requests library, network access
metadata:
  author: your-name
  version: "1.0"
---

# My Skill

Detailed description of the Skill.

## Input Parameters

- `query`: Input query string (required)

## Output Format

Returns JSON result.

• skilllite (Rust binary) — Sandbox executor, CLI, Agent loop, MCP server — single binary
• python-sdk (pip install skilllite) — Thin bridge (~600 lines), zero runtime deps
• langchain-skilllite (pip install langchain-skilllite) — LangChain adapter

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

skilllite/
├── Cargo.toml              # [workspace] members
├── skilllite/              # Main binary (CLI entry point)
└── crates/
    ├── skilllite-assistant/ # Desktop app (Tauri + React)
    ├── skilllite-core/     # Config, skill metadata, path validation
    ├── skilllite-sandbox/  # Sandbox executor (independently deliverable)
    ├── skilllite-executor/ # Session, transcript, memory
    └── skilllite-agent/    # LLM Agent loop, tool extensions

pip install skilllite
skilllite init-opencode   # Auto-configure OpenCode MCP
opencode

cd crates/skilllite-assistant
npm install
npm run tauri dev    # dev mode (HMR)
npm run tauri build

MIT — See THIRD_PARTY_LICENSES.md for third-party details.

• Getting Started — Installation and quick start guide
• Environment Variables Reference — Complete env var documentation
• Architecture — Project architecture and design
• Contributing Guide — How to contribute