Your First Workflow
A workflow is a canvas you wire up and press Run. This page builds one the fast way — which is also how they get built in practice, a node at a time, running as you go.
1. Start with the Start node
This is the entry point. Any single node can be run on its own whenever you like — but running the workflow means running it from here, and the Run button in the bottom toolbar only appears once a Start node is on the canvas. So it is usually the first thing you place.
2. Put the next node on the canvas
Drag a Code node out of the sidebar and bring it near the node you want it to follow. As you get close the target picks up a ring, and a dotted line runs from where you are hovering to the handle it would use. Drop it there and the connection is already made.
That is the easy way, and it is on by default — there is a toggle in the bottom toolbar if you would rather place nodes without connecting them.
There is a second way, once you know the canvas: drag out from the edge of a node and let go on empty space. A picker opens where you dropped and whatever you choose arrives connected.
Either way, connection points sit on all four sides of every node and the edge attaches to whichever side makes sense — so you never have to aim, and a node cannot connect to itself.
3. Set the node up
Every node type is configured differently, and the panel on the right changes with whatever you have selected. A Code node picks a language. An Agent node picks a model. A Files node picks a folder. There is no one settings screen to learn — the node tells you what it needs.
A Code node runs JavaScript, TypeScript, Python, Three.js, Shell, Go, Rust, C, C++ or Zig. It's a dropdown on the node, not a project setting — so steps in different languages sit in the same flow, and changing one is not a rebuild.
4. Ask the node for what you want
Every node type carries a wizard (✨). Type a line — Mandelbrot fractal — and it writes the code into the node, in the language you already chose. What it writes is ordinary code, sitting in the editor, yours to change.
You can also just write it yourself. On a free plan that is how you build a flow: the canvas, the nodes and the runs are all there, and you supply the code. A paid plan adds the wizards, which is the difference between typing a sentence and typing a function.
5. Run it, and see what came out
Every node has its own run button. Press it and that one step executes on its own — you don't have to run the whole flow to test the piece you just added.
Wire a code node into an Image node and its output renders on the canvas. A Chart node plots it; a 3D node runs it as a scene. The result sits next to the code that made it.
The loop that makes this fast
Run each node before you add the next one.
Once a node has run, its output is real — and the next node's wizard can read it: the shape of the data and the values in it. So what that wizard writes lands on your actual fields instead of a guess at them. The inputs carry the context, which is why the instruction can be a sentence instead of an essay.
That is the whole loop, and it is worth getting into the habit early:
add a node → run it → add the next.
It is also why you don't need to invent test data to get started. Run the first step for real and everything after it has something true to work from.
See the shape of your data, and drag it in
You never have to remember what the last step produced, or type a path from memory.
Run the step above, then open this node's config panel. The output of that step is sitting there as a JSON tree you can expand — the real thing it just returned, not a schema. Drag any field out of it and drop it into the code box or the prompt. In code you get the path itself; in a prompt it arrives already wrapped as a template variable.
That is the same reason running as you go pays off: before the step above has run there is nothing in that panel to drag.
Typed by hand it is {{input.something}}, which works in any prompt or field, and reaches your environment variables too — so keys and endpoints never have to be typed into a node.
- Template variables — every form of them, and where they resolve
- Environment variables — setting them, and what belongs in one
6. Turn it into an API
Replace the Start node with a Webhook node and the same flow becomes an endpoint in the cloud. It carries a public address, and a Reply node returns the response — the graph you drew is the thing answering the request.
As soon as you save, it is live. There is no deploy step and nothing to rewrite: the URL serves whatever you last saved, so an edit takes effect the moment you save it.
When you don't know what the caller sends
Connecting something else up to this — another system, a service you don't control — usually means guessing at the shape of what it posts.
Don't. Set the Webhook node to listen for a request and it waits for a real one. Fire the call from the other system and the node captures it: the method, the headers, the query, the path and the body, exactly as it arrived.
Now you have the same thing step 5 gave you — a real payload to look at. Expand it in the config panel, drag the fields you need, or open the wizard on a Code or Agent node and say what should happen to the request. It is working from the actual call, not from your description of it.
Reading a run
Press Run and the flow animates as it goes: green dotted lines travel along each connection as data moves, and every node picks up a badge — a success count, or an error.
Hover a node to inspect what it output. On a phone, long-press it.
Nothing here needs a separate log window open to follow. The canvas is the progress view.
When it doesn't work
A dropped node didn't connect. You were too far from the target for it to offer — move closer until the ring and the dotted line appear, then drop. If they never appear, auto-connect is switched off in the bottom toolbar.
A node didn't run. The Start node needs at least one connection, and a node showing red will tell you what it is missing when you click it.
A step got the wrong shape of data. Run the step above it, then reopen the wizard. Before that node has run there is nothing for the wizard to read, so it is working from a guess.
You are not sure what a field is called. Don't guess it — run the previous step and drag the field out of the JSON tree in the config panel.
Next
- Node types — everything you can drop on the canvas
- Debugging — breakpoints, running a single node, running from a node onward
- Building workflows — branching, loops, and flows that call other flows