An AI agent that plans your 3D build, then runs it

Ask a generator for a low-poly printable dragon and you get a mesh and a shrug. The mesh is the easy part. What stands between it and something usable is a sequence — retopologise it so a game engine will take it, repaint it, make it watertight so a slicer will, export the format the next tool wants — and every one of those is a decision someone has to make in the right order.

An agent that makes them for you silently is not an improvement; it is the same problem with the receipt hidden. The 3D Agent answers a sentence with a plan you can read: named steps, one line of reasoning each, and the exact parameters it intends to use. Nothing is spent until you say run.

One sentence in, a named plan out

You type up to 2,000 characters describing what you want and say what you are starting from: an idea, a photo, or a model you already have. What comes back is a short conversational reply plus an ordered plan of at most six steps drawn from a fixed catalogue of seven tools.

Text → 3D creates a base model from a description. Image → 3D turns a photo into a textured mesh. Remesh rebuilds the topology — low-poly, game or clean quads. Retexture repaints with a full PBR set while leaving the geometry alone. Print-prep / repair makes the mesh watertight, optionally hollow. Auto-rig builds a skeleton for a humanoid and can apply a walk, run, idle or jump clip. Export writes GLB, OBJ, STL, FBX, USDZ or 3MF.

Every row is typed, and the chain is walked

Each tool declares what it consumes and what it produces, in three kinds: nothing, an image, or a model. The planner's output is then walked against the kind currently in hand, and any step whose input cannot be satisfied is dropped rather than queued to fail.

This is what stops the plausible-looking nonsense. A plan that starts from a photo and opens with Text → 3D is discarding your photo; a plan that rigs before anything has produced a mesh cannot run at all. Neither survives the walk, so neither reaches the step where it would have cost you a generation.

The plan is the product

Every row carries three things: the tool's label, a one-line why, and the parameters as they will actually be sent — mode: game, face_limit: 20000, format: stl. You read the plan before it runs, which is the whole difference between an agent and a slot machine.

It also means the plan is a teaching surface. Somebody who has never heard the word retopology can see that a step called Remesh is there because the model is going into a real-time engine, and that it is targeting twenty thousand faces. The reasoning is not hidden in a system prompt; it is a line in the row.

What the model proposes is data, not instructions

Every plan a language model returns is coerced against the tool catalogue before anything can run. Text parameters are cut to 2,000 characters. Integers are clamped to the declared range — face_limit lives between 1,000 and 200,000 and defaults to 20,000. An enum that is not one of the declared choices falls back to that parameter's default rather than being passed through.

A tool name the catalogue does not have is not a tool. The guard is the table on the server, not the sentence in the prompt asking the model to behave — the same rule the graph auto-pilot and Operator follow, because a model that invents an action is a model, not an attack.

No model, still a plan

When the language model is unavailable, the agent does not apologise — it falls back to a deterministic keyword planner, and the fallback is worth knowing because it tells you what the vocabulary rewards.

Say print, printable, watertight, hollow, STL, 3MF or slicer and you get a repair step followed by an export in the format you named. Say low poly, game, real-time or optimise and you get a remesh targeting twenty thousand faces. Say rig, animate, walk or run cycle and you get an auto-rig with the clip you asked for. Say retexture, paint or recolor and you get a PBR repaint.

And a question that is only a question — no imperative verb, no build signal — returns no steps at all, because it was a question. An agent that answers “how big should a print be?” with a queue of generations is an agent nobody leaves running.

Run all steps, in your own account

Approve the plan and it runs where your work lives. A fresh session is created, and each operation hands the next one the node it produced, so the chain is real rather than four unrelated jobs that happen to be listed together. Each row reports for itself — running, done, or failed on the row that failed — and a plan that starts from a model imports your .glb as the base node first.

Expect each step to take between thirty seconds and three minutes, and expect it to use credits: these are real generations, not a preview. Export is the one step that sometimes costs nothing — the working format is already GLB, so asking for GLB downloads what you have rather than converting it.

Every step is a node

The run does not overwrite anything. Each step lands as its own node beside the one it came from, which means the remesh sits next to the model it lowered, and the repaired mesh sits next to the one that had holes. You can go back to any of them and branch a different way — the same reversible shape the rest of Grafy uses, and the reason a plan you disagree with halfway through is a fork rather than a restart.

From there the model is in 3D Studio with its gizmos, per-part materials and separate-parts split, because the agent's job ends where the editor's begins.

“Printable” is a measurement, not a label

Repair claims to make a mesh watertight. The printability check is what tells you whether it did.

Given a model it reports whether the mesh is watertight, whether the face winding is consistent, how many open edges it has — those are the holes a slicer cannot fill reliably — how many separate shells it is made of, the triangle and vertex counts, its bounding dimensions and its volume. The verdict is ready only when it is watertight, consistently wound and has no open edges; anything else comes back as needs_repair with the issues named. Above a million triangles it also suggests a remesh, because a print does not need them and your slicer will be slower for every one.

Give it a target size and it scales the model so its longest side is that many millimetres, reports the resulting dimensions, and estimates filament: solid volume, material volume at your infill plus a fifteen per cent allowance for walls and top and bottom, and a weight for PLA, PETG and ABS at their real densities. It is a rough estimate and says so — no slicing is done — but it answers the question you actually have, which is whether this will fit on the bed and roughly what it will cost.

The standalone checker takes a GLB or glTF upload up to 64 MB, analyses it in memory, never stores it, and charges nothing.

Photos: one is fine, four are better

Starting from a photo, one image is enough and four are better, for the obvious reason — the model has to invent less of the back. One photo goes through the ordinary image-to-model path; two to four are sent as a multiview reconstruction instead. Both land as a node in the same session, so the plan continues into remesh, repair and export exactly as a text start would.

Where it sits next to the other agents

Grafy has three agents and they are not the same shape, which is worth being explicit about.

The 3D Agent plans a short, typed pipeline over a fixed catalogue and hands you the plan first — the domain is narrow and the steps are expensive, so approving them is cheap insurance. The graph auto-pilot chains image, edit, upscale, animate and narrate steps across a canvas, with a free plan preview and a credit estimate before it runs. Operator is the open-ended one: a goal, a task queue it re-plans after every result, and a hard credit ceiling checked before each model call.

Pick by how much you already know. If you can describe the object, you want a plan. If you can describe an outcome but not the steps, you want a run with a ceiling on it.

Frequently asked questions

Does the agent spend anything while it is planning?

Planning produces a reply and a list of steps; it does not touch the 3D endpoints. The cost arrives when you press run, and the note under the plan says so — each step is a real generation taking roughly thirty seconds to three minutes.

What happens if a step fails halfway through?

The row that failed says so and the run stops there. The nodes the earlier steps produced are already in your session, so you keep the work that landed and can retry from it rather than starting the chain again — the same partial-progress rule the graph auto-pilot follows.

Can I edit the plan before running it?

You steer it the way you would steer any chat: say what you want changed and the next reply plans it differently. Because the plan is short, typed and capped at six steps, re-asking is usually faster than editing rows would be — and every re-plan is walked against your starting kind again.

Which export format should I ask for?

STL or 3MF for printing, GLB for the web and for anything that will come back into Grafy, FBX or USDZ for a game engine or an Apple viewer, OBJ when the receiving tool is old. Asking for GLB explicitly is free, because that is already the working format.

Will the rig animate anything?

Auto-rig targets humanoid models, and the known animation presets — walk and idle — are applied as a clip. Ask for a motion it does not have a preset for and you still get the rigged skeleton, which is the part that is hard; driving it afterwards is a step in the editor rather than a failure of the plan.

Is the printability report the same as slicing?

No, and it does not pretend to be. It measures the mesh — watertight, winding, open edges, shells, dimensions, volume — and estimates filament from volume and density. Your slicer will still decide supports, layer height and walls; this tells you whether it is worth opening.

Open the 3D Agent and describe the thing you want to make.