# KinetiCAD for AI agents

KinetiCAD gets custom parts CNC machined in the US. This guide is for an AI agent that works for a person who
designed a part, or wants one designed, and wants to know what it costs or wants it made.

You can do three things here, with no account and no API key:

1. Send a part as CadQuery code or as a STEP file. KinetiCAD builds it with a CAD kernel and returns its measured
   size, its holes and round features, warnings, a picture, and a page where the person can rotate it in 3D.
2. Get the price and the delivery date. KinetiCAD's engine plans how the part is machined (the machine, the
   setups, the tools, the cycle time) and prices that plan.
3. Send an order request once the person has seen the price and said yes. No payment is taken.
   Bera Demirhan at KinetiCAD confirms the price and the delivery date by email within 1 business day.

Checking and pricing are free. The person pays only for parts they order, after they agree to the confirmed price.

## Option A: MCP

- Address: `https://get.kineticad.ai/mcp` (Streamable HTTP, JSON responses, no login, no session)
- Protocol versions: 2026-07-28, 2025-11-25, 2025-06-18, 2025-03-26
- Claude Code: `claude mcp add --transport http kineticad https://get.kineticad.ai/mcp`
- Name in the official MCP Registry: `ai.kineticad.get/cnc-parts`

| Tool | What it does | Arguments |
|---|---|---|
| `build_part` | Build and check a part | `cadquery`, `name` (optional), `about` (optional) |
| `view_part` | Look at a part | `part_id`, `view` (optional) |
| `price_part` | Price a part | `part_id`, `material` (optional), `quantity` (optional) |
| `request_order` | Request an order | `part_id`, `quantity` (optional), `material` (optional), `name`, `email`, `street`, `city`, `state`, `zip`, `phone` (optional), `company` (optional), `notes` (optional) |

Typical order of calls: `build_part`, then `view_part` if you need another side, then `price_part`, then
`request_order` after the person agrees. A STEP file on disk is uploaded over HTTP (Option B); the `part_id` you get
back works with the MCP tools too.

## Option B: plain HTTP

Base URL: `https://get.kineticad.ai/api/agent`. Responses are JSON. An error looks like
`{"error": {"code": "...", "message": "..."}}` and the message says what to change.
Machine-readable description: `https://get.kineticad.ai/api/agent/openapi.json`.

Send a part as CadQuery code:

```sh
curl -sS https://get.kineticad.ai/api/agent/parts -H 'Content-Type: application/json' \
  -d '{"name": "Mounting plate", "about": "Holds a small motor", "cadquery": "import cadquery as cq\nresult = cq.Workplane(\"XY\").box(60, 40, 8).faces(\">Z\").workplane().rarray(40, 20, 2, 2).hole(5)"}'
```

Or send a STEP file (up to 8 MB, one part per file):

```sh
curl -sS -F file=@part.step -F name="Mounting plate" https://get.kineticad.ai/api/agent/parts
```

The response, shortened:

```json
{"part_id": "0123456789abcdef01234567", "name": "Mounting plate", "source": "script",
 "size_mm": [60, 40, 8], "volume_cm3": 18.572,
 "features": ["Round holes: 4 x along Z: diameter 5 mm, 8 mm long, open at both ends."],
 "warnings": [],
 "links": {"see_in_3d": "https://get.kineticad.ai/make?d=0123456789abcdef01234567",
           "picture": "https://get.kineticad.ai/api/agent/parts/0123456789abcdef01234567/picture.png"}}
```

Look at it (PNG, 640 x 480). Views: `iso`, `iso_back`, `top`, `bottom`, `front`, `back`, `right`, `left`, `under`.

```sh
curl -sS -o part.png 'https://get.kineticad.ai/api/agent/parts/PART_ID/picture.png?view=iso'
```

Price it. Planning a new part takes from about 10 seconds to a few minutes. The call waits up to `wait_seconds`
(at most 50). If `status` is `planning`, call again after `retry_after_seconds`.

```sh
curl -sS https://get.kineticad.ai/api/agent/parts/PART_ID/price -H 'Content-Type: application/json' \
  -d '{"material": "aluminum-6061", "quantity": 5, "wait_seconds": 45}'
```

`status` is one of: `priced` (the engine's plan and price: `unit_price`, `total`, `cost_lines`, `plan`,
`delivery_date`), `planning`, `busy`, or `estimate` (the engine could not plan this part by itself; you get a
rough `unit_price_range`, and a person at KinetiCAD prices it by hand after an order request).
In a `priced` response, `plan.watch_out` lists what makes the plan expensive or incomplete, for example features
the plan does not cover yet or a high number of setups. Use it to improve the design before the person orders.

Send the order request, only after the person has agreed:

```sh
curl -sS https://get.kineticad.ai/api/agent/parts/PART_ID/order -H 'Content-Type: application/json' \
  -d '{"quantity": 5, "material": "aluminum-6061", "name": "Jane Doe", "email": "jane@example.com",
       "street": "1 Main St", "city": "Oakland", "state": "CA", "zip": "94607", "notes": "M6 thread in the center hole"}'
```

Get the STEP or STL file of a part (free; the email address is kept with the part so the person can ask about it):

```sh
curl -sS https://get.kineticad.ai/api/agent/parts/PART_ID/download -H 'Content-Type: application/json' \
  -d '{"email": "jane@example.com", "format": "step"}'
```

## How to write the CadQuery code

The code runs in a sandbox with only `cadquery` (as `cq`) and `math`. Leave the finished solid in a variable named `result`, or pass it to `show_object()`. Units are millimeters. The part must be ONE closed solid, at most 1000 mm long. A cavity sealed inside the material is rejected, because no cutter can reach it. The code can be up to 20000 characters long.

```python
import cadquery as cq

plate = cq.Workplane("XY").box(60, 40, 8)
result = plate.faces(">Z").workplane().rarray(40, 20, 2, 2).hole(5)
```

If you want the person to be able to change dimensions on the part's page, name them:

```python
import cadquery as cq

NAME = "Spacer"
PARAMS = [
    {"name": "od", "label": "Outside diameter", "unit": "mm", "value": 30, "min": 12, "max": 80},
    {"name": "bore", "label": "Bore", "unit": "mm", "value": 10, "min": 3, "max": 20},
    {"name": "h", "label": "Height", "unit": "mm", "value": 15, "min": 3, "max": 60},
]

def build(p):
    return cq.Workplane("XY").circle(p["od"] / 2).circle(p["bore"] / 2).extrude(p["h"])
```

Things that make a part fail or come back with a warning:

- Two or more separate bodies. Make the pieces overlap by at least 1 mm, or send each part by itself.
- A cut that does not touch the material. The warning names the line. The hole or slot you meant is missing.
- A hole covered by a later boss or cap. Cut the hole after you add the body that covers it, and cut through that body too.
- A wall with no thickness, where two surfaces only touch along a line.
- Draw a tapped hole at its tap drill size and name the thread in `about` or in the order notes.

When a build fails, the response names the stage and the line. Fix the code and send it again.

## What KinetiCAD machines

- CNC milled and turned parts, 1 to 1,000 pieces, up to 1,000 mm long.
- Materials: `aluminum-6061` (Aluminum 6061-T6), `aluminum-7075` (Aluminum 7075-T6), `steel-1045` (Steel 1045), `stainless-304` (Stainless steel 304), `acetal` (Acetal (POM-C)).
- Shipping within the US. The part is made by a partner machine shop in the US.
- One part per request. Send each part of an assembly by itself.
- We don't make sheet metal parts, castings or 3D-printed parts.
- We don't take firearm parts or other regulated items, or parts that need a certificate of conformance for
  aerospace or medical use.

## Rules for agents

- Ask the person before you send an order request. Show them the price and the `see_in_3d` link first.
- An order request takes no payment. It sends the person's name, email and shipping address to KinetiCAD.
- Tell the person what happens next: Bera Demirhan emails them within 1 business day with the confirmed price
  and delivery date, and they pay only after they agree.
- Prices are in US dollars. A `priced` response comes from a machining plan made for the part. A `unit_price_range`
  is a rough range based on the part's size alone, so say so when you quote it.

## Limits

- 40 parts an hour and 150 a day from one IP address. 40 new prices an hour.
- CadQuery scripts up to 20,000 characters, STEP files up to 8 MB.
- A build can run for up to a minute. The engine plans one part at a time, so a price can take a few minutes when it is busy.
- Parts are kept for 30 days, longer once they have been downloaded or ordered.

## Privacy

Parts are stored on KinetiCAD's own server and are not sent to an outside AI company. Email
contact@kineticad.ai to have a part deleted sooner.

## Contact

contact@kineticad.ai. For people: https://get.kineticad.ai/agents
