Kiln lets AI agents design, queue, and execute physical manufacturing jobs on real 3D printers with zero human intervention. It exposes printer control through both a CLI and the Model Context Protocol (MCP), making any MCP-compatible agent (OpenClaw, Claude, GPT, custom) a first-class operator of your print farm.

Positioning Clarification

Messaging clarification (February 24, 2026): We clarified wording to remove ambiguity and align with existing intent; no strategy change. Kiln is orchestration and agent infrastructure for fabrication workflows. Kiln does not operate a first-party decentralized manufacturing marketplace/network. Kiln integrates with third-party providers and external provider/network adapters as integrations are available.

Three ways to print

Mode	What it is	You need
🖨️ Your printer	Control OctoPrint, Moonraker, Bambu, or Prusa Link printers on your LAN — or remotely via Bambu Cloud	A 3D printer
🏭 Fulfillment centers	Outsource to Craftcloud (150+ services — no API key required). Kiln handles quoting, ordering, and tracking. More providers as integrations launch	Nothing — no printer required
🌐 External provider integrations	Route jobs through connected third-party provider/network adapters. Kiln does not operate a first-party network marketplace	Integrations as available

All three modes use the same MCP tools and CLI commands. An agent can seamlessly fall back from a busy local printer to a fulfillment center or connected external provider integration — all in one workflow.

Non-goals

Operating a first-party decentralized manufacturing marketplace/network
Replacing partner supply-side networks
Owning provider marketplaces instead of integrating with them
Acting as merchant of record for provider-routed manufacturing orders

Why Kiln?

One control plane, any printer — OctoPrint, Moonraker, Bambu Lab, Prusa Link. Manage a mixed fleet from one place.
AI-native — 353 MCP tools built for AI agents. Not a web UI with an API bolted on.
Prints don't fail silently — Cross-printer learning, automatic failure rerouting, preflight safety checks on every job.
Search → Slice → Print — Search and download 3D models from Thingiverse, MyMiniFactory, and Cults3D (search only), auto-slice with PrusaSlicer or OrcaSlicer, print — all from one agent conversation.
Safety at scale — 28 per-printer safety profiles, G-code validation, heater watchdog, tamper-proof audit logs. Enterprise adds encrypted G-code at rest with key rotation, lockable profiles, RBAC, SSO, fleet site grouping, per-project cost tracking, and PostgreSQL HA.

Architecture

graph TD
    A["🤖 AI Agent<br/><sub>Claude · GPT · Custom</sub>"]
    A -->|"CLI or MCP"| B["⚙️ Kiln<br/><sub>CLI + MCP Server</sub>"]

    B --> C["🖨️ Your Printers"]
    B --> F["🏭 Fulfillment"]
    B --> N["🌐 External Integrations<br/><sub>(third-party providers/networks, as available)</sub>"]
    B --> D["🛒 Marketplaces"]

    C --> E1["OctoPrint"]
    C --> E2["Moonraker"]
    C --> E3["Bambu"]
    C --> E4["Prusa Link"]
    C --> E5["Elegoo"]

    F --> F1["Craftcloud"]

    N --> N1["Third-Party Network Providers"]

    D --> I["MyMiniFactory"]
    D --> J["Cults3D"]
    D --> H["Thingiverse (deprecated)"]

    style A fill:#1a1a2e,stroke:#e94560,color:#fff
    style B fill:#16213e,stroke:#0f3460,color:#fff
    style C fill:#0f3460,stroke:#e94560,color:#fff
    style F fill:#0f3460,stroke:#27ae60,color:#fff
    style N fill:#0f3460,stroke:#f39c12,color:#fff
    style D fill:#0f3460,stroke:#533483,color:#fff
    style E1 fill:#2d2d44,stroke:#e94560,color:#fff
    style E2 fill:#2d2d44,stroke:#e94560,color:#fff
    style E3 fill:#2d2d44,stroke:#e94560,color:#fff
    style E4 fill:#2d2d44,stroke:#e94560,color:#fff
    style F1 fill:#2d2d44,stroke:#27ae60,color:#fff
    style F2 fill:#2d2d44,stroke:#27ae60,color:#fff
    style N1 fill:#2d2d44,stroke:#f39c12,color:#fff
    style H fill:#2d2d44,stroke:#533483,color:#fff
    style I fill:#2d2d44,stroke:#533483,color:#fff
    style J fill:#2d2d44,stroke:#533483,color:#fff

Kiln connects AI agents to OctoPrint, Moonraker (Klipper), Bambu Lab, Prusa Link, and Elegoo printers. Agents can also outsource jobs through Craftcloud fulfillment, and search models on MyMiniFactory, Cults3D (search only), and Thingiverse.

Related MCP server: Thingiverse MCP Server

Packages

This monorepo contains two packages:

Package	Description	Entry Point
kiln	CLI + MCP server for multi-printer control (OctoPrint, Moonraker, Bambu, Elegoo, Prusa Link)	`kiln` or `python -m kiln`
octoprint-cli	Lightweight standalone CLI for OctoPrint-only setups	`octoprint-cli`

Prerequisites

Before installing Kiln, you need your printer's LAN details (Ethernet or Wi-Fi):

Printer	Type	What You Need
Prusa MK4/XL/Mini+	`prusaconnect`	IP address + API key (both in Settings > Network > PrusaLink on the printer's LCD)
OctoPrint (any printer)	`octoprint`	OctoPrint URL + API key (Settings > API in OctoPrint web UI)
Klipper/Moonraker	`moonraker`	Moonraker URL (usually `http://<ip>:7125`)
Bambu Lab	`bambu`	IP address + LAN access code + serial number (all on the printer's LCD)
Elegoo (SDCP printers)	`elegoo`	IP address only — no authentication required. For Neptune 4/OrangeStorm Giga, use `moonraker` instead.

Kiln only needs IP reachability on your local LAN. Ethernet-only printers are fully supported.

Optional: Install PrusaSlicer or OrcaSlicer to slice STL files directly from Kiln (brew install --cask prusaslicer on macOS).

Optional: Install OpenSCAD for AI model generation via Gemini Deep Think (brew install openscad on macOS). Gemini Deep Think can generate 3D-printable models from text descriptions — OpenSCAD compiles the generated geometry to STL. Set KILN_GEMINI_API_KEY to enable.

Quick Start

Kiln CLI

# One-line install (clones repo + installs via pipx)
git clone https://github.com/codeofaxel/Kiln.git ~/.kiln/src && ~/.kiln/src/install.sh

# Or install manually from a local clone
pip install -e ./kiln

# Discover printers on your network (mDNS + HTTP probe)
kiln discover

# Add your printer (pick your type from the Prerequisites table)
kiln auth --name my-printer --host http://octopi.local --type octoprint --api-key YOUR_KEY
# Other printer types:
# kiln auth --name prusa --host http://192.168.1.100 --type prusaconnect --api-key YOUR_KEY
# kiln auth --name klipper --host http://192.168.1.100:7125 --type moonraker
# kiln auth --name bambu --host 192.168.1.100 --type bambu --access-code LAN_CODE --serial SERIAL
# If discovery misses your printer (common on WSL/VLANs), connect directly by IP with kiln auth.

# Check printer status
kiln status

# Upload and print a file
kiln upload model.gcode
kiln print model.gcode

# Slice an STL and print in one step
kiln slice model.stl --print-after

# Batch print multiple files
kiln print *.gcode --queue

# Monitor a running print
kiln wait

# Take a webcam snapshot
kiln snapshot --save photo.jpg

# View print history
kiln history --status completed

# All commands support --json for agent consumption
kiln status --json

Ethernet-Only Printers (No Wi-Fi)

Kiln works the same over Ethernet and Wi-Fi because it talks to printer APIs over LAN IP.

# 1. Connect printer and host to the same router/switch
# 2. Find printer IP from the printer UI or your router DHCP client list
# 3. Verify the printer endpoint responds:
curl http://<printer-ip>/api/version                    # OctoPrint
curl http://<printer-ip>:7125/server/info               # Moonraker
curl -H "X-Api-Key: YOUR_KEY" http://<printer-ip>/api/v1/status   # Prusa Link

# 4. Register directly by IP (no discovery required)
kiln auth --name my-printer --host http://<printer-ip> --type prusaconnect --api-key YOUR_KEY

Linux / WSL 2

Kiln runs natively on Linux and Ubuntu under WSL 2.

Option 1: pipx (recommended)

pipx installs Kiln into its own isolated environment and puts the kiln command on your PATH — works from any directory, no virtualenv to manage.

Note: The pip package name is kiln3d (not kiln). This matters for pipx uninstall, pip show, etc. The CLI command is still kiln.

# One-time: install pipx
sudo apt install pipx
pipx ensurepath   # adds ~/.local/bin to PATH (restart your shell after)

# Clone and install
git clone https://github.com/codeofaxel/Kiln.git
cd Kiln
pipx install ./kiln

# System dependencies (optional but recommended)
sudo apt install prusa-slicer   # Required for slicing STL → G-code
sudo apt install openscad        # Required only for text-to-3D generation

# Verify
kiln verify

Uninstall / Update

# Uninstall (package name is kiln3d, not kiln)
pipx uninstall kiln3d

# Update to latest version (if installed from a git clone)
cd Kiln
git pull
pipx install --force ./kiln

# Check what pipx has installed (useful for troubleshooting)
pipx list

Option 2: virtualenv

If you prefer a manual virtualenv:

python3 -m venv ~/.kiln-venv
source ~/.kiln-venv/bin/activate

git clone https://github.com/codeofaxel/Kiln.git
cd Kiln
pip install -e ./kiln            # includes all printer backends (OctoPrint, Moonraker, Bambu, Elegoo, Prusa Link)

kiln verify

Tip: Add source ~/.kiln-venv/bin/activate to your ~/.bashrc so the kiln command is always available when you open a terminal.

WSL 2 networking note: WSL 2 uses a virtual network (NAT), so mDNS printer discovery (kiln discover) will not find printers on your home network. Instead, connect directly by IP (same flow for Ethernet-only printers):

# 1. Find your printer's IP (check your router or the printer's LCD/web UI)
# 2. Verify connectivity from WSL
curl http://192.168.1.100:7125/server/info                              # Moonraker (Klipper)
curl http://192.168.1.100/api/version                                   # OctoPrint
curl -H "X-Api-Key: YOUR_KEY" http://192.168.1.100/api/v1/status       # Prusa Link
# Bambu printers use MQTT — just ensure port 8883 is reachable:
# nc -zv 192.168.1.100 8883

# 3. Register the printer with Kiln (pick your type)
kiln auth --name my-printer --host http://192.168.1.100:7125 --type moonraker
# kiln auth --name prusa --host http://192.168.1.100 --type prusaconnect --api-key YOUR_KEY
# kiln auth --name bambu --host 192.168.1.100 --type bambu --access-code LAN_CODE --serial SERIAL

# 4. Check printer status
kiln status

If PrusaSlicer is not in your PATH, set it explicitly:

export KILN_SLICER_PATH=/path/to/prusa-slicer

Bambu TLS security defaults: Kiln now uses certificate pinning (pin mode) for Bambu by default. On first successful connection, the printer certificate fingerprint is pinned (TOFU) in ~/.kiln/bambu_tls_pins.json. Advanced overrides:

# Strict CA/hostname validation (usually fails on stock self-signed printers)
export KILN_BAMBU_TLS_MODE=ca

# Legacy behavior (no certificate validation) - use only on trusted LANs
export KILN_BAMBU_TLS_MODE=insecure

# Optional explicit pin (SHA-256 fingerprint, hex with or without colons)
export KILN_BAMBU_TLS_FINGERPRINT=0123abcd...

Bambu webcam snapshots require ffmpeg for RTSP frame capture. Install it if you want vision monitoring on Bambu printers:

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

Without ffmpeg, Bambu printers will work normally but can_snapshot will be False and vision monitoring tools won't capture frames.

CLI Commands

kiln discover                              # Scan LAN for printers (mDNS + HTTP probe)
kiln auth --name N --host H --type T       # Save printer credentials
kiln doctor-prusa [--json]                 # Prusa Link diagnostics (endpoints + storage roots)
kiln status [--json]                       # Printer state + job progress
kiln files [--json]                        # List files on printer
kiln upload <file> [--json]                # Upload G-code file
kiln print <files>... [--queue] [--json]   # Start printing (supports batch + queue)
kiln cancel [--json]                       # Cancel current print
kiln pause [--json]                        # Pause current print
kiln resume [--json]                       # Resume paused print
kiln emergency-stop [--printer N|--all]    # Trip emergency stop latch (single printer or fleet)
kiln emergency-status [--printer N|--all]  # Inspect emergency latch/interlock state
kiln emergency-clear --ack-note "..."      # Acknowledge and clear emergency latch
kiln temp [--tool N] [--bed N] [--json]    # Get/set temperatures
kiln gcode <cmds>... [--json]              # Send raw G-code
kiln printers [--json]                     # List saved printers
kiln use <name>                            # Switch active printer
kiln remove <name>                         # Remove a saved printer
kiln preflight [--material MAT] [--json]   # Pre-print safety checks
kiln slice <file> [--print-after] [--json] # Slice STL/3MF to G-code (material-aware temps + smart supports)
kiln snapshot [--save PATH] [--json]       # Capture webcam snapshot
kiln wait [--timeout N] [--json]           # Wait for print to finish
kiln history [--status S] [--json]         # View past prints
kiln order materials [--json]              # List fulfillment materials
kiln order quote <file> -m MAT [--json]   # Get manufacturing quote
kiln order place <quote_id> [--json]      # Place a fulfillment order
kiln order status <order_id> [--json]     # Track order status
kiln order cancel <order_id> [--json]     # Cancel an order
kiln cost <file> [--material PLA] [--json]    # Estimate print cost
kiln material set|show|spools|add-spool       # Material tracking
kiln level [--status] [--trigger] [--json]    # Bed leveling triggers
kiln stream [--port 8081] [--stop] [--json]   # Webcam MJPEG proxy
kiln sync status|now|configure                # Cloud sync
kiln local-first [--apply] [--write-env]     # Local-first profile for edge/AGX deployments (backs up cloud sync config before disabling)
kiln ingest watch --dir ~/incoming [--auto-queue] [--once] [--state-file ~/.kiln/ingest_service/watch_state.json] [--min-stable-seconds N]
kiln ingest service install --dir ~/incoming [--auto-queue]  # Install opt-in background watcher config (detect-only by default)
kiln ingest service start|stop|status                           # Run and manage watcher as a background service
kiln plugins list|info                        # Plugin management
kiln generate "a phone stand" --provider meshy --json   # Generate 3D model from text (meshy/tripo3d/stability/gemini/openscad)
kiln generate-and-print "a phone stand" --provider gemini --material PLA   # One-command generate -> preview -> slice -> upload
kiln generate-status <job_id> --json                    # Check generation status
kiln generate-download <job_id> -o ./models --json      # Download generated model
kiln firmware status --json                # Check for firmware updates
kiln firmware update [--component klipper] # Apply firmware updates
kiln firmware rollback <component>         # Roll back firmware
kiln fleet route --material PLA [--file model.gcode] --json   # Mixed-fleet printer recommendation
kiln partner connect --name N --location L # Connect provider account/listing (integration preview)
kiln partner find --material PLA           # Find provider capacity by material/location
kiln partner submit URL --material PLA     # Submit job through a connected provider integration
kiln partner status <job_id>               # Check provider-managed job status
kiln partner list                          # List connected provider capacity listings
kiln partner sync <id> --available         # Sync provider capacity availability
# Legacy alias (deprecated in v0.2.0, removal target v0.4.0):
# kiln network register|find|submit|status|list|update
kiln setup                                 # Interactive printer setup wizard
kiln serve                                 # Start MCP server
kiln rest [--port 8420] [--tier full] [--auth-token TOKEN]  # Start REST API server
kiln agent [--model openai/gpt-4o]         # Interactive agent REPL (any LLM)

The REST API can be deployed to Fly.io for production use — see deploy.sh for one-command deployment.

Global option: --printer <name> to target a specific printer per-command.

MCP Server

# Start the MCP server (uses printer from ~/.kiln/config.yaml)
kiln serve

# Or override with environment variables
export KILN_PRINTER_HOST=http://192.168.1.100    # Your printer's IP or hostname
export KILN_PRINTER_API_KEY=your_api_key          # API key (OctoPrint/Moonraker/Prusa Link)
export KILN_PRINTER_TYPE=prusaconnect             # octoprint | moonraker | bambu | prusaconnect
kiln serve

Claude Code Integration

Add to your project's .claude/settings.json (or global ~/.claude/settings.json):

{
  "mcpServers": {
    "kiln": {
      "command": "kiln",
      "args": ["serve"]
    }
  }
}

Note: Claude Code uses your ~/.kiln/config.yaml for printer credentials (set up via kiln setup or kiln auth). No env vars needed if you've already configured a printer.

Claude Desktop Integration

Add to ~/.config/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "kiln": {
      "command": "python",
      "args": ["-m", "kiln", "serve"],
      "env": {
        "KILN_PRINTER_HOST": "http://192.168.1.100",
        "KILN_PRINTER_API_KEY": "your_key",
        "KILN_PRINTER_TYPE": "prusaconnect"
      }
    }
  }
}

Tip: Replace KILN_PRINTER_TYPE with your backend: octoprint, moonraker, bambu, or prusaconnect. Or skip env vars entirely if you've already run kiln setup.

Multi-Model Support (OpenRouter / Any LLM)

Kiln works with any LLM that supports OpenAI-compatible function calling — not just Claude.

# Interactive agent REPL with any model via OpenRouter
export KILN_OPENROUTER_KEY=sk-or-...
kiln agent --model openai/gpt-4o
kiln agent --model anthropic/claude-sonnet-4
kiln agent --model meta-llama/llama-3.1-70b-instruct --tier essential

# REST API mode — any HTTP client can call Kiln tools
export KILN_API_AUTH_TOKEN=CHANGE_ME_long_random_token
kiln rest --port 8420 --tier full
# POST http://localhost:8420/api/tools/printer_status
# GET  http://localhost:8420/api/tools

# Install with REST API support
pip install kiln3d[rest]

When binding REST to non-localhost addresses (for hosted deployments), set KILN_API_AUTH_TOKEN or pass --auth-token.

Tool tiers automatically match model capability: essential (15 tools) for smaller models, standard (46 tools) for mid-range, full (105 tools) for Claude/GPT-4/Gemini. All 345 tools are available via MCP (kiln serve).

OctoPrint CLI

# Install
pip install -e ./octoprint-cli

# Initialize config
octoprint-cli init --host http://octopi.local --api-key YOUR_KEY

# Use
octoprint-cli status
octoprint-cli files
octoprint-cli print myfile.gcode --confirm

MCP Tools (Selected)

The Kiln MCP server (kiln serve) exposes 345 tools to agents. Key tools are listed below — run kiln tools for the complete catalog.

Tool	Description
`printer_status`	Get printer state, temperatures, job progress
`printer_files`	List available G-code files
`upload_file`	Upload a local G-code file to the printer
`start_print`	Start printing a file
`cancel_print`	Cancel the active print job
`pause_print`	Pause the active print
`resume_print`	Resume a paused print
`emergency_stop`	Trigger emergency stop latch for one or all printers
`emergency_status`	Read emergency latch/interlock status
`clear_emergency_stop`	Acknowledge and clear emergency latch
`emergency_trip_input`	Secure external-input trigger (button/PLC bridge)
`set_temperature`	Set hotend and/or bed temperature
`preflight_check`	Run safety checks before printing
`send_gcode`	Send raw G-code commands
`validate_gcode`	Validate G-code without sending
`fleet_status`	Get status of all registered printers
`register_printer`	Add a printer to the fleet
`submit_job`	Submit a print job to the queue
`job_status`	Check status of a queued job
`queue_summary`	Overview of the job queue
`cancel_job`	Cancel a queued or running job
`recent_events`	Get recent events from the event bus
`kiln_health`	System health check (version, uptime, modules)
`register_webhook`	Register a webhook for event notifications
`list_webhooks`	List all registered webhooks
`delete_webhook`	Remove a webhook endpoint
`search_all_models`	Search MyMiniFactory, Cults3D (search only), and Thingiverse simultaneously
`marketplace_info`	Show connected marketplaces and setup hints
`search_models`	Search a single marketplace for 3D models
`model_details`	Get details for a marketplace model
`model_files`	List files for a marketplace model
`download_model`	Download a model file from a marketplace
`download_and_upload`	Download from any marketplace and upload to printer in one step
`browse_models`	Browse popular/newest/featured models
`list_model_categories`	List marketplace categories
`slice_model`	Slice an STL/3MF file to G-code
`find_slicer_tool`	Detect installed slicer (PrusaSlicer/OrcaSlicer)
`slice_and_print`	Slice a model then upload and print in one step (auto-detects AMS material, auto-injects brim/raft)
`slice_and_estimate`	Dry-run slice: time, filament, printability, and adhesion estimates without printing
`analyze_printability`	Deep printability analysis: overhangs, thin walls, bridging, adhesion, support volume (score 0-100)
`auto_orient_model`	Find optimal print orientation by scoring rotations for adhesion/supports/overhangs
`estimate_supports`	Estimate support volume and whether supports are needed
`recommend_adhesion_settings`	Recommend brim/raft settings based on geometry + material + printer type
`diagnose_print_failure_live`	Real-time failure diagnosis from printer state + model geometry + printer intelligence
`retry_print_with_fix`	Diagnose a failure, apply slicer overrides, re-slice, and reprint in one step
`get_active_material`	Get the currently loaded AMS filament (type, color, remaining)
`check_print_health`	Single-shot health check: temp drift, errors, progress assessment
`monitor_print`	Standardized print monitoring report (progress, temps, speed, camera snapshot, auto-comments)
`multi_copy_print`	Print multiple copies arranged on one plate (PrusaSlicer `--duplicate` or STL mesh duplication fallback)
`printer_snapshot`	Capture a webcam snapshot from the printer
`fulfillment_materials`	List materials from external print services (Craftcloud)
`fulfillment_quote`	Get a manufacturing quote for a 3D model
`fulfillment_order`	Place an order based on a quote
`fulfillment_order_status`	Track a fulfillment order
`fulfillment_cancel`	Cancel a fulfillment order
`estimate_cost`	Estimate print cost from G-code file
`list_materials`	List available material profiles
`set_material`	Set loaded material on a printer
`get_material`	Get loaded material for a printer
`check_material_match`	Verify material matches expected
`list_spools`	List spool inventory
`add_spool`	Add a spool to inventory
`remove_spool`	Remove a spool from inventory
`bed_level_status`	Get bed leveling status for a printer
`trigger_bed_level`	Trigger bed leveling on a printer
`set_leveling_policy`	Configure auto-leveling policy
`webcam_stream`	Start/stop/status MJPEG stream proxy
`cloud_sync_status`	Get cloud sync status
`cloud_sync_now`	Trigger immediate sync
`cloud_sync_configure`	Configure cloud sync settings
`list_plugins`	List installed plugins
`plugin_info`	Get details for a specific plugin
`await_print_completion`	Poll until a print job finishes (completed/failed/cancelled/timeout)
`compare_print_options`	Side-by-side local vs. fulfillment cost comparison
`analyze_print_failure`	Diagnose a failed print job with causes and recommendations
`validate_print_quality`	Post-print quality assessment with snapshot and event analysis
`generate_model`	Generate a 3D model from text (Meshy, Tripo3D, Stability AI, Gemini Deep Think, or OpenSCAD)
`generate_original_design`	Closed-loop original design generation: printer-aware prompt -> generate -> audit -> corrective retry
`generation_status`	Check the status of a model generation job
`download_generated_model`	Download a completed generated model with mesh validation
`await_generation`	Wait for a generation job to complete (polling)
`generate_and_print`	Full pipeline: generate -> validate -> slice -> upload -> print
`validate_generated_mesh`	Validate an STL/OBJ mesh for printing readiness
`firmware_status`	Check for available firmware updates on the printer
`update_firmware`	Start a firmware update (all or specific component)
`rollback_firmware`	Roll back a firmware component to its previous version
`print_history`	Get recent print history with success/failure tracking
`printer_stats`	Aggregate stats for a printer (total prints, success rate, avg duration)
`annotate_print`	Add notes to a completed print record
`save_agent_note`	Save a persistent note/preference that survives across sessions
`get_agent_context`	Retrieve all stored agent memory for context
`delete_agent_note`	Remove a stored note or preference
`list_safety_profiles`	List all bundled printer safety profiles (28 models)
`get_safety_profile`	Get temperature/feedrate/flow limits for a specific printer
`validate_gcode_safe`	Validate G-code against printer-specific safety limits
`list_slicer_profiles_tool`	List all bundled slicer profiles with recommended settings
`get_slicer_profile_tool`	Get full slicer settings (speeds, retraction, temps) for a printer
`get_printer_intelligence`	Firmware quirks, material compatibility, calibration guidance
`get_material_recommendation`	Recommended hotend/bed/fan settings for a material on a printer
`troubleshoot_printer`	Diagnose printer issues from known failure modes database
`list_print_pipelines`	List available pre-validated pipelines (quick_print, calibrate, benchmark)
`run_quick_print`	Full pipeline: slice → validate → upload → print in one shot
`run_calibrate`	Home → bed level → calibration guidance pipeline
`run_benchmark`	Slice → upload → stats report (manual start)
`monitor_print_vision`	Capture snapshot + printer state + phase hints; agent's vision model analyzes for defects
`watch_print`	Poll printer with periodic snapshots; returns batch for agent vision review
`record_print_outcome`	Record print quality outcome with safety-validated settings
`get_printer_insights`	Query cross-printer learning: success rates, failure breakdown, material stats
`suggest_printer_for_job`	Rank printers by historical success for a file/material combination
`recommend_settings`	Recommend print settings (temps, speed, slicer profile) from historical successes
`connect_provider_account`	Connect a local listing to a partner provider integration (as integrations launch)
`sync_provider_capacity`	Sync provider availability/capacity for a connected listing (as integrations launch)
`list_provider_capacity`	List capacity/listings from connected provider integrations (as integrations launch)
`find_provider_capacity`	Search connected provider capacity by material/location (as integrations launch)
`submit_provider_job`	Submit a print job through a connected provider integration (as integrations launch)
`provider_job_status`	Check status of a provider-managed job (as integrations launch)
`network_register_printer`	Legacy compatibility alias for `connect_provider_account` (deprecated v0.2.0; remove v0.4.0)
`network_update_printer`	Legacy compatibility alias for `sync_provider_capacity` (deprecated v0.2.0; remove v0.4.0)
`network_list_printers`	Legacy compatibility alias for `list_provider_capacity` (deprecated v0.2.0; remove v0.4.0)
`network_find_printers`	Legacy compatibility alias for `find_provider_capacity` (deprecated v0.2.0; remove v0.4.0)
`network_submit_job`	Legacy compatibility alias for `submit_provider_job` (deprecated v0.2.0; remove v0.4.0)
`network_job_status`	Legacy compatibility alias for `provider_job_status` (deprecated v0.2.0; remove v0.4.0)
`billing_status`	Get billing status, fee policy, and payment methods
`billing_summary`	Aggregated billing summary
`billing_history`	Recent billing charges and payment outcomes
`billing_setup_url`	Get URL to link a payment method (Stripe)
`safety_audit`	Audit safety compliance across jobs
`safety_settings`	Get current safety and auto-print settings
`safety_status`	Comprehensive safety status check
`delete_file`	Delete a file from the printer
`cache_model`	Cache a downloaded model locally for reuse
`search_cached_models`	Search cached models by name, source, or tags
`list_cached_models`	List all cached models with metadata
`get_cached_model`	Get details and local path for a cached model
`delete_cached_model`	Remove a model from the local cache
`backup_database`	Create a timestamped backup of the Kiln SQLite database
`verify_audit_integrity`	Verify integrity of the audit log (hash chain validation)
`clean_agent_memory`	Prune stale or expired agent memory entries
`list_trusted_printers`	List printers in the trust store with verification status
`trust_printer`	Add a printer to the trust store (fingerprint + TLS pinning)
`untrust_printer`	Remove a printer from the trust store
`pipeline_status`	Get real-time status of a running pipeline
`pipeline_pause`	Pause a running pipeline at the current step boundary
`pipeline_resume`	Resume a paused pipeline
`pipeline_abort`	Abort a running or paused pipeline
`pipeline_retry_step`	Retry the failed step in a pipeline
`consumer_onboarding`	Step-by-step guide for users without a 3D printer
`validate_shipping_address`	Validate and normalize a shipping address
`recommend_material`	Recommend material by use case (decorative, functional, outdoor, etc.)
`estimate_price`	Instant price estimate before requesting a full quote
`estimate_timeline`	Order-to-delivery timeline with per-stage breakdown
`fulfillment_compare_providers`	Side-by-side quotes from all fulfillment providers
`fulfillment_filter_materials`	Search/filter materials by technology, color, price
`fulfillment_batch_quote`	Quote multiple parts in one operation (assemblies)
`fulfillment_provider_health`	Health status of all fulfillment providers
`fulfillment_order_history`	View past orders for status review or reorder
`fulfillment_reorder`	Look up past order details for easy reordering
`fulfillment_insurance_options`	Shipping insurance/protection options with pricing
`supported_shipping_countries`	List countries supported for fulfillment shipping
`export_audit_trail`	Export audit trail as JSON/CSV with date range, tool, action, and session filters (Enterprise)
`lock_safety_profile`	Admin-lock a safety profile to prevent agent modifications (Enterprise)
`unlock_safety_profile`	Unlock a previously locked safety profile (Enterprise)
`manage_team_member`	Add, remove, or update team member roles (admin/engineer/operator) (Enterprise)
`printer_usage_summary`	Per-printer usage summary for overage billing (Enterprise)
`uptime_report`	Rolling uptime metrics (1h/24h/7d/30d) with SLA tracking (Enterprise)
`encryption_status`	Check G-code encryption status and key configuration (Enterprise)
`report_printer_overage`	Report printer overage billing details (Enterprise)
`configure_sso`	Configure SSO provider (OIDC/SAML) with IdP settings (Enterprise)
`sso_login_url`	Generate SSO login URL for OIDC/SAML authentication (Enterprise)
`sso_exchange_code`	Exchange authorization code for session token via SSO (Enterprise)
`sso_status`	Check SSO configuration and provider status (Enterprise)
`rotate_encryption_key`	Re-encrypt all G-code files with a new key (Enterprise)
`database_status`	Check database backend (SQLite/PostgreSQL) health and config (Enterprise)
`list_fleet_sites`	List all physical sites in the fleet with printer counts (Enterprise)
`fleet_status_by_site`	Fleet status grouped by physical site (Enterprise)
`update_printer_site`	Assign a printer to a physical site/location (Enterprise)
`create_project`	Create a client project for cost allocation (Enterprise)
`log_project_cost`	Log a cost entry (material, printer time, labor, etc.) against a project (Enterprise)
`project_cost_summary`	Aggregate cost summary with budget tracking for a project (Enterprise)
`client_cost_report`	Cross-project cost report for a client (Enterprise)
`get_design_brief`	Complete design brief for a functional requirement (materials, patterns, constraints)
`build_generation_prompt`	Turn a natural-language idea into a printer-aware, design-constrained generation prompt
`audit_original_design`	Harsh original-design audit: brief + validation + printability + diagnostics + feedback
`get_material_design_profile`	Full engineering properties for a 3D printing material
`list_design_materials`	List all available materials with summary properties
`recommend_design_material`	Recommend the best material for a design task
`estimate_structural_load`	Estimate safe structural load for a cantilevered section
`check_material_environment`	Check whether a material is compatible with an environment
`get_printer_design_capabilities`	Get the design capability profile for a printer
`list_printer_design_profiles`	List all known printer design capability profiles
`get_design_pattern_info`	Get detailed design rules for a functional pattern (snap-fit, living hinge, etc.)
`list_design_patterns_catalog`	List all available design patterns with descriptions
`find_design_patterns`	Find design patterns that apply to a specific use case
`match_design_requirements`	Identify which functional requirements apply to a design task
`validate_design_for_requirements`	Validate a 3D model against functional design requirements
`troubleshoot_print_issue`	Diagnose a 3D printing problem by material and symptom
`check_printer_material_compatibility`	Check if a specific printer can handle a material
`get_post_processing_guide`	Post-processing techniques for finishing a 3D printed part
`check_multi_material_pairing`	Check if two materials can be co-printed in dual extrusion
`get_print_diagnostic`	Comprehensive print diagnostic combining multiple knowledge sources
`get_construction_design_brief`	Design brief for construction-scale 3D printing
`get_construction_material_profile`	Engineering properties for a construction printing material
`list_construction_materials_catalog`	List all available construction printing materials
`get_construction_pattern_info`	Design rules for a construction printing pattern
`list_construction_patterns_catalog`	List all available construction printing patterns
`get_construction_building_requirement`	Detailed building program requirements
`list_construction_building_requirements`	List all available building program requirement profiles
`match_construction_building_requirements`	Match a building description to known program requirements

Provider Tool Deprecation Timeline

Canonical provider integration tools: connect_provider_account, sync_provider_capacity, list_provider_capacity, find_provider_capacity, submit_provider_job, provider_job_status.
Legacy aliases (network_*) remain available for compatibility only.
network_* deprecated in v0.2.0.
Removal target for network_*: v0.4.0.
Clarification only: existing intent unchanged, no strategy change.

Supported Printers

Backend	Status	Printers
OctoPrint	Stable	Any OctoPrint-connected printer (Prusa, Ender, custom)
Moonraker	Stable	Klipper-based printers (Voron, Ratrig, etc.)
Bambu	Stable	Bambu Lab X1C, P1S, A1 (via LAN MQTT)
Prusa Link	Stable	Prusa MK4, XL, Mini+ (local REST API — type: `prusaconnect`)
Elegoo	Stable	Centauri Carbon, Saturn, Mars series (via LAN WebSocket/SDCP). Neptune 4/OrangeStorm Giga use Moonraker.

MCP Resources

The server also exposes read-only resources that agents can use for context:

Resource URI	Description
`kiln://status`	System-wide snapshot (printers, queue, events)
`kiln://printers`	Fleet listing with idle printers
`kiln://printers/{name}`	Detailed status for a specific printer
`kiln://queue`	Job queue summary and recent jobs
`kiln://queue/{job_id}`	Detail for a specific job
`kiln://events`	Recent events (last 50)

Modules

Module	Description
`server.py`	MCP server with tools, resources, and subsystem wiring
`printers/`	Printer adapter abstraction (OctoPrint, Moonraker, Bambu, Elegoo, Prusa Link)
`marketplaces/`	Model marketplace adapters (MyMiniFactory, Cults3D, Thingiverse)
`slicer.py`	Slicer integration (PrusaSlicer, OrcaSlicer) with auto-detection
`registry.py`	Fleet registry for multi-printer management
`queue.py`	Priority job queue with status tracking
`scheduler.py`	Background job dispatcher with history-based smart routing
`events.py`	Pub/sub event bus with history
`persistence.py`	SQLite storage for jobs, events, and settings
`webhooks.py`	Event-driven webhook delivery with HMAC signing
`auth.py`	Optional API key authentication with scope-based access
`billing.py`	Fee tracking for fulfillment and network-routed jobs
`discovery.py`	Network printer discovery (mDNS + HTTP probe)
`generation/`	Text-to-model generation providers (Meshy, Tripo3D, Stability AI, Gemini Deep Think, OpenSCAD) with auto-discovery, mesh validation, and printability analysis
`consumer.py`	Consumer workflow for non-printer users (address validation, material recommendations, timeline/price estimation, onboarding)
`fulfillment/`	External manufacturing service adapters (Craftcloud) with intelligence layer (provider health, multi-provider comparison, batch quoting, retry/fallback, order history, shipping insurance)
`cost_estimator.py`	Print cost estimation from G-code analysis
`materials.py`	Multi-material and spool tracking
`bed_leveling.py`	Automated bed leveling trigger system
`streaming.py`	MJPEG webcam streaming proxy
`cloud_sync.py`	Cloud sync for printer configs and job history
`plugins.py`	Plugin system with entry-point discovery
`gcode.py`	G-code safety validator with per-printer limits
`safety_profiles.py`	Bundled safety database (30 printer models, temps/feedrates/flow)
`slicer_profiles.py`	Bundled slicer profiles (auto-generates .ini files per printer)
`printer_intelligence.py`	Printer knowledge base (firmware quirks, materials, failure modes)
`pipelines.py`	Pre-validated print pipelines (quick_print, calibrate, benchmark)
`tool_schema.py`	OpenAI function-calling schema converter (MCP → OpenAI format)
`tool_tiers.py`	Tool tier definitions (essential/standard/full) for model capability matching
`agent_loop.py`	Generic agent loop for any OpenAI-compatible API (OpenRouter, direct, etc.)
`openrouter.py`	OpenRouter integration with model catalog and auto-tier detection
`rest_api.py`	REST API wrapper (FastAPI) exposing all MCP tools as HTTP endpoints
`data/`	Bundled JSON databases (safety profiles, slicer profiles, printer intelligence)
`payments/`	Payment processing (Stripe, Circle USDC, crypto rails)
`gateway/`	External-provider integration gateway (as integrations launch)
`heater_watchdog.py`	Auto-cooldown watchdog for idle heaters
`licensing.py`	License tier management (Free/Pro/Business/Enterprise, offline-first)
`sso.py`	SSO authentication (OIDC/SAML) with IdP role mapping and email domain allowlists
`gcode_encryption.py`	G-code encryption at rest (Fernet/PBKDF2 via KILN_ENCRYPTION_KEY)
`printer_billing.py`	Per-printer overage billing (20 included, $15/mo each additional)
`teams.py`	Team seat management with RBAC (admin/engineer/operator roles)
`uptime.py`	Rolling uptime health monitoring (1h/24h/7d/30d windows, 99.9% SLA target)
`project_costs.py`	Per-project cost tracking for manufacturing bureaus (material, labor, printer time, fulfillment)
`wallets.py`	Crypto wallet configuration (Solana/Ethereum for donations and fees)
`cli/`	Click CLI with 114 commands and JSON output
`deploy/`	Kubernetes manifests and Helm chart for on-prem Enterprise deployment

Authentication (Optional)

Kiln supports optional API key authentication for MCP tools. Disabled by default.

# Enable auth
export KILN_AUTH_ENABLED=1
export KILN_AUTH_KEY=your_secret_key

# Clients provide their key via
export KILN_MCP_AUTH_TOKEN=your_secret_key

Scopes: read, write, admin. Read-only tools (status, list) never require auth.

Webhooks

register_webhook(url="https://example.com/hook", events=["job.completed", "print.failed"])

Payloads are signed with HMAC-SHA256 when a secret is provided.

Security defaults:

Webhook redirects are blocked by default (KILN_WEBHOOK_ALLOW_REDIRECTS=0).
If redirects are enabled, each hop is SSRF-validated and HTTPS→HTTP downgrade is blocked.

Printer Discovery

Kiln can automatically find printers on your local network:

kiln discover

Discovery uses mDNS/Bonjour and HTTP subnet probing to find OctoPrint, Moonraker, Bambu, and Prusa Link printers. If discovery returns no results, register printers directly by IP with kiln auth (works for both Ethernet and Wi-Fi LAN setups).

Third-Party Plugins

Third-party entry-point plugins are default-deny in production (KILN_PLUGIN_POLICY=strict). Allow only specific plugins with:

export KILN_ALLOWED_PLUGINS=my_plugin,other_plugin

For temporary migration compatibility, permissive mode can be enabled:

export KILN_PLUGIN_POLICY=permissive

Model Marketplaces

Kiln includes adapters for discovering and downloading 3D models from popular marketplaces:

Marketplace	Status	Features
MyMiniFactory	Stable	Search, details, download. Primary marketplace — recommended for new integrations.
Cults3D	Stable	Search, details (metadata-only — no direct download; provides URLs for manual download)
Thingiverse	Deprecated	Search, browse, download, categories. Acquired by MyMiniFactory (Feb 2026). API may be sunset; prefer MyMiniFactory.

Marketplace features require free API keys. Get yours and set the environment variables:

Marketplace	Get your API key	Environment variable(s)
MyMiniFactory (recommended)	Developer Settings	`KILN_MMF_API_KEY`
Cults3D (search only)	API Keys	`KILN_CULTS3D_USERNAME` + `KILN_CULTS3D_API_KEY`
Thingiverse (deprecated)	Create App	`KILN_THINGIVERSE_TOKEN`

export KILN_MMF_API_KEY=your_key               # MyMiniFactory (recommended)
export KILN_CULTS3D_USERNAME=your_username      # Cults3D
export KILN_CULTS3D_API_KEY=your_key            # Cults3D
export KILN_THINGIVERSE_TOKEN=your_token       # Thingiverse (deprecated)

All configured marketplaces are searched simultaneously via search_all_models. Agents can inspect details, download files, and upload directly to a printer — enabling a full design-to-print workflow without human intervention.

AI Model Generation

Kiln's universal generation adapter auto-discovers text-to-3D providers from environment variables. Set any of the following and the provider is available instantly:

export KILN_MESHY_API_KEY=your_key         # Meshy — cloud text-to-3D
export KILN_TRIPO3D_API_KEY=your_key       # Tripo3D — high-quality cloud text-to-3D
export KILN_STABILITY_API_KEY=your_key     # Stability AI — synchronous 3D generation
export KILN_GEMINI_API_KEY=your_key        # Gemini Deep Think — AI-reasoned text/sketch-to-3D

OpenSCAD is also available for local parametric generation (no API key needed — just install the openscad binary).

Provider	Type	Async	Output Formats
Meshy	Cloud	Yes	STL, OBJ, GLB
Tripo3D	Cloud	Yes	STL, OBJ, GLB
Stability AI	Cloud	No (synchronous)	GLB
Gemini Deep Think	Cloud + Local	No (synchronous)	STL
OpenSCAD	Local	No (synchronous)	STL

Generated models are automatically validated for printability (manifold check, triangle count, bounding box dimensions) before printing. The registry pattern means new providers can be added in under 100 lines. kiln generate and kiln generate-and-print now render a 3-view preview (isometric/dimetric/trimetric) by default; use --no-preview to disable. The MCP provider list reports every supported backend and whether its API key is configured, so agents can reason about the real generation surface instead of a partial subset.

Slicer Integration

Kiln wraps PrusaSlicer and OrcaSlicer for headless slicing. Auto-detects installed slicers on PATH, macOS app bundles, or via KILN_SLICER_PATH.

# Slice an STL to G-code
kiln slice model.stl

# Slice and immediately print
kiln slice model.stl --print-after

# Smart supports (auto = minimal buildplate-only only when needed)
kiln slice model.stl --support-mode auto

# Override material defaults when needed
kiln slice model.stl --material PETG

# Supported formats: STL, 3MF, STEP, OBJ, AMF

Webcam Snapshots

Capture point-in-time images from printer webcams for monitoring and quality checks:

# Save snapshot to file
kiln snapshot --save photo.jpg

# Get base64-encoded snapshot (for agents)
kiln snapshot --json

Supported on OctoPrint, Moonraker, Prusa Link, and Bambu (requires ffmpeg for RTSP capture — see install note above). Agents use the printer_snapshot MCP tool.

Fulfillment Services

Print through external manufacturing services — no 3D printer required, or use alongside your own printers for overflow, specialty materials, or production runs. Kiln handles the entire workflow from idea to delivered product:

# Get material recommendations for your use case
kiln order recommend functional --budget budget

# Instant price estimate (no API call needed)
kiln order estimate FDM --x 80 --y 60 --z 40

# Estimate delivery timeline
kiln order timeline SLA --country US

# List available materials (FDM, SLA, SLS, MJF, etc.)
kiln order materials

# Get a quote for a model
kiln order quote model.stl --material pla-white --quantity 2

# Validate your shipping address
kiln order validate-address --street "123 Main St" --city Austin --state TX --postal-code 78701 --country US

# View shipping insurance options
kiln order insurance 45.00

# Place the order
kiln order place q-abc123 --shipping std

# Track order status
kiln order status o-def456

# View order history
kiln order history

# List supported shipping countries
kiln order countries

Configure your fulfillment provider:

# Craftcloud — works out of the box (no API key required for public endpoints)
export KILN_FULFILLMENT_PROVIDER=craftcloud

# Optional: API key to associate orders with a Craftcloud account
export KILN_CRAFTCLOUD_API_KEY=your_key

# Optional: WebSocket price polling (recommended by Craftcloud, requires pip install websockets msgpack)
export KILN_CRAFTCLOUD_USE_WEBSOCKET=1

# Craftcloud staging (for testing)
export KILN_CRAFTCLOUD_BASE_URL=https://api-stg.craftcloud3d.com

# Optional: explicitly select a provider
export KILN_FULFILLMENT_PROVIDER=craftcloud

Agents use the consumer workflow MCP tools: consumer_onboarding for guided setup, recommend_material for material selection, estimate_price / estimate_timeline for quick estimates, fulfillment_compare_providers for cross-provider quotes, fulfillment_batch_quote for multi-part assemblies, and fulfillment_order_history / fulfillment_reorder for repeat orders.

Development

# Create a virtualenv first (required on modern Ubuntu/Debian/WSL)
python3 -m venv .venv && source .venv/bin/activate

# Install both packages in dev mode
pip install -e "./kiln[dev]"
pip install -e "./octoprint-cli[dev]"

# Run tests (7,825 total)
cd kiln && python3 -m pytest tests/ -v        # 7,586 tests
cd ../octoprint-cli && python3 -m pytest tests/ -v  # 239 tests

Revenue Model

All local printing is free forever — status checks, file management, slicing, fleet control, and printing to your own printers costs nothing.

Kiln charges a 5% orchestration fee on orders placed through external manufacturing services (kiln order / fulfillment MCP tools), with:

First 3 outsourced orders per month free
$0.25 minimum / $200 maximum per-order cap

The fee is shown transparently in every quote before you commit.

For provider-routed orders, the provider remains merchant of record and support owner. Kiln acts as orchestration infrastructure.

Licensing Tiers

Tier	Price	What You Get
Free	$0	All local printing, slicing, marketplace, safety profiles. Job queue (10 jobs). Up to 2 printers. Billing visibility.
Pro	$29/mo	Unlimited printers + fleet orchestration, fleet analytics, unlimited queue depth, cloud sync, priority scheduler. Annual: $23/mo ($276/yr).
Business	$99/mo	Everything in Pro + up to 50 printers, 5 team seats, unlimited fulfillment orders (5% orchestration fee), shared hosted MCP server, priority support, custom safety profiles, webhook integrations. Annual: $79/mo ($948/yr).
Enterprise	From $499/mo	Everything in Business + unlimited printers (20 included, $15/mo each after), unlimited seats, role-based access control, dedicated single-tenant MCP server, on-prem/cloud/hybrid deployment, SSO (SAML/OIDC), full audit trail with export, lockable safety profiles, encrypted G-code at rest, 99.9% uptime SLA, dedicated Slack channel. Annual: $399/mo ($4,788/yr).

Run kiln upgrade to activate a license key.

Safety

Kiln is safety-first infrastructure for controlling physical machines:

Pre-flight checks validate printer state, temperatures, and files before every print
G-code validation blocks dangerous commands (firmware reset, unsafe temperatures)
Temperature limits enforce safe maximums (300C hotend, 130C bed)
Confirmation required for destructive operations (cancel, raw G-code)
Optional authentication with scope-based API keys for multi-user setups
Structured errors ensure agents always know when something fails

Brand Assets

Logo files live in docs/assets/:

File	Use
`kiln-banner-1280x640.svg`	GitHub / social media banner
`kiln-logo-dark.svg`	Primary mark + wordmark (dark bg)
`kiln-logo-light.svg`	Mark + wordmark (light bg)
`kiln-horizontal-dark.svg`	Horizontal lockup (dark bg)
`kiln-horizontal-light.svg`	Horizontal lockup (light bg)
`kiln-logo-dark-notext.svg`	Mark only (dark bg)
`kiln-favicon-256.svg`	Favicon / app icon
`kiln-logo-transparent.svg`	Transparent bg (for dark UIs)
`kiln-logo-transparent-dark.svg`	Transparent bg (for light UIs)
`kiln-pfp-1024.svg`	Social media profile picture with subtle glow (1024×1024)
`kiln-pfp-1024-flat.svg`	Social media profile picture, no glow (1024×1024)
`wallpapers/kiln-wallpaper-iphone-*.svg`	iPhone wallpapers (15, 15 Pro/Max, 16, 16 Pro/Max, 17, 17 Air, 17 Pro/Max)
`wallpapers/kiln-wallpaper-macbook-*.svg`	MacBook wallpapers (Air 13/15, Pro 14/16)

All files are vector SVG — scale to any size.

Documentation

Document	Description
Litepaper	Quick overview for non-technical readers
Whitepaper	Full technical architecture and protocol design
Project Docs	Complete reference (CLI, MCP tools, adapters, config)

Support Development

Kiln is free, open-source software. If you find it useful, consider sending a tip:

Solana: kiln3d.sol
Ethereum: kiln3d.eth

License

Kiln is a project of Hadron Labs Inc.

MIT License — free for any use. See LICENSE for details.