Say what you want and it gets built. Point at what you mean and it gets changed. Sketch, constrain and tweak by hand when that is quicker. Assemble it, section it, make it move, render it. Then STEP, STL, shop drawings, or G-code, and run it on your Makera Z1 (experimental). One reproducible script, on your own machine — and when the app lacks a tool, the agent writes it.
Sound on. A real session with the real agent; only the thinking time is sped up.
Needs Claude Code. The app does not bundle Anthropic's Claude Code; install it once (free, one command) and sign in with your Claude account or API key. The app walks you through it on first launch. Details.
Intel Macs and Linux: use the source zip for now.
# any platform with Python 3.12, inside the unzipped source zip or a clone of github.com/agenticcad/agenticcad
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
.venv/bin/python server.py # then open the address it prints in your browser
Same app, same Claude Code requirement. All releases: github.com/agenticcad/agenticcad/releases.
Free for non-commercial use under PolyForm Noncommercial 1.0.0. Commercial use is A$99 per user per year; see licensing.
Three ways to shape a part, and they all end in the same place: one build123d script that the exact kernel executes. No feature tree, no hidden state, nothing you cannot read.
“60 × 40 × 8 plate, four Ø5 holes 8 mm from the corners, a Ø20 boss with a Ø8 bore.” Attach a photo or a napkin sketch if you have one. The agent writes the model with named dimensions.
Click a face, an edge or a body and it becomes a chip on your message, with its exact type, centre, normal and size. The agent works on that face, not a guess.
Press/pull, holes, fillets, chamfers, shells, revolve, loft, sweep, mirror and pattern from a Fusion-style toolbar; sketches with constraints; or change a number in the Parameters card. Written into the same script, undoable, visible to the agent.
This viewer runs the app's renderer on meshes baked from the real kernel. Hover and click faces: the chip and the [Selected geometry] block are exactly what a chat message carries.
Because the message carries the geometry, the agent can write faces().sort_by_distance((x, y, z))[0] and hit the face you meant, then confirm with inspect_model or a screenshot. Every rebuild renumbers faces, so the app matches chips again by type and centre.
Sometimes you know exactly what you want and do not want to say it. The toolbar works like a desktop CAD tool: pick, type a number, ↵. A command dialog walks you through each tool with a live prompt, chips for what you picked and unit fields. Under the hood the operation is appended to the body's expression in the script, so it is undoable, reproducible and visible to the agent.
_plate = plate.part
_plate2 = _plate + extrude(_plate.faces().sort_by_distance((7, 0, 19))[0], amount=5, dir=(0, 0, 1))
_plate3 = tap(_plate2, "M4", at=(18, 0, 4), depth=6, axis=(0, 0, -1))
result = {"Plate": _plate3.fillet(2, [*_plate3.faces().sort_by_distance((7, 0, 24))[0].edges()])}
Play the ribbon tutorial →
Hover a tool. Shortcuts match the app: B C O K create, Q H F X L V modify, I measure, D drawings, P slice.

Lines and arcs snap to the model; horizontal, vertical and coincident constraints appear as you draw. Pick an edge, press D, type a number and the geometry moves to match. The status line counts the degrees of freedom left; fully constrained items turn white, and anything that conflicts is refused with a reason. Finish writes the sketch and its constraints into the script, where the agent can extrude, cut, revolve or loft it.
Play the constraints tutorial →Select a face, press K: lines, arcs, rectangles, circles and slots with snapping. Coincident, horizontal, vertical, tangent, equal, concentric… and dimensions that drive the geometry. Drag a point and the solver keeps every rule. It is also a real Sketch the agent can extrude, cut or revolve.
ISO metric (M4) and Unified inch (1/4-20, #10-32): tap drill, clearance, hex and socket heads, nuts and washers from the tables. tap(part, "M4", …) cuts the hole and drawings call it out as M4×0.7.
Every top-level number is a field. Named configurations override them: pick a variant to rebuild, export every variant as STEP or STL in one go. Measure snaps to vertices, edges and faces: lengths, radii, angles, hole spacing, mass, clearance between bodies.
Planes, cylinders, cones, spheres, tori and B-splines from OCCT. The display mesh has exact normals; the geometry underneath is analytic.
Most parts stop here. File ▸ Export gives you what a slicer or another CAD package needs, and one press of Output ▸ Drawings turns the model into a drawing you can hand to someone.
The planetary gearhead below is 113 parts the agent built from one prompt: ISO screws with real threads, ball bearings with balls and cages, phased planets, all from the Design Kit. Then it checked every pair of parts for interference and declared the joints so it turns.
Press S: cut the model with a base plane or parallel to any flat face and slide through it; cut faces are hatched caps in each body's colour. Press J: exact overlap volumes for every pair of bodies, with thread engagement listed separately, and the overlap shown in red. The agent runs the same check before it calls an assembly done.
Joints live in the script: revolute, slider, couple for gear ratios and racks, drive to play. ▶ Animate has a slider for every free joint, plays the drive, and explodes the assembly automatically or by your offsets. Check collisions sweeps the motion for parts that hit each other.
One click for a studio render: about thirty materials (appearance in the script, sensible defaults from body names), environment lighting and soft shadows. Save a high-resolution image or record a video of the spin, the explode or the motion.
“Design a NEMA 17 planetary gearhead, 4:1, module 0.6…” The agent reached for the kit — kit.planetary_stage, kit.ball_bearing("688ZZ"), kit.socket_screw("M3", 40, real=True) — built it body by body, measured clearances, ran the interference check and fixed what it found. That design is an eval case in the repository: what the video shows is what the test grades.
The things you reach for once the first parts are done.
63 ready-made standard parts the agent calls by name: ISO screws with real threads, ball bearings by designation with balls and cages, gears and planetary stages, NEMA steppers down to the coils, servos, boards, extrusions, springs, O-rings. Plus 27 design guides it reads before designing, and a per-workspace kit it adds its own notes and parts to.
One Python file adds helpers, agent tools, build checks and panels. Hot-reloaded, listed in Settings, and the agent writes them on request — see it happen.
Parametric script parts and exact STEP parts with thumbnails and tags. Insert from the Browser with + Part, save any body to it, and the agent searches it before modelling a standard part.
Drop a .step on the viewer: as a new body in the current design, as a new design, or straight into the library. Exact, and referenced from the script so the design stays reproducible.
Attach photos, sketches or old drawings to a message. The agent reads them directly; the dimensions you type override what it estimates.
Claude Opus 5.5 by default. Settings for the model, effort, max steps, thinking summaries, web tools, standing instructions and MCP servers (stdio, http, sse) with live connection status. Restart the session in place.
Rename, delete and add bodies, set parameters, sketch blocks and toolbar operations are AST rewrites of the same file. Every build is kept in history; Undo steps back through it.
295 unit and API tests run in about three minutes with no Claude calls. 39 agent evals run the real agent headless and grade geometry, programs, panels and answers deterministically, with cost and steps per case.

Ask for a mass-and-cost estimator, a bolt-pattern tool, a thin-wall check or a hole report, and the agent writes one Python file. It can add helpers every design script can call, tools the agent itself can call, checks that run after every build, and panels: sliders, numbers, pickers that take a face or a body from the viewer, tables whose rows select the geometry they describe, buttons. Panels are declared, not coded, so they render from the toolbar's Extensions menu with the app's own look and keep working across releases. Files hot-reload; Settings lists them, and a broken one shows as broken instead of breaking a design.
@panel("Round corners", icon="◜", description="Fillet the vertical edges of a body")
def round_corners(ctx):
s = ctx.state
body, radius = s.get("body"), s.get("radius", 2.0)
info = ui.text("Pick a body in the viewer.", muted=True)
if body:
b = ctx.body(body)
info = ui.kv([["Body", body], ["Vertical edges", len(_vertical_edges(b.shape))]])
return ui.panel(ui.picker("body", "Body", what="body"),
ui.slider("radius", "Radius", radius, 0.5, 6, step=0.5, unit="mm"),
info, ui.button("Apply", call="round_corners_apply", primary=True))
That is the panel in the clip, as the agent wrote it during the recording (lightly abridged); its Apply wraps the body in a round_vertical_edges(plate, 3) helper it also defined. Built-in examples ship with the app: Parameters (every number as a live slider), Hole report, Bolt pattern.
Describe the job the way you would brief a machinist and the agent writes a second script, cam.py, against a small API: face, contour, pocket, adaptive, drill, parallel3d, and new in 1.0 chamfer_edges and vcarve (letters cut along their centrelines, as deep as each stroke is wide). On the 4th axis, 1.1 adds rotary_profile (a hex, square or cam from round bar) and gear_teeth (involute teeth with a module cutter from the side of the blank, simulated to within 0.02 mm), with the chuck, jaws and tailstock checked in 3D on every move. Or click + Add operation in the CAM tree and skip the chat. The CAM workspace shows the program as a tree with the tools it needs in order, the Inspector edits each operation, and the timeline simulates and plays it back. The post (GRBL; Makera for the Z1 and Carvera Air; Haas; LinuxCNC) checks travel, spindle range, feeds and depth before you press run.
Your tools, as on the packet. Settings ▸ Tools describes each bit the way its packet does: a V-bit's angle and tip Ø, a ball nose's radius, the cutting height. Type the label and Fill does the rest; feeds are sized by the width actually cutting at depth; a cropped photo of the packet shows at every tool change, so you fit the right one.

The first lines of the exported G-code:
The Machine workspace connects to a Makera Z1 on your network: the status strip, the camera with a jog pad, and four steps. Prepare: home, change tool (the machine's own change, every tool and probe measured on the setter, the packet photo on the card). Zero: what the setup wants next to what set the origin this session; Find the block probes three corners of a block in the L-bracket and puts X0 Y0 on the front-left from the measured faces; on a rotary setup Zero on the 4th axis runs Makera's own 4th-axis Z probe for Z0 on the chuck centreline, sets Y0 from the controller's rotation offset, A0 and X0, one confirmed step at a time, with A on the DRO and the jog pad. Run: a readiness checklist, the program's operations in tool runs, an air cut first, progress op by op. Manual for everything else.
The assistant can work the machine too: hold, pause and STOP act at once; everything that moves waits as an approval card until you click Approve. Every spindle start lifts first, moves over the work, then comes down.
Personal projects, hobby making, research, education, and use by charities, schools and public institutions. Full source, every feature, no account, no telemetry. PolyForm Noncommercial 1.0.0.
Using it in a business, in products or services, or as part of paid work. One licence per person who uses it, billed yearly in Australian dollars, same software. Buy online with the number of users you need; tax is added at checkout where it applies, and the receipt is your licence record, nothing to install or enter. Questions and volume or site licences: agenticcad@prodevelop.com.au. Terms of sale.








Simulated replays of real sessions: the chat, the tool calls, the code and the exact meshes at every step were generated by the kernel, not drawn. Play them, pause them, scrub them.