Skillz - Self-Extending MCP Server

⚡ Quick Install

Get started in seconds with cargo

                    
                        🦀
                        Terminal
                    
                    # Install WASM target
rustup target add wasm32-wasip1

# Install Skillz
cargo install skillz

Then add to your editor's MCP config:

                        {
  "mcpServers": {
    "skillz": {
      "command": "skillz"
    }
  }
}
                    

Powerful Features

Everything you need to build dynamic AI tools

🦀

WASM Tools (Rust)

Compile Rust code to WebAssembly at runtime. Tools run in a secure sandbox with memory isolation and near-native performance.

📜

Script Tools (Any Language)

📦

Dependency Management

Automatic pip/npm dependency installation. Each tool gets its own isolated virtual environment that persists across restarts.

🔧

Sequential Creation

Build skills step-by-step with guided workflow: Design → Implement → Test → Finalize. Perfect for complex tools.

📡

Full MCP Protocol

Resources, roots, logging, progress updates, elicitation, and sampling support. Complete MCP compatibility.

💾

Persistent Tools

Tools, dependencies, and environments persist across restarts. Build your AI's toolbox over time.

🔒

Secure Sandbox

WASM tools run in isolated WebAssembly environment. Scripts execute as separate processes with filtered environment.

🚀

Auto-Publish CI

Every version bump automatically publishes to crates.io via GitHub Actions. Always up to date.

📖

Dynamic Guide

Built-in skillz://guide resource that automatically updates when new tools are added.

🛠️ Available Tools

Built-in tools for creating and managing your AI toolkit

Tool	Description	Type
build_tool	Compile Rust code → WASM tool. Automatically handles cargo build.	Core
register_script	Register script tool with optional dependencies (pip/npm packages).	Core
create_skill	Step-by-step skill creation: Design → Implement → Test → Finalize.	Core
call_tool	Execute any registered tool (WASM or script) by name.	Core
list_tools	List all available tools grouped by type.	Core
install_deps	Install dependencies for existing script tools.	New
delete_tool	Delete a tool and clean up its files and environments.	New
test_validate	Validate Rust code before building (syntax check).	Core
add_root	Add a workspace root for script file access.	Core
list_roots	List all workspace roots available to scripts.	Core

Simple to Use

Create tools with just a few lines of code

                    
                        🦀
                        Rust WASM Tool
                    
                

                    // Build a Fibonacci generator
build_tool(
  name: "fibonacci",
  code: "fn main() {
    let mut a = 0u64;
    let mut b = 1;
    for _ in 0..20 {
        print!(\"{} \", a);
        let t = a + b;
        a = b;
        b = t;
    }
}",
  description: "Generates Fibonacci numbers"
)
                

Architecture

Clean, modular design

┌─────────────────────────────────────────────────────────────────┐
│                  AI Assistant (Claude, Cursor, etc.)             │
└───────────────────────────────┬─────────────────────────────────┘
                                │ MCP Protocol
┌───────────────────────────────▼─────────────────────────────────┐
│                       Skillz MCP Server                          │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │   WASM Tools    │  │  Script Tools   │  │   Sequential    │  │
│  │  (Rust → WASM)  │  │ (Any Language)  │  │    Creation     │  │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │           Tool Registry & Dependency Manager              │  │
│  │    • Virtual environments (Python venv, Node modules)     │  │
│  │    • Auto-install pip/npm packages                        │  │
│  │    • Persistent tool storage                              │  │
│  └───────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

How It Works

From code to execution in seconds

Write Code

AI writes Rust code for WASM tools or scripts in any language (Python, Node.js, etc.). Specify dependencies if needed.

Compile & Register

WASM tools are compiled using cargo. Scripts are saved with appropriate interpreter. Dependencies are installed in isolated environments.

Execute

WASM runs in Wasmtime sandbox. Scripts execute via subprocess with JSON-RPC 2.0 protocol using their virtual environment.

Persist

Tools, dependencies, and environments are stored on disk. Available across server restarts. Build your AI's toolbox over time.

Let Your AI Build Its Own Tools