How the agent works: route, plan, preview, verify, accept

The agent is not one big black box that spits out geometry. It is a loop with distinct stages, and each stage is visible to you. Knowing the stages helps you phrase requests, spot where something went wrong, and trust the result.

Route  ->  Plan  ->  Ghost preview  ->  Execute tools  ->  Verify  ->  You accept  ->  Commit to the Recipe

1. Route (a fraction of a second, free)

A fast router first decides what kind of request you made. It classifies every input into a short, flat list of intents, for example:

• build something new,
• edit geometry,
• change a parameter,
• add a rule (design intent),
• measure or ask a question,
• check manufacturability,
• connect, split or join pieces,
• make concept images,
• turn an image into a model,
• render, draw, export,
• history (undo, branch, compare),
• help ("how do I...?").

It also works out what "this" refers to and what kind of image you dropped. It gives each decision a confidence. High confidence runs automatically. Low confidence asks you a question first. Routing is always free.

2. Plan

For anything beyond a trivial edit, a deeper model plans the work: which steps to add, which parameters to create, which existing steps to touch. It reasons about your design intent, your parameters and the geometry that is there now.

3. Execute on a working copy

The agent then carries out its plan using typed tools: sketch, extrude, revolve, sweep, loft, shell, fillet, chamfer, hole, pattern, mirror, boolean, split, join, connect, add a bought piece, set a parameter, add a rule, measure, check manufacturability, and so on.

These run against the real geometry engine, on a working copy. So the agent gets real feedback: "that fillet is too large", "the boolean produced nothing", "the part is now 83 mm wide". It can adapt before you ever see a result. Your actual model is untouched.

Every tool call becomes a readable Recipe step or a history event. Nothing is hidden.

4. Ghost preview

The result of the working copy is shown to you as a translucent overlay with a summary of what changes. See Reading the agent trace and the ghost preview.

5. Verify

Before presenting, the agent renders the result and compares it with your request, using a vision model. It writes a short note on what it checked. If the check fails, it can fix the problem before bothering you, or tell you honestly that it is unsure.

6. You decide

Accept commits the new steps to the Recipe. Tweak adjusts the proposal. Reject drops it. Until you accept, your model is unchanged.

Safety, by design

• The agent can never delete history. It suppresses steps instead.
• All changes are previewed and reversible.
• Text inside images and files is data, not instructions. A sketch with "ignore your rules" written on it changes nothing.
• Credit checks and rate limits run before expensive operations.
• Concept image prompts are moderated.

What this means for how you ask

Where Smart and Fast fit

Fast and Smart choose which models perform the planning and verification steps. The loop is the same in both. Effort changes how much thinking and checking each stage does. See Smart vs Fast, and how much effort to ask for.

What the agent cannot do

• It cannot know dimensions you did not give or show. It will ask, or flag its assumption.
• It cannot see your real-world part. A photo plus a reference object gives scale, but calipers give truth.
• It is not a structural analyst. Quick simulation features are coming later, so for load-bearing parts design generously and test.

Try it

Make the loop visible. Open the trace panel, then send:

Watch for: the route line (intent and confidence), the tool calls (sketch, hole), the verify line, and the credits. Then send an ambiguous request on purpose:

The agent should ask you what "better" means rather than guess. That is the confidence threshold doing its job.