Documentation

The basics

New to 3D printing, or to AI apps? Start here. The rest of this page is the full reference; this part is the short version.

What Kiln is

Kiln connects an AI app you already use, like Claude or ChatGPT, to a 3D printer. You describe the thing you want in a sentence, the AI designs it with Kiln, Kiln checks that it will print, and your printer makes it. Kiln is free and open source, and it runs on your own computer.

A few words you will meet

• AI app, or agent. The chat app you talk to: Claude, ChatGPT, Codex, Cursor, Gemini and others. It does the thinking and asks Kiln to do the making. See which apps work.
• MCP server. The plug that lets an AI app use tools outside the chat window. Kiln is one: install it once, connect it to your app, and the app can design, check and print.
• Model, STL, 3MF. A 3D design saved as a file. STL and 3MF are the two common file types for printing. Kiln handles both, and you rarely need to open one yourself.
• CAD, STEP. CAD is the kind of software engineers design parts in. STEP is the file type those programs share. If you already have a part as a STEP file, Kiln can take it; every design Kiln makes can leave as a STEP file too, for a machine shop or a CAD program to open.
• Slicer. The program that turns a model into the layer-by-layer instructions a printer follows. Kiln runs yours for you.
• Filament. The spool of plastic a printer melts to build the part. PLA is the everyday one.
• Printer backend. How Kiln talks to your machine. Bambu Lab, Creality, Prusa, Elegoo, Klipper and OctoPrint printers all work. The full list is on the integrations page.
• Free and Pro. Free runs one printer on your home network with every public tool, and there is no limit on how much you print. Pro adds judgment and depth: every design kept with its history, printing from anywhere, and recovery when a print starts to go wrong. See pricing.

Your first print

1. Ask in a sentence. "Make me a hook for my keys" is enough. The AI asks only what it needs to know.
2. Look at it. Kiln shows the object in 3D before anything is printed. Ask for changes until it looks right.
3. Say yes. Nothing goes to the printer until you approve it.
4. Kiln checks it. Before printing, Kiln makes sure the part fits your printer, will hold together, and stays inside the machine's safe limits. If something is off, it tells you before any filament is used.
5. It prints. You can watch progress and stop the print at any time.

What you need

• A printer Kiln supports. Check yours on the integrations page. No printer yet? You can still design in the browser and order the part made.
• An AI app. Claude, ChatGPT, Codex, Cursor, Gemini or any other app that can use an MCP server.
• A few minutes to install. Follow kiln3d.com/install. Stuck? The FAQ covers the common questions.

About Kiln

Kiln is the open-source MCP server that lets Claude, Codex or any AI agent design, slice and print on Bambu Lab, Creality, Prusa, Elegoo, Klipper and OctoPrint printers. This page is the full reference: every MCP tool and CLI command, each printer adapter, and the safety guardrails that decide what an agent may do on its own. Connect it to your agent and it takes a part from description to done — design it, check that it will actually print, slice it, print it, watch the print, and help recover when something goes wrong — through 887 MCP capabilities and a 253-command CLI.

Clarification: Kiln does not operate its own marketplace or manufacturing network. It integrates with third-party marketplaces for model discovery and third-party fulfillment providers for outsourced manufacturing. Kiln is orchestration and agent infrastructure, not a supply-side platform.

Three ways to get to a print:

• 🖨️ Your printers. Control OctoPrint, Moonraker, Creality, Bambu Lab, Prusa Link, Elegoo, Duet (RepRapFirmware, beta), or Direct USB/Serial machines on your LAN.
• 🌐 Third-party model search. Search external model repositories such as MakerWorld and MyMiniFactory, then download where the provider permits, slice, and print.
• 🏭 Fulfillment providers. Route jobs to third-party fulfillment services like Craftcloud for overflow, specialty materials, or when you don't own a printer.

All three modes use the same MCP tools and CLI commands. No printer and no install? You can also design in the browser — see The Web App below.

Non-goals:

• Operating a first-party marketplace or manufacturing network
• Replacing third-party supply-side platforms
• Acting as merchant of record for provider-routed manufacturing orders

Key properties:

• Local-first. Printer communication stays on your network, and printer control never requires an account. Cloud touches are explicit and controllable: a version-update check (KILN_NO_UPDATE_CHECK=1 disables it), anonymized community print-outcome sharing (controlled via telemetry preferences; never your designs or files), and opt-in signed-in features like cloud sync and stats.
• One interface, many printers. The same commands and tools work across every supported backend. New printer families plug in without changing how you use Kiln.
• Safety-enforced. Pre-flight checks, G-code validation, and temperature limits are built into the protocol — not optional.
• Agent-native. Every operation returns structured JSON. Every error includes machine-readable status codes. --json on every CLI command.

What Kiln Does

The short version of the capability map. Everything below is reachable through the same MCP tools and CLI.

• Design. Describe a part in plain language and Kiln designs it — no external AI service or API key required — then previews it and iterates with you. The preview includes an interactive 3D stage on every install: inline in apps that support panels, or a browser link to the same stage everywhere else. Where Kiln knows which printer is yours, the stage stands the model on that machine's actual bed and says when a part outgrows it. Common items (coasters, keychains, trays, nameplates, and more) route to dedicated generators. Parametric templates, STEP/STL import, and opt-in cloud generation providers round out the ways a design can start. Any Kiln design can leave as a real CAD file too — export_step emits a clean STEP a machine shop can open and measure, free like STL and 3MF. A multi-part model can be imported with its named parts intact and turned into a buildable kit: the largest printable scale, proof the pieces physically fit, and plate-by-plate packing.
• See it in 3D. Models render from every angle before printing, and on the hosted connection you can turn a design over interactively — inline in AI apps that support embedded panels, or through a shareable link.
• Validate before you print. Every model can be checked for printability before it reaches a printer: overhangs, thin walls, bridging, bed adhesion, support needs, warping risk, and more — one verdict, the reasons behind it, and concrete fixes. Parts that physically can't succeed (too big for the plate, a material your hotend can't melt) are caught up front, free.
• Print and monitor. Slice with your installed slicer, print on any supported printer, and monitor with camera snapshots, progress, temperatures, and health checks. Some printers' cameras need a free camera add-on; Kiln tells you when yours does and can add it for you. Failed prints get diagnosis, guided recovery, and — on supported setups — resume from the layer where the print stopped.
• Decorate. Photos, logos, QR codes, text, and procedural textures can be applied to models for single- or multi-color printing (paid tiers; see pricing). A decoration saved earlier can be re-applied by name at its recorded depth and placement.
• Learn. Print outcomes feed material recommendations, per-printer settings, and calibration so the next print is smarter than the last. Community learning is anonymized and opt-in.
• Version. Designs, decorations, and mechanical features can be branched, merged, reviewed, released, and signed — version control that understands manufacturing artifacts. A free Kiln account keeps full history on the designs it saves; Kiln Pro covers every design, decorations and features, and signed releases.

Parts of Kiln's intelligence stack are patent-pending.

The Web App

kiln3d.com is Kiln in the browser. Sign in for free and make a real, printable object on the spot — pick a starter (coaster, keychain, nameplate, and more), watch it build in 3D, apply a color or texture, and download it to print. No install, no printer, no API key required. A free account keeps the designs you save with their full version history and branches; Kiln Pro keeps every design and adds reviews and signed releases. Nothing about local printer control requires an account.

Supported Printers

The full, always-current list of printer models Kiln ships a tuned profile for lives at kiln3d.com/printers.

Tiers

The core loop — design, validate, slice, print, monitor — is free and open source. Kiln Pro, Business, and Enterprise add depth on top: decoration and versioning, per-printer calibration and learning, production drawings, team workflows, and compliance features. See kiln3d.com/pricing for what each tier includes.

Founding members get half off for life, while founding spots last: Pro $24.50/mo or $234/yr, Business $99.50/mo or $954/yr. Students get half off Pro or Business for 12 months by emailing adam@kiln3d.com from a school address. The pricing page shows whether the founding offer is open.

Kiln works with one printer at a time below the Business tier: registering and listing any number of machines is free, and hand_back_printer moves Kiln between them without touching a running print. Renaming a printer (rename_printer, or kiln rename-printer at a terminal) is free too, and its history, settings and permissions follow the new name; from the web or the hosted connector the rename reaches your computer through the Kiln Bridge. Driving several printers in parallel — including fleet-wide commands — is a Business feature.

Getting Started

Installation

# Recommended
uv tool install kiln3d

# Also works
pip install kiln3d
pipx install kiln3d

Requirements: Python 3.11+. The pip package is kiln3d; the CLI command is kiln. OS-specific walkthroughs (Windows, WSL 2, Linux) live at kiln3d.com/install.

To update later: kiln self-update (or ask your AI assistant — it will offer when a new version is out).

Connect Your AI App

kiln signin        # create your free account (optional, unlocks stats and saved designs)
kiln install-mcp   # connects Kiln to Claude Desktop, Claude Code, and Codex automatically

Kiln's hosted connection speaks the July 2026 revision of the Model Context Protocol: long-running work hands back a ticket you can check on, and confirmations (like a fulfillment order's price) come back as real questions in your app. Older clients keep working unchanged.

Restart your AI app and it can run your printer. Using a different MCP client? kiln install-mcp --print prints the config — or paste it yourself:

{
  "mcpServers": {
    "kiln": {
      "command": "python3",
      "args": ["-m", "kiln"],
      "env": {
        "KILN_PRINTER_HOST": "http://your-printer:80",
        "KILN_PRINTER_API_KEY": "your-api-key"
      }
    }
  }
}

Use Kiln from claude.ai, with nothing installed

Add Kiln as a connector in claude.ai (the connector address is https://api.kiln3d.com/mcp; a one-click link is at kiln3d.com/claude). Designing, engineering checks, material and printer questions and manufacturing quotes run on Kiln's servers. Two things reach your own printer once Kiln is installed and signed in on the computer attached to it: print_design sends a design made in the chat to that printer, and you approve each print yourself; monitor_printer watches it, and answers honestly whether it is printing, idle, offline or never paired. Printing this way is free on your home network; printing from elsewhere is part of Kiln Pro (pricing).

Discover Printers

kiln discover

Scans your local LAN (Ethernet or Wi-Fi) using mDNS and HTTP probing. If discovery does not find your printer, add it directly by IP with kiln auth.

Add a Printer

Say which printer it is with --printer-model. A printer Kiln doesn't list yet is fine: add who makes it with --printer-make.

# OctoPrint
kiln auth --name ender3 --host http://octopi.local --type octoprint --api-key YOUR_KEY --printer-model "Ender 3"

# Moonraker
kiln auth --name voron --host http://voron.local:7125 --type moonraker --printer-model "Voron 2.4"

# Creality K1/K2/Hi-class local Moonraker
kiln doctor-creality --host 192.168.1.55 --model k1_max
kiln auth --name k1max --host 192.168.1.55 --type creality --printer-model k1_max

# Prusa Link
kiln auth --name prusa-mini --host http://192.168.1.44 --type prusalink --api-key YOUR_KEY --printer-model "Prusa Mini"

# Bambu Lab
kiln auth --name x1c --host 192.168.1.100 --type bambu --access-code 12345678 --serial 01P00A000000001 --printer-model "X1 Carbon"

# Elegoo SDCP
kiln auth --name centauri --host 192.168.1.50 --type elegoo --printer-model "Centauri Carbon"

# Direct USB / Serial
kiln auth --name ender3-usb --host /dev/tty.usbserial-0001 --type usb --printer-model "Ender 3"

# A printer Kiln doesn't list yet
kiln auth --name kobra --host http://octopi.local --type octoprint --api-key YOUR_KEY --printer-make Anycubic --printer-model "Kobra X"

Ethernet-Only Setup (No Wi-Fi)

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

# Verify endpoint from your host:
curl http://192.168.1.44/api/v1/status                  # Prusa Link
curl http://192.168.1.50:7125/server/info               # Moonraker
curl http://192.168.1.60/api/version                    # OctoPrint

# Register directly by IP (no discovery required):
kiln auth --name printer --host http://192.168.1.44 --type prusalink --api-key YOUR_KEY --printer-model MK4

First Print

kiln status                    # Verify printer is online
kiln preflight --material PLA  # Run safety checks
kiln upload benchy.gcode       # Upload file to printer
kiln print benchy.gcode        # Start printing
kiln wait                      # Block until complete

Slice and Print (STL to Object)

kiln slice benchy.stl --print-after

Auto-detects PrusaSlicer, OrcaSlicer, or BambuStudio, slices to G-code, uploads, and starts printing.

Make Something From Scratch

The easiest way to design with Kiln is through your AI assistant. Just describe what you want:

"Make me a phone stand for my desk — my phone is 78 mm wide."

Kiln captures the goal, designs the part itself (no external AI service or API key needed), shows you a preview, and iterates until it's right — then slices and prints it. Saved goals travel with the design, so monitoring, reprints, and later versions know what the part was for.

Cloud text-to-3D providers (Meshy, Tripo3D, Stability AI, Gemini) are available as opt-in alternatives — bring your own API key and ask for them explicitly. They are never required.

No Printer?

You can still go from idea to object: design through the agent or the web app, then route the job to a third-party fulfillment provider (fulfillment_quote → fulfillment_order), or just download your file and print it anywhere.

CLI Reference

Global Options

The CLI has 253 commands in total; this section documents the everyday core. Run kiln --help for the full command tree.

Commands

`kiln discover`

Scan the local LAN for printers via mDNS and HTTP probing. If no printers are found, use kiln auth --host <ip> to register directly.

`kiln auth`

Save printer credentials to ~/.kiln/config.yaml.

`kiln signin`

Create or sign in to your Kiln account (free). Optional — unlocks stats, saved design goals, and paid-tier features when you have them.

`kiln status`

Get printer state, temperatures, and active job progress.

`kiln files`

List G-code files available on the printer.

`kiln upload `

Upload a local G-code file to the printer.

`kiln print ... [--queue]`

Start printing. Accepts multiple files via glob expansion. With --queue, files are submitted to the job queue for sequential printing. Before anything starts, it shows you the preview and asks you to confirm at the keyboard (see Saying Go).

`kiln cancel`

Cancel the active print job.

`kiln pause` / `kiln resume`

Pause or resume the active print.

`kiln consent window|status|extend|revoke`

Open, list, extend or close a standing window — a yes for a while on one printer (see Standing windows). window and extend only work with a person at the keyboard; revoke works from anywhere.

`kiln temp [--tool N] [--bed N] [--printer NAME]`

Get current temperatures, or set targets. Without flags, returns current temps. Targets are held to the named machine's own limits.

`kiln filament load|unload|purge|wipe [--slot N] [--material MAT] [--temp N] [--length MM] [--keep-hot]` / `kiln filament wipe [--plan] [--step N] [--plate-clear]`

Move filament. load feeds a spool to the nozzle (through the AMS on a Bambu). unload pulls filament out of the hotend. purge extrudes a short length and reports whether the printer flagged a problem: the clog test. wipe cleans the tip on the printer's own wipe pad, and refuses by name on any model whose pad Kiln does not know.

Every op says where the plastic went — over the machine's own purge chute where Kiln knows it for your model (served through Kiln's hosted service for a printer paired to your Kiln sign-in, free, and kept on your machine so it keeps working offline), or in place with the reason — and leaves the machine cool and safe, the way a person would. --keep-hot opts out for a caller about to do something else hot.

Temperature is held to the machine's own safety profile, to the loaded spool's temperature window where the printer reports one, and to a 170 °C cold-extrusion floor. Refused while a print is running; allowed while paused, which is the mid-print recovery case. On a Klipper machine whose filament path belongs to a Happy Hare or AFC unit, load and unload refuse and name the unit's own commands. Backends that cannot drive the extruder honestly — Prusa Link, Elegoo — say so instead of pretending.

wipe runs in steps too, the first time on a machine: --plan describes every motion and sends nothing; --step N sends one motion, reports what it left armed, and holds the cool-down until the last step. A wipe that presses or crosses the plate runs only with --plate-clear, on every call, whatever the plate record says. Where a model's wipe has not yet been run on a real machine, Kiln says so and runs it in steps only; kiln doctor shows both on the filament line.

`kiln home [--axes XYZ] [--plan] [--step N] [--plate-clear]` / `kiln park [--plan] [--step N]`

The Home button, from Kiln, and the retreat. home runs your model's own homing routine where Kiln has it (served through Kiln's hosted service for a printer paired to your Kiln sign-in, free, and kept on your machine so it keeps working offline), hands the job to the firmware's own routine on Marlin, Klipper and RepRapFirmware, and refuses — naming the screen's jog controls — where neither is safe. park moves the head to the model's own spot off the plate, with no Z touch and no heat.

Run either in steps the first time on a machine with a person beside it: --plan describes every motion and sends nothing; --step N sends one motion, reports what it left armed, and describes the next. A model whose Z home presses the nozzle onto the plate (the A1 mini) runs it only with --plate-clear, on every call — a person's word, never inferred. Both refuse while a print runs or is paused. kiln doctor shows what Kiln knows about homing your printer.

`kiln plate status` / `kiln plate clear [--note TEXT]`

What Kiln records is on the build plate: the print that left a part there and when; or a person's word that it is clear. home and park refuse to cross a recorded part; plate clear is the person's door and stays clear until the next print starts. The record lives on your machine. A Z home that presses the nozzle onto the plate asks every time regardless -- the record cannot see a print started from the printer's own screen. There is deliberately no MCP tool that marks the plate clear.

`kiln gcode ...`

Send raw G-code commands to the printer. Commands are validated for safety before sending.

`kiln preflight [--material MAT]`

Run pre-print safety checks. Optional --material validates temperatures against expected ranges for: PLA, PETG, ABS, TPU, ASA, Nylon, PC.

`kiln slice [--print-after] [--profile PATH] [--output-dir DIR]`

Slice an STL/3MF/STEP/OBJ/AMF file to G-code. --print-after chains upload and print.

`kiln snapshot [--save PATH]`

Capture a webcam snapshot. --save writes to file; otherwise returns base64 in JSON mode.

`kiln install-camera`

Add Kiln's free camera add-on to this computer. Some printers' cameras need it before Kiln can show them, and Kiln says when yours does. It can be added while a print runs, and nothing needs restarting.

`kiln wait [--timeout N] [--interval N]`

Block until the current print finishes. Returns exit code 0 on success, 1 on error/timeout.

`kiln history [--status S] [--limit N]`

Query past print records from the local database. Filter by completed, failed, cancelled.

`kiln printers`

List all saved printers with type and active status.

`kiln use `

Switch the active printer.

`kiln remove `

Remove a saved printer from config.

`kiln rename-printer `

Rename a saved printer. Its print history, loaded material, queued jobs, emergency-stop state and the standing permissions on that computer that name it all follow the new name, and Kiln keeps the names it has had. Refused while the printer is printing or under an emergency stop, when the new name is taken (here, or by a standing permission), or when the new name carries the printer's address, serial or a code (a clean name is suggested). Signed in, the records your Kiln account keeps for the printer follow too; --account-only does just that half after a rename made while signed out. The same rename is the rename_printer tool for an agent.

`kiln serve`

Start the MCP server (for agent integration).

`kiln health`

Check Kiln's own setup: MCP client config drift, stale paths, environment problems — and self-heal where it can.

`kiln trim`

Close leftover background Kiln servers that closed agent sessions leave behind. Checks that nothing is printing first and never touches the session you're in.

`kiln doctor` / `kiln doctor-creality`

Diagnose connection problems. The Creality variant verifies local Moonraker reachability and gives same-LAN/IP/port guidance. kiln doctor also says which ways of saying go to a print work on this computer (your app's dialog, a code on this screen, the terminal) and lists any standing window that is open.

`kiln self-update`

Update Kiln to the latest version. Holds off while a print is running.

`kiln accept-terms`

Show Kiln's Terms of Use and record your acceptance (one time, remembered everywhere you use Kiln).

`kiln cost [--material MAT] [--electricity-rate N] [--printer-wattage N]`

Estimate the cost of printing a G-code file. Analyzes extrusion, calculates filament weight and cost, and optionally includes electricity cost.

`kiln material set|show|spools|add-spool`

Material tracking commands. set records loaded material on a printer. show displays current material. spools lists spool inventory. add-spool registers a new spool.

`kiln level [--status] [--trigger] [--set-prints N] [--set-hours N] [--enable/--disable]`

Bed leveling management. Check status, manually trigger leveling, or configure auto-leveling policy.

`kiln stream [--port 8081] [--stop] [--check]`

Start or stop live video from the printer's camera, served as MJPEG at a local address on this computer. --check finds what the printer's camera serves and says how to save a live stream it finds; it saves nothing itself. Both run only on the machine next to the printer.

`kiln events tail|summary`

Read-only access to the local event log.

`kiln plugins list|info`

Plugin management. list shows all discovered plugins. info shows details for a specific plugin.

`kiln install-mcp` / `kiln uninstall-mcp`

Install or remove Kiln from supported MCP clients. The installer detects common client config locations and writes the kiln serve entry for the current environment.

`kiln preview ` / `kiln validate ` / `kiln repair `

Render a model preview, check print readiness, or repair common STL/3MF mesh defects before slicing.

Through your AI agent: cloud sync and assembly manuals

These two have no command of their own; ask your AI agent, connected to Kiln, and it does them for you.

• Cloud sync (Kiln Pro and above). Kiln copies your printer settings, print history and events, in the background, to a sync service you point it at. Your agent sets it up, syncs now, or tells you where it stands.
• Assembly manuals (Kiln Business and above). A printable step-by-step PDF for a multi-part design, with the parts list and a picture for each step.

See pricing for what each plan includes.

MCP Server Reference

Installation

The MCP server starts via kiln serve or python -m kiln serve. The fastest setup is kiln install-mcp (see Getting Started).

Tool Catalog (Selected)

Kiln exposes 880 MCP tools and 887 total MCP capabilities. The everyday core is documented below by category; agents see the full, current catalog at connect time (get_started and get_skill_manifest return the complete map).

Paid-tier tools are discoverable too: agents without a license receive a structured response naming the required tier, so they can tell you what's possible and where it lives (pricing).

Printer Control

File Management

Slicing

Monitoring

Fleet & Job Queue

Model Discovery

Each search result carries print-readiness hints: is_free, has_sliceable_files (STL/3MF/OBJ that need slicing), and has_printable_files (ready-to-print G-code).

Materials

Deeper material intelligence — drying schedules per filament, chemical-exposure verdicts, adhesive recommendations for joining printed parts, and datasheet ingestion — ships with paid tiers; see Paid-Tier Tool Families.

Design & Generation

Design intelligence queries — material recommendations for a duty, printer design capabilities, template design rules, environment compatibility, structural load estimates, post-processing guides, and print-issue troubleshooting — are available as individual tools (recommend_design_material, get_printer_design_capabilities, troubleshoot_print_issue, and friends).

The documents Kiln makes for a design — assembly manuals, dimensioned drawings, manufacturability assessments, first-article records, hardware insertion records — move to your Kiln account and back with one tool: cloud_documents takes an action (push or pull) and a kind. Keeping and getting back your own manuals and drawings is free on every plan; the assessment and first-article kinds follow the tier of the records they move.

Printability & Mesh Tools

All mesh analysis runs locally.

Cost Estimation

Print Analysis & Recovery

Wet-filament detection is built in: failures that look like moisture (popping, stringing, weak layers) get named as such, for any printer and material.

Vision Monitoring (Agent-Delegated)

Kiln provides structured monitoring data (webcam snapshots, temperatures, progress, phase context, failure hints) to agents. The agent's own vision model analyzes the snapshots — Kiln does not embed its own vision model.

Safety & System

G-code interception (rule-based command filtering between Kiln and the printer) is available for advanced setups: start_gcode_interception, add_interception_rule, load_safety_interception_rules, and friends.

Fulfillment (Third-Party Providers)

Routes manufacturing to third-party fulfillment providers (Craftcloud). Kiln acts as an API client — it does not operate manufacturing capacity or act as merchant of record. A quote shows exactly what you'll pay — printing, the shop's minimum, shipping — and notes that tax is added at checkout. Orders require an explicit preview confirmation and a shipping-address confirmation before placing, so an agent can never order something you haven't seen; placing one hands you the print service's own checkout link, where you pay, and the order status then follows your print from paid to delivered.

Paid-Tier Tool Families (kiln-pro)

The families below ship through kiln-pro, Kiln's paid companion. Agents discover these tools even without a license and receive a structured pointer to the required tier.

• Decoration & textures (Pro+). Emboss or deboss photos, logos, SVG, QR codes, and text onto any face of a model; procedural and image-based textures with custom palettes for multicolor printing. Flagships: decorate_surface, apply_procedural_texture.
• Product generators (free with monthly quota; unlimited on Pro+). One-call generators for coasters, keychains, nameplates, pet tags, trays, ornaments, magnets, and more — engraving-ready and printer-aware, each stating its assumptions (material, sizing) in plain English so you can redirect it in one line. Flagships: generate_coaster, generate_keychain, generate_nameplate.
• Version control for designs (free on saved designs; Pro+ on every design). Branch, merge and cherry-pick the designs a free account keeps in its Kiln account; Pro+ does it on every design and adds releases and signing for designs, decorations, and mechanical features. Pull requests on your own designs follow the same split: free on the designs you keep, Pro+ on every design; team review and enforced approval gates are Business+. Flagships: create_design_branch, merge_design_branches, sign_design_release.
• Provenance & learning (Pro+). Design version history with print outcomes attached, regression alerts when a design stops printing well, proven recipes per material and printer, and print-confidence scoring. Flagships: save_design_version, get_proven_recipe, get_regression_alerts.
• Per-machine calibration (Pro+). Kiln learns each printer's real-world offsets from your prints and applies them when slicing — with freshness tracking and a plain-English answer to "why is this dimension what it is?" Flagships: get_calibration_freshness, explain_calibration_for_design, ingest_measurement.
• Nozzle intelligence (Pro+). Per-printer nozzle tracking (material, diameter, filament run through it), wear warnings before a print that would push it past its window, and wear-aware failure analysis. Flagships: nozzle_wear_status, get_nozzle_state, record_nozzle_replacement.
• Material intelligence depth. Drying schedules per filament with one-tap AMS dryer handoff (Pro+); chemical-exposure verdicts for fuels, solvents, cleaners, and outdoor duty (Business+; the safety warnings are always free); skin-contact verdicts for jewelry, wearables, and watch straps (always free — paid tiers add risk-reduction guidance and what it takes to sell a skin-contact product); adhesive recommendations with prep and cure schedules for joining printed parts (Pro+); manufacturer-datasheet ingestion into your own material library (Business+). Flagships: drying_advisor, check_chemical_resistance, check_skin_contact_suitability, recommend_adhesive, ingest_material_datasheet.
• Production drawings (Business+). Dimensioned technical drawings — aligned orthographic views with real measurements, PDF and DXF — from any design. Flagship: generate_technical_drawing.
• Part Passport (Pro+). Everything about one design in a single call: versions, materials, manual, BOM, outcomes, releases. Flagship: get_part_passport.
• Sourcing risk for bought parts (Enterprise). Flags the purchased components a design depends on that are going end-of-life, single-source, or long-lead — and proposes swaps — before you commit to a bill of materials you can't buy in a year. Flagships: assess_bom_sourcing_risk, propose_sourcing_remediation.
• Assembly manuals (Business+). Printable step-by-step PDF manuals for multi-part designs, with BOM and per-step renders. Enterprise adds controlled, multi-language factory work instructions with torque specs, inspection gates, and sign-off. Flagships: generate_assembly_manual, embed_manual_in_3mf.
• Mid-print modification & deep recovery (Pro+). Add features or decorations to a paused print, resume across power loss, and (Business+) triage a whole fleet after an outage. Flagships: decorate_during_print, recover_power_loss_print, assess_fleet_power_loss.
• Business & Enterprise operations. Billing and spend caps, team and org management, SSO sign-in, audit-trail export, and multi-site fleet views. See pricing for the full breakdown.

MCP Resources

Read-only resources for agent context:

Printer Adapters

OctoPrint

Communicates via HTTP REST. Kiln asks OctoPrint for an application key of its own when you connect without one — you click Allow inside OctoPrint (from OctoPrint 1.8 the request also opens a small approval page), and the key is made for Kiln. OctoPrint versions without the Application Keys plugin still take a pasted key, made under User Settings > Application Keys.

Configuration:

type: octoprint
host: http://octopi.local
api_key: YOUR_KEY

Webcam: Snapshots supported via the OctoPrint webcam interface.

Moonraker

Communicates via HTTP REST. Usually needs no key: Moonraker lets in the computers on its trusted list, which most installs set to the local network. Otherwise, add its API key.

Configuration:

type: moonraker
host: http://voron.local:7125

Webcam: Cameras are discovered automatically from Moonraker's webcam list.

Creality

Modern CrealityOS/Klipper FDM printers are supported through local Moonraker when it is reachable on the printer's LAN. The creality backend probes common Creality Moonraker ports and then behaves like a Moonraker printer. Older Marlin-based Creality machines should use octoprint or serial.

Configuration:

type: creality
host: 192.168.1.55
printer_model: k1_max

Diagnostics: Run kiln doctor-creality --host 192.168.1.55 --model k1_max to verify reachability and get same-LAN/IP/port/API-key guidance when local Moonraker is not reachable.

Caveat: Not every stock Creality firmware exposes local Moonraker. Support depends on the printer answering on your LAN.

Bambu Lab

Communicates via MQTT over LAN. Requires the printer's serial number and LAN access code, both shown on the printer's screen; Kiln's network discovery reads the serial for you.

Configuration:

type: bambu
host: 192.168.1.100
access_code: "12345678"
serial: "01P00A000000001"

Notes: Requires the paho-mqtt package. AMS material routing, AMS dryer control (AMS 2 Pro / HT), and network discovery are supported. On every model, turn on LAN Only Mode and then Developer Mode (on the page that shows the access code) for Kiln to start and control prints; status works without them. Both modes turn off Bambu Handy and Bambu's cloud for that printer.

Prusa Link

Communicates via the Prusa Link REST API. Requires the PrusaLink password, shown on the printer's screen under Settings > Network > PrusaLink (an MK3S running PrusaLink on a Raspberry Pi makes its key in PrusaLink's web page instead).

Configuration:

type: prusalink
host: http://prusa-mk4.local
api_key: YOUR_KEY

Limitations: No raw G-code or direct temperature control — these are managed through print files. (Configs saved under the old prusaconnect type name are auto-detected and migrated.)

Elegoo (SDCP)

Communicates via the SDCP protocol over WebSocket. No authentication required on the local network. Covers the Elegoo Centauri Carbon.

Note: Elegoo Neptune 4 and OrangeStorm Giga run Klipper/Moonraker — use the moonraker adapter type for those.

Configuration:

type: elegoo
host: 192.168.1.50
mainboard_id: ABCD1234ABCD1234  # optional, auto-discovered

File upload: the printer fetches files from your machine over the local network, so your firewall must allow local inbound connections from the printer.

Dependencies: Requires the websocket-client package. Install with pip install 'kiln3d[elegoo]'.

Direct USB / Serial

Any Marlin or RepRapFirmware printer over a USB serial connection.

Configuration:

type: usb
host: /dev/tty.usbserial-0001

Model Marketplaces (Third-Party Search)

Kiln searches third-party model repositories on your behalf — it does not host or serve models itself. search_all_models queries every connected marketplace at once and interleaves the results; if one source fails, the others still return.

Supported Marketplaces

Configuration

MakerWorld works with no setup. For the others, set environment variables for each marketplace you want to enable:

export KILN_MMF_API_KEY=your_key               # MyMiniFactory developer key
export KILN_CULTS3D_USERNAME=your_username      # Cults3D account username
export KILN_CULTS3D_API_KEY=your_key            # https://cults3d.com/en/api/keys
export KILN_THINGIVERSE_TOKEN=your_token        # Deprecated

Adapters are auto-registered at server startup based on available credentials. Only configured marketplaces participate in searches.

Download and Upload

download_and_upload combines marketplace file download with printer upload in a single tool call, for marketplaces that support direct downloads.

Safety Systems

Pre-flight Checks

Every print job should pass through preflight_check():

1. Printer online — Kiln can reach the printer
2. Printer idle — No active job running
3. File exists — Target file is on the printer
4. Temperature safe — Targets within safe bounds
5. Material validation — When --material is specified, temperatures match expected ranges
6. Physical feasibility — A part that can't fit the build volume, or a material the hotend can't melt, is caught before filament is wasted. Kiln rotates a part to fit when it can; force_print_oversize is the explicit override for slicing-for-another-printer workflows.

A check Kiln could not make is never reported as a pass: a pre-flight that cannot reach Kiln's servers lists that check as not made, instead of quietly leaving it out.

When Kiln's Servers Can't Be Reached

Every feature that leans on Kiln's servers says, in plain words, which of four things happened — this computer is offline, Kiln is signed out, Kiln's servers didn't answer, or they said no — along with what Kiln will not do because of it and the safe thing to do next. A safety check that cannot be made fails closed and says which. A session that has run out says so everywhere; your plan stays on your account, and signing back in restores it on this machine.

Preview Confirmation

New print starts require a preview-confirmation step:

1. Render a model preview (kiln preview or the preview tools).
2. Show the preview to the user and get approval.
3. Start the print with the issued confirmation.

Confirmations are single-use, short-lived, and bound to the file and printer, so an agent can never quietly start a print you haven't seen. KILN_SKIP_PREVIEW_GATE=1 is the explicit advanced-user bypass and is logged whenever used.

In MCP apps that support confirmation prompts, the approval is a dialog the app shows you directly — your assistant cannot answer it for you. It names the file and covers that one print, unless you choose a standing window. Every way of starting a print asks: slicing-and-printing, retries, and monitored prints all pass through the same approval step, and a retry only re-asks when the shape changed. If your app cannot show a dialog, Kiln shows a code on your screen instead — see Saying Go.

Saying Go

A print starts only when a person says go — for that one print, or for a while — in a place your assistant cannot answer for you. No flag or command lets an assistant supply that yes itself; the only exceptions are switches you set yourself, all off by default — the advanced-user bypass above and the auto-print settings. Stopping, pausing, resuming and watching a print never need that yes.

Kiln tries the ways below in order and uses the first one that works on your setup. When a print is refused, your assistant is told which of them exist on your computer, and only those, so it can tell you what to do.

1. Your app's approval dialog

If your AI app can show approval dialogs, Kiln asks there before every print. The dialog names the file and the printer, starts on No (so a stray click starts nothing), and offers:

• Yes, this print only
• Yes, and for the next 2 hours without asking again
• Yes, and for the rest of today without asking again
• No

You can also type a length instead, like 45m or 3h (24 hours at most). The "for a while" answers open a standing window on that printer. Saying No, or closing the dialog, ends it there: nothing is sent to the printer.

A yes that could not have come from a person reading the question does not count: Kiln sets the dialog aside and moves on to a code on your screen.

2. A code on your screen

When your app cannot show the dialog, Kiln puts a four-digit code in an ordinary system notification on the computer it runs on. It looks like this:

Kiln
benchy.3mf on garage
Type 4821 in your chat to print it. Add 2h or today to keep printing without asking.

Type the code into your chat with your assistant:

A length works too, like 4821 45m (24 hours at most). Your assistant passes your words to Kiln and tries the print again; if the code matches, the print starts.

• Your assistant cannot see the code. Nothing it can ask Kiln for reveals it: the code is held only in Kiln's memory while it waits and never appears in anything Kiln hands back. That is what makes typing it a real yes.
• One code, one print. A code covers the one file on the one printer it was shown for, works once, and runs out after 10 minutes. It never covers more than that one printer.
• Wrong guesses count. Too many wrong codes cancels every waiting code for a short while; then ask your assistant to try the print again for a fresh code.
• Notifications have to be on. The code is a normal notification, so if notifications are off on that computer, or Do Not Disturb or a Focus mode is hiding them, you will not see it. On Linux it needs a desktop session and the notify-send command. If no banner appears, give your yes at the terminal instead.
• What it proves, and what it does not. A typed code proves that someone who could see that screen chose to type it — the same as a yes at the keyboard. If you have let an assistant take screenshots of that computer, it could read a banner while it is showing; on a setup like that, use the dialog or the terminal.

A computer with no screen (a headless box) shows no code, and neither does one where the banner has been turned off (see Environment Variables). There, the yes comes from the terminal.

3. The terminal

At a terminal on the computer running Kiln:

kiln print benchy.3mf                              # shows the preview, then asks: Start printing …? [y/N]
kiln consent window --for 2h --printer garage      # opens a standing window (below)

kiln print opens the preview (or, for a file it cannot draw, says so) and asks you directly. It only asks when a person is at the keyboard: if an assistant runs the command for you, it gets a refusal, not a question. This way of saying go is there on every computer that runs Kiln.

Standing windows

A standing window is a yes for a while: until it closes, prints on that printer start without asking you each time. Every print inside one still has to be previewed first.

• Opening one: pick a "for a while" answer in the dialog, add 2h or today to a code, or at the terminal run kiln consent window --for 2h --printer garage (--for takes lengths like 30m, 2h or 1d). Nothing your assistant can call opens or extends one.
• 24 hours at most, whichever way it was opened. Open another when it runs out.
• Seeing them: kiln consent status (or kiln doctor) lists what is open, until when, and how it was opened.
• Closing one: kiln consent revoke <id> (or --all), or tell your assistant to close it — closing works from anywhere. Jobs queued under a window that has closed do not start on it.
• Extending one: kiln consent extend <id> --for 1h, at the terminal.
• Several printers: a window over a list of printers (--printers a,b) or all of them (--fleet) is a Business feature, like running several printers at once (kiln3d.com/pricing).

A window that runs out or is closed while a print is running lets that print finish. It only stops new prints from starting without asking.

When Nothing at Home Is Running Kiln

Kiln reaches your printer over your home network (or a USB cable) from the computer it is installed on, and every way of saying go above ends at that computer. So a computer on the printer's network has to be switched on, awake and running Kiln — a Mac or PC that is not asleep, or a small always-on computer. When nothing at home is running Kiln, none of these can start a print. If you want to start prints while you are away from the desk, leave one computer on and set it not to sleep. kiln doctor on that computer says which ways of saying go work there.

Occupied Plate

Kiln remembers what its last print left on the plate. Until you say the plate is empty (kiln plate clear, or plate_clear=True on home_axes), every way of starting a print refuses to start onto it, and every way of slicing refuses to slice onto it. plate_status shows what the record says is there and since when.

To print a second part beside the one on the plate, pass a placement (a named region such as back-left or centre, or exact plate coordinates) to any slicing tool. Kiln checks that spot on your printer and slices there only when the new print will stay clear of the part for its whole run. The check runs on Kiln's servers, so offline or signed out there is no slice: Kiln says which one stopped it and what to do, rather than guessing. The check is free on every tier.

On Kiln Pro the new print then starts without disturbing the part beside it. Below Pro, the file is sliced beside the part but starts only once the plate is clear (pricing).

Across a fleet, route_print_job, fleet_submit_job and suggest_printer_for_job read each printer's plate and send a job only where it fits; a job no plate can take is refused when it is submitted, with each printer's reason. Reading the whole fleet's plates is a Kiln Business feature; the check on any one printer stays free.

G-code Validation

validate_gcode() screens commands before they reach hardware:

• Blocked: Firmware reset, EEPROM wipe, unsafe axis movements
• Warned: High temperatures, rapid moves without homing
• Passed: Standard print commands, temperature sets within limits

Temperature Limits

Per-printer safety profiles tighten these further for specific machines, and idle heaters are automatically cooled by a background watchdog if left on with no active print.

Authentication

Local API-key auth for the Kiln server is disabled by default. Enable it for multi-user or network-exposed setups.

export KILN_AUTH_ENABLED=1
export KILN_AUTH_KEY=your_secret_key

Scopes: read, write, admin.

Read-only tools (printer_status, printer_files, fleet_status) never require authentication.

Webhooks

Register HTTP endpoints for real-time event notifications:

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

Event types cover the job lifecycle (job.submitted, job.completed, job.failed, ...), print state (print.started, print.paused, print.failed, ...), printer availability (printer.online, printer.offline, printer.error), materials (material.loaded, material.mismatch, material.spool_low, ...), leveling, sync, recovery, and vision checks. recent_events lists what your install emits.

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

Configuration

Config File

Location: ~/.kiln/config.yaml

active_printer: my-voron

printers:
  my-voron:
    type: moonraker
    host: http://voron.local:7125

  ender3:
    type: octoprint
    host: http://octopi.local
    api_key: ABC123

  x1c:
    type: bambu
    host: 192.168.1.100
    access_code: "12345678"
    serial: "01P00A000000001"

settings:
  timeout: 30
  retries: 3

Environment Variables

The common ones:

Precedence

CLI flags > Environment variables > Config file.

Development

Kiln's public package is open source (AGPL-3.0) and developed at github.com/codeofaxel/Kiln.

Setup

git clone https://github.com/codeofaxel/Kiln.git
cd Kiln
pip install -e "./kiln[dev]"

Running Tests

cd kiln && python3 -m pytest tests/ -v

Adding a New Printer Adapter

1. Create kiln/src/kiln/printers/yourbackend.py
2. Implement the abstract methods from PrinterAdapter in base.py
3. Return typed dataclasses — never raw dicts
4. Map all backend states to the PrinterStatus enum
5. Handle connection failures gracefully (return OFFLINE)
6. Add to the adapter factory in cli/config.py
7. Write tests following the existing adapter test patterns

See CONTRIBUTING.md in the repository for the full contributor guide.

About kiln-pro

Kiln's paid tiers ship through the private kiln-pro companion package (kiln3d.com/pricing). Public Kiln defines the interface contracts — the tool manifest, response shapes, and the assembly JSON contract — and works fully without it; kiln-pro provides the licensed features behind those contracts.

Kiln is a project of Hadron Labs Inc.