Built by one. Run by everyone.
Whoever builds it decides what everyone else can change — a text field, a colourway, an upload, a slider. The rest is locked. One person sets it up; nobody has to ask them again.
Nobody has to become a technical artist.
The reason AI hasn't landed in most creative teams isn't the models. It's that wiring them into a pipeline takes a programmer, and most teams don't have one per project. This is the answer to that: the wiring happens once.
Sees a form, not a graph
A coordinator, producer, account manager or brand designer swaps copy, picks a market, uploads an image and generates.
It is a form with a few fields. Nothing to learn, no training session, and no way to break it — and it is a role that already exists on your team.
Just opens the link
If the output is a scene, it goes live as a web link — any device, no install, no account.
They never know a graph was involved. That's the point.
The graph is the contract.
An operator surface isn't a permissions setting bolted on afterwards. It's a description of what's allowed to vary — so the things that shouldn't change simply aren't reachable.
The author chooses what's editable
Any parameter can be promoted to the operator surface: a colour, a headline, an asset slot, a market. Everything not promoted is invisible, not merely discouraged.
Off-brand isn't an option they have
Brand consistency stops being something you enforce in review and becomes something the tool can't produce. There's no version where someone picks the wrong red, because the wrong red isn't in the control.
Constraints can be meaningful, not just cosmetic
Because it's a real engine, a constraint can be structural — this layout must accommodate any string, this composition must hold at nine ratios — rather than a locked layer someone works around.
The author can keep working
Improving the graph improves every future run. The people operating it get the benefit without a migration, because they were never editing a copy.
And it's portable
Save the setup as a Recipe and the next brief starts from the thing that worked. Hand it to a teammate, or open it up and see exactly how it was built. Recipes ship with the beta.
Where the bottleneck goes.
Today
Every variation routes back through the one person who can open the file. They become a queue. The work is beneath them, they resent it, and the team waits — so most variations simply don't get made.
With the hand-off
They build the system once and step out of the loop. The team generates what it needs, when it needs it, without asking. What that person produces becomes the capability rather than the assets.
You do not start from a blank canvas.
The word author makes this sound like a specialism. It is not. Building a setup is a visual job — you connect things and see the result immediately — and there are four ways the first one gets easier.
Start from a Recipe that already works
Open one, change the product, change the copy, and you have already authored something. Take it apart when you are curious about how it works. Most people never begin with an empty graph. Recipes ship with the beta.
Describe it and the assistant wires it
Say what you want in a sentence and it adds the nodes, connects them and sets the parameters. It can only use nodes that genuinely exist, so it will not send you chasing something imaginary.
Expose one control, then two
A useful setup can start with a single editable field. You are not designing a whole interface up front — you promote a parameter when someone asks to change it, and that takes seconds.
Nothing is a one-way door
It is a graph, not a build. Nothing bakes, nothing is destructive, and you can always go back and rewire. The cost of trying something is close to zero, which is the whole reason procedural tools are worth learning.
So who builds it?
Usually whoever on the team already enjoys working out how things fit together. That is a temperament rather than a job title, and it is more common on creative teams than people expect.
They will be at home in an afternoon
Anyone who has worked in a node-based tool will read a graph on sight — the concepts carry straight over. If they write expressions or scripts today, that fluency makes the deeper parts of the engine available, but it is not the price of entry.
Then start smaller than you think
Open a Recipe, change two things, expose one control, hand it over. That is a working hand-off, and it is a first afternoon rather than a project. If you would rather not start from scratch at all, on Studio and Enterprise plans we will build the first setups with you.
What teams ask.
Do I need to know how to code?
No. You build by connecting nodes and watching what happens — it is a visual medium, and the feedback is immediate. Expressions and scripting exist for people who want them, and open up the deeper parts of the engine, but plenty of useful setups never touch either.
How long before I can build something real?
Opening a Recipe and changing what varies is a first afternoon. Building a setup from scratch that someone else operates is more like a first week — and you will almost certainly do it by adapting something rather than starting from an empty graph.
What if I get stuck partway through?
Nothing here is destructive, so a half-finished graph is a fine place to stop and come back to. The assistant can wire the part you are stuck on, and support is a person rather than a queue — see support.
Can operators break the setup?
Not through the surface they're given — they only reach the controls the author promoted. Full editing access is a separate thing you grant deliberately.
What if an operator needs something the author didn't expose?
The author promotes another parameter, which takes moments and applies to every future run. That conversation — "I need to change this too" — is a much better bottleneck than re-cutting a set of files by hand.
Do operators need their own paid seat?
Operator and author seats are part of Studio and Enterprise plans. The split matters commercially as well as practically: you'll usually have one author and several operators. See pricing.
Can we hand an operator surface to a client rather than our own team?
Yes — it's a common agency pattern for the revisions round. Studio plans white-label the deliverable so what the client opens carries their brand rather than ours.
Is this the same as a template?
A template is a document with some editable fields. This is a running program with an interface: it can compute, respond to data, enforce a rule and produce motion, 3D or an interactive experience — none of which a template does.
Build it once. Let the team run it.
Free to start, nothing to install. Or tell us how your team works and we'll walk through the hand-off with your own project.
Working with a team?
Tell us where to reach you and we'll set up a walkthrough.
No spam. A real reply from a human.