get startedno api key · no account

Try mojulo headless in a web agent, or install it locally.

You don't install mojulo yourself; your agent does, asking before each step. It can do that in two places: headless, in the throwaway Linux box a web agent gives itself — nothing on your machine, and the box is gone when the session ends — or on your own machine, where the whole loop lives. Same install, same recipes, same exports. 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 and the box. No API key, no account, no external telemetry, either way.

npx mojulo init
requires·node 22.12+·apache‑2.0·runs where your agent runs·no account

two ways inheadless in a box · or the whole loop on your machine

Try it headless

in a web agent's sandbox · nothing on your machine

A web agent — Claude Code on the web, ChatGPT, Grok chat, Meta Muse — gives itself a Linux box, throwaway on most hosts. Mojulo installs there, and the agent is the only surface: no dashboard, no window, no still pictures. What you make comes back as files through whatever door the agent has, and as the recipe in its report. The box is gone when the session ends; the recipe is what you keep, and any mojulo re-mints it byte for byte.

Needs a Linux box with Node 22.12+ and npm reachable. Whether the box has internet is the host's rule, not mojulo's. While it lives, what you made sits on that vendor's machine under their policy; mojulo itself still sends nothing anywhere.

npx -y mojulo init --yes --no-ui

Install it locally

macOS · windows · linux · the whole loop

Your own agent — Claude Code, Codex, Grok Build, Hermes, any MCP host — installs it on your machine. This is the whole loop: the dashboard at localhost:3001, the still pictures, the workers on your PATH — Blender, a slicer, an engine — and everything under one directory, ~/.mojulo/.

It is also where a recipe from a box comes home to: paste it in, and the same thing regrows here, exactly.

npx mojulo init
either way·no api key·no account·no external telemetry·loopback only

four stepsinstall · orient · mint · edit

1

Paste the prompt for where your agent is

Don't install anything yourself — hand the job to the agent you already run. In a web agent the prompt is one sentence; the one for your machine checks first and asks before every step.

Headless, in a web agent. The sentence is nearly the same everywhere. What differs is the door the file comes back through, and the line under each host says which, and what was seen in a run. Then ask for one small thing, and ask for the recipe JSON in the reply — that is the one door every box has, and all a local install needs to regrow the thing.

Claude Code on the webheadless · door: the artifact tool

ran · 2026-09-21

open a linux box and install mojulo npm package in it

That sentence is the whole install: the agent opens its box, runs init --yes without a keyboard, and reports. On 2026-09-21 a Claude Code web session did this, minted a 47-part phone at true scale, and handed the glTF back; the artifact tool is the door, one self-contained page at a time.

ChatGPTconnected MCP, or headless in work mode · door: the report

ran · 2026-09-22

on work mode, open a linux box and install mojulo npm package in it

ChatGPT asks before it opens the box — hit accept. On 2026-09-22, in work mode, it installed mojulo, wired it, reached the loopback dashboard and minted one keyless thing. Outside work mode its box had no internet, so nothing installed there — the box's egress is the plan's rule, not mojulo's. Handing a file out of this box has not been run yet; the recipe in the reply is the door. With a mojulo MCP server already connected, ChatGPT uses that instead; the ChatGPT guide covers both.

Grok chatheadless · shell only · door: a file card

ran · 2026-09-21

open a linux box and install mojulo npm package in it

Grok chat's sandbox has a shell and no MCP client, so after the install it drives the same registry from the command line — npx mojulo call <tool>. On 2026-09-21 it minted a city and exported it this way; the file card is the door, and world.html opens from disk with no server. This is Grok chat, not Grok Build — the CLI is a real MCP host on your own machine, and takes the local prompt below.

Meta Museheadless · persistent VM · CLI only · door: Artifacts and the Library

ran · 2026-09-23

open a linux box and install mojulo npm package in it

Muse drives one persistent Linux VM behind all its clients, with a shell and no MCP client, so it runs mojulo from the command line — npx mojulo call <tool>, starting with npx mojulo orient. Unlike the other boxes, that VM keeps ~/.mojulo/ between conversations. Pages leave through its Artifacts tool and files through its Library.

On your own machine. 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 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.
4. When it finishes, tell me to open a fresh session and ask you:
   "what is this?"

Never install anything on my machine without asking me first.

What comes down, in either place: a 6.7 MB package that lands at about 227 MB on disk with its dependencies, measured on one machine, and no model — search ranks by the words in your ask until you opt into mojulo install recall. The dashboard is a separate package, fetched only when you open it. The browser that bakes still pictures is not in the install: an explicit render fetches one the first time it needs it (about half a gigabyte) if none is on the machine, never at install, and a Chrome, Chromium, Edge or Brave already there 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. 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. That shell route is exactly how Grok chat's sandbox runs it. When init has no terminal to ask — a pipe, CI, an agent's box — it changes nothing without --yes: it prints its plan and exits 2. npx -y mojulo init --yes --no-ui is the explicit spelling.

In Claude Code, the plugin. /plugin marketplace add zombico/mojulo, then /plugin install mojulo@mojulo, starts the same server pinned to one version. Use the plugin or init for Claude Code, not both: two registrations run two servers.

Already on 2.x? An unpinned npx mojulo moves to 3.0 on its next start, and 3.0 re-encrypts your saved provider keys one way, so back up ~/.mojulo/secret.key with the database first. The chatbot factory is no longer part of mojulo as of 3.0 and is moving to its own project. Earlier 2.x versions that include it are unmaintained and have known security issues. The steps are in Upgrading from 2.x.

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. Headless, the agent asks the same question from inside its box and reports the answer back.

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 to pick up again next week — on your disk, or in the report the box handed back.

Headless, ask for the page, not a still: the box may have no browser to bake a picture with, but the exported world.html is self-contained and opens from disk. Every export the agent writes tells it which door this host has, so it knows how to hand the file back. And keep the recipe — the box will not.

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, or a shell. Claude Code or Codex get the most out of it; Claude Desktop and other hosts wire by declared profile. With no MCP client at all, npx mojulo call drives the same registry.

Your machine. Built and verified on macOS, Apple Silicon. Linux: the test suite runs on Ubuntu in CI, and a cold install 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.

Or your agent's box. A Linux box with Node and npm reachable, headless: no dashboard you can open, no still pictures, files and the recipe out through the host's door. Ran on Claude Code on the web (2026-09-21), on ChatGPT in work mode (2026-09-22), in Grok chat's sandbox, shell only (2026-09-21), and on Meta Muse's persistent VM, shell only (2026-09-23). A Codex cloud task: by its documentation, internet off by default. Blender installs in those boxes; slicers and the game engines do not, and the export packs are written either way.

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

6.7 MB tarball, 21.3 MB unpacked, ~227 MB installed with its dependencies (153 packages) — measured 2026-09-30 against mojulo 3.0.0 on macOS arm64. A cold start downloads about 79 MB and leaves about 140 MB in npm's cache, and answered initialize in a median 4.5 s through a local registry stand-in; the real registry is slower. The creative helpers (audio, exact booleans, images) are inside that figure; npm install --omit=optional sheds about 115 MB of them. The dashboard, mojulo-ui, is 12.7 MB packed and 57.0 MB unpacked, fetched only when you open it.

No model. A default install fetches none; search still answers, ranking by the words in your ask. The embedding model is the opt-in below.

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 an explicit render 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 under ~/.mojulo/; the full sheet names the variables that move them. Under the Claude plugin neither is ever fetched on its own: it uses a browser and an ffmpeg you already have.

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.

Search that ranks by meaning — mojulo install recall adds the embedding model: ~480 MB of runtime and a ~130 MB model under ~/.mojulo/, kept across upgrades. Most sessions never need it; the agent reads the tool index directly.

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 external telemetry. Starting the server makes no network call. Outbound traffic happens only on a named action: npm fetching the package, the one-time downloads above, check_for_updates when your agent calls it, the dashboard package when you open it, and whatever your agent's own provider does — that traffic is the agent's, not mojulo's. The one log the software keeps, of its own tool calls, stays on your machine; the full list is in the repo.

In a box, egress is the host's rule. A Codex cloud task ships with internet off; ChatGPT's box outside work mode had none. Mojulo needs npm reachable once, at install, and nothing after.

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.