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
four stepsinstall · orient · mint · edit
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.
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.
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.
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.
model a hurricane lantern at real scale I can orbit in 3D
minting — seven stacked lathe profiles and one swept handle: brass, copper, glass, 40 cm tall. Open /sketches/sk_jon77cn4ud and orbit it.
the handle is floating
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.
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.
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.
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/.
~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.
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.
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.
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.
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.