get startedno api key · no account

How to ask your agent to install the Mojulo workshop.

You don't install mojulo yourself. You paste one prompt into the coding agent you already run — Claude Code, Codex, any MCP-capable agent — and it does the install, asking before each step. Then you ask it for one small thing. What comes back is kept as a recipe — a small file that remakes it exactly, and outlives the chat. No API key, no account, no telemetry; what you make stays on your machine.

npx mojulo init
requires·node 22.12+·apache‑2.0·runs local·no account

four stepsinstall · orient · mint · edit

1

Paste this into your agent

Don't install anything yourself — hand the job to the agent you already run. Open Claude Code or Codex and paste this prompt. It checks the machine first, reports what it found, and asks your permission before installing anything — nothing enters your machine without a yes.

Help me install mojulo — a free, local 3D factory you'll drive over MCP.
Orientation, if you can fetch it: https://mojulo.ai/llms.txt
(mirror if the site is down: https://github.com/zombico/mojulo)

1. First just check: run `node --version`. Mojulo needs Node 22.12+.
   Tell me what you found before changing anything.
2. If Node is missing or too old, ask my permission, then install it
   the way this machine expects (brew / winget / nvm / apt).
3. With my go-ahead, run `npx mojulo init`. It wires mojulo into the
   coding agents on this machine (one yes/no per host) and opens a
   dashboard at localhost:3001. Everything stays on my machine.
4. When it finishes, tell me to open a fresh session and ask you:
   "what is this?"

Never install anything without asking me first.

What comes down: the package and its native runtime — about 985 MB on disk, measured on one machine — and, on first launch, a ~130 MB search model. The 3D render libraries are in the default install. The one thing that isn't is the headless browser the factory bakes still pictures with: it is fetched the first time a bake needs it (about half a gigabyte), never at install, and a Chrome, Chromium, Edge or Brave already on the machine is used instead. The measured figures, and everything else the machine needs, are in technical requirements below.

Prefer to drive it yourself? Install Node.js 22.12+ from nodejs.org and run npx mojulo init. Either way, everything runs on your machine — the dashboard opens at localhost:3001 (or the next free port; the installer prints the URL) and state lands in ~/.mojulo/. No account, no credential to hand over; re-running init repairs older wiring instead of duplicating it. The same install doubles as a command line — npx mojulo tools lists what's inside, npx mojulo call <tool> runs any of it, no agent in the loop.

2

Ask your agent what it's looking at

Open a fresh agent session — the new wiring is picked up on start — and type one line. Mojulo reads its own routing index and orients itself out loud — no provider key, no cloud call, nothing built yet.

what is this?

forward_context — the factory explaining itself. This is the intended interface: you ask, your agent discovers the right tool and reaches for it.

3

Ask for one small thing

Then ask for something that's yours. Your agent authors it, mojulo keeps it as a small deterministic recipe, and hands you a URL to open.

model a coffee mug in real centimetres I can orbit   → mint_solid

the recipe is the stored artifact — a few readable lines that regrow the same mug on every open. the render is derived and disposable; the recipe stays on your disk to pick up again next week.

If a 3D tool ever refuses and names mojulo install creative, run that. The render libraries ship in the default install, but an npm install --omit=optional or a failed native build can leave them out — and the refusal says so rather than failing quietly.

4

Then change it

"Make it taller." "Change the tint." Your agent edits a few lines of the same recipe in place and it re-renders; nothing is regenerated from a black box, and the lines it changed are there to read.

make the handle thicker and the glaze matte black   → update_sketch

A mug is the floor, not the ceiling. What else the factory makes — and where a finished thing can go next — the workshop names when you have something in hand, or when you ask. This page stops promising here on purpose.

the first flightask → mint → look → keep

This is how a real object was actually made, including the part where the first attempt was wrong. The correction isn't a failure of the method; it is the method.

you
model a hurricane lantern at real scale I can orbit in 3D
agent
minting — seven stacked lathe profiles and one swept handle: brass, copper, glass, 40 cm tall. Open /sketches/sk_jon77cn4ud and orbit it.
you
the handle is floating
agent
so it is — the hoop's ends sit at ±6.5 cm over a 3.6 cm collar. Re-seating the sweep… v2 minted. The hoop lands on the collar.
you
keep it

mint_solid — the ask is plain language, a thing and a scale. nobody typed a coordinate: the parts are placed by declared relations (on / gap / radial), and the factory resolves them.

what's stored is the recipe — 1.8 KB of profiles and one path. the lantern you orbit is derived from it on every render, and the render is disposable.

"the handle is floating" is the eyes gate — someone actually looks before a thing is kept. the recipe made the miss cheap: one path edited, v2 minted, and both versions persist as recipes you can diff.

and after "keep it," the doors — a kept thing can leave: a file for a printer, a page you can host, rooms bigger than that. nobody lists them up front; the workshop names the doors that fit the thing you're holding, at the moment you're holding it. the doors open onto tools you already run — blender, a game engine, a slicer — as files they already read, and what you refine there can come back and bind to the same recipe.

technical requirementswhat it needs · what it weighs · what's optional

The short version of what mojulo asks of a machine. Every figure was measured on one machine on a stated date; the full sheet, down to the size of each dependency, lives in the repo.

to run

Node.js 22.12 or newer. The one hard floor; an older Node exits with a message instead of half-working.

An MCP host. Claude Code or Codex get the most out of it; Claude Desktop and other hosts wire by declared profile.

A desktop OS. Built and verified on macOS, Apple Silicon. Linux: the test suite runs on Ubuntu in CI, and a cold install of 2.0.1 was checked on Linux x64 and arm64; the engine checks further down are not verified there. Windows: verified on a native Windows machine with Claude Code — npx mojulo init completed and a first render landed; Codex there, and the engine checks further down, have not been checked.

No GPU, no provider key, no account. Still pictures bake on the CPU. Your agent is the reasoning loop; a key enters only when something must paint.

on disk

36 MB tarball, ~985 MB on disk after npx mojulo init — measured 2026-09-11 against mojulo 2.0.2 on macOS arm64. The 3D render libraries are inside that figure; npm install --omit=optional sheds them (~86 MB) and mojulo install creative puts them back.

~130 MB search model, fetched once on first launch into ~/.mojulo/models/.

Kilobytes per recipe. Everything you make is one SQLite file under ~/.mojulo/data/.

fetched later, only if needed

~500 MB headless Chrome, the first time a bake needs it — skipped when Chrome, Chromium, Edge or Brave is already on the machine.

~19 MB ffmpeg, the first time clips are stitched into an MP4 — skipped when ffmpeg is already on your PATH.

Nothing downloads at install. These two cache inside the package directory rather than ~/.mojulo/; the full sheet names the variables that move them.

optional · you install, mojulo detects

Godot 4.5 or newer (free) opens a game pack as a project. Blender 4.x or newer (free) takes the art pass and the bake. Unity 6, activated, with the glTFast package from Package Manager. Unreal 5.4 or newer; a game pack compiles C++, so Xcode on macOS or Visual Studio on Windows.

A slicer — PrusaSlicer or Bambu Studio — stamps a headless print check beside the STL or 3MF; any slicer opens the file.

Every export works with none of these installed: the pack and its step-by-step import guide are written either way, and the machine check reports "skipped" with the reason. The engines are multi-gigabyte installs under their own licences; mojulo never downloads or configures one.

optional workers

Separate installs you run yourself; mojulo never starts or depends on them, and absence turns off one loop and breaks nothing. ComfyUI with Qwen-Image-Edit paints when your agent can't — ~31 GB, or a ~17 GB quant on Apple Silicon. Kokoro speaks the narration — ~92 MB. TripoSR sculpts surface detail over the greybox — ~1.4 GB.

network

No telemetry. Outbound traffic happens only on explicit actions: npm fetching the package, the one-time downloads above, check_for_updates when your agent calls it, and whatever your agent's own provider does — that traffic is the agent's, not mojulo's.

to remove

Unwire it from the host config, remove the npm package, delete ~/.mojulo/ and the two caches above. Engines and workers you installed yourself are yours to keep or remove.