Amagine3D Review 2026 — Open-Source 3D-Native Agent That Turns Requirements into Editable CAD

Quick Verdict

Amagine3D is the open-source 3D capability layer from Amagine, the startup whose pitch is “from natural language to working smart devices.” Give it a product description, reference images, and key dimensions, and it designs an enclosure and assembly structure around your internal components — producing editable build123d Python source, checking its own work against a real geometry engine, and exporting STEP, STL, and color-aware 3MF. It hit 556 stars and 29 forks within a week of its 2026-08-19 debut, which tells you how hungry the maker community is for something that outputs manufacturable CAD rather than decorative meshes.

The honest framing: this is stage one (parametric CAD for intelligent enclosures), and the README says so plainly. But the architecture — a 3D-native agent loop that reads measured geometry and revises until checks pass — is the most interesting take on agentic hardware design we have seen this year.

Features

The 3D-native agent loop

Amagine3D’s core idea: the agent’s state is the 3D design state, not a chat transcript. The loop looks like this:

Requirements + physical constraints
  → accepted 3D design state
  → create candidate version
  → read model → plan changes (autonomous inner loop)
  → run checks in real geometry runtime → analyze measured results
  → checks pass? commit as new version (save state + artifacts)

Two levels are deliberately separated: the autonomous inner loop produces candidate designs, and the commit stage decides whether a candidate becomes the new baseline. The agent can iterate aggressively without damaging a design that already passed its checks. Crucially, the loop is driven by measurements — part connectivity, assembly interference, motion paths, and even read-back of exported files — rather than by the model’s textual judgment of its own output.

Parametric CAD with preserved source

Every generation keeps the complete Python/build123d source code. Key dimensions appear in the workbench where you can adjust them and write the change back into source without re-invoking the model. The design process is hardware-first: internal components and their mounts come first, then the enclosure, controls, and thermal-management structures. Multi-part designs develop covers, hinges, or latches together with assembly clearances and printing tolerances; for rigid mechanisms (hinged or sliding covers) the system checks collisions and operating clearances along a defined motion path.

Export: real manufacturing formats

• Single-color designs → STEP and STL
• Multi-color designs → color-aware 3MF plus a separate STL per color region

Exported files are read back into the geometry runtime as part of the check loop, so what ships is what was verified.

Web refs (optional)

With TAVILY_API_KEY set, the composer exposes a Web refs control. Enabled for a turn, it forces the agent to search before CAD mutations, returns ranked dimension/specification sources, and passes up to three available reference images to the multimodal model. Missing images do not block the workflow — the README is explicit that a CAD skill run proceeds regardless.

Pricing

Amagine3D is free and Apache-2.0, self-hosted:

• Stack: React/Vite UI → Express API → 3D-native Agent runtime → session-scoped Python CAD workspace (build123d + OCP + trimesh + lib3mf). npm install && npm run dev, configure .env, open http://127.0.0.1:6160 (API on 6161).
• Real costs: your LLM gateway spend — the example config uses openai/gpt-5.5 through an OpenAI-responses-compatible endpoint with LLM_THINKING_LEVEL=medium — plus Tavily if you enable web refs.
• The commercial layer: Amagine (amagine.ai) wraps electronics, enclosure, firmware, and assembly into one workflow. It is still in early access; its project library lists starter builds like a plant monitor (¥90 budget, 2h build), an ESP32 companion (¥180), and a 7.5-inch E-Ink dashboard (~¥240), giving a sense of the target audience: makers, not factories.

Use Case: Enclosure for a Desktop Status Device

The project’s flagship example is a multipart enclosure for BUSY Bar, an open-source desktop productivity multi-tool with a Pomodoro timer and custom status apps. Amagine3D:

1. Received public information about the device plus user-provided dimensions.
2. Organized a design brief: display area on the front, physical controls on top, internal space arranged around the components and interfaces.
3. Generated build123d source, built the geometry in the browser, and ran connectivity/interference checks.
4. Iterated on measured results until checks passed, then committed the version with its source and manufacturing files.

That is the workflow to expect: describe → brief → generate → verify → export, with you approving commits and adjusting key dimensions in the workbench.

Pros & Cons

Pros: editable parametric CAD with preserved source (not a dead mesh); an agent loop grounded in measured geometry and real check results; hardware-first ordering that produces enclosures, not sculptures; true manufacturing export formats including color-aware 3MF; optional web-grounded search; Apache-2.0 with a clean self-host path and no desktop CAD dependency.

Cons: parametric CAD only today — organic shapes, scans, and point clouds are roadmap items; you supply the model gateway (gpt-5.5-class spend is real); no published benchmarks on success rates or iteration counts; the hosted commercial product is early access, so end-to-end production claims are unverified; browser-side geometry runtime can struggle with heavyweight assemblies.

Alternatives

Tool	Output	Editability	Local/Cloud	Best for
Amagine3D	STEP/STL/3MF + build123d source	Full (source preserved)	Local + your LLM API	Enclosures, assemblies
Meshy / Tripo / Luma Genie	Text-to-3D meshes	Low (mesh sculpting)	Cloud	Concept art, game assets
Fusion 360 / Onshape	Full CAD	Full (manual)	Desktop/Cloud	Professional manual CAD
build123d (bare)	Python CAD scripts	Full (code)	Local	Developers who write their own code

The differentiator is the agent loop plus editability: mesh generators give you a nice thumbnail but no engineering; traditional CAD gives you engineering but no agent. Amagine3D is the first open project we have seen that tries to give you both — with source code as the design state.

FAQ

Do I need a GPU? No. The heavy lifting is model calls to your LLM gateway plus browser-side geometry; there is no local GPU inference requirement.

Can it design organic shapes? Not yet. The current release is parametric CAD focused on enclosures and assemblies; generative meshes, scans, and point clouds are the stated next stage.

What does it cost to run? The software is free (Apache-2.0). You pay for LLM API usage (the reference config is gpt-5.5-class) and optionally Tavily for web refs.

Can I edit the design after generation? Yes — key dimensions are exposed in the workbench and write back into the build123d source without another model call, and the full source is yours.

Is it production-ready for manufacturing? It exports real manufacturing formats (STEP, STL, 3MF with print tolerances in the design), but the project itself is early — expect to review geometry before sending anything to a service like JLCPCB.