Wiring & data binding
Connect nodes with edges, then bind upstream values to each node's inputs in the mapper.
Building a workflow is two related acts: wiring nodes together so data can flow between them, and binding specific upstream values to a node's inputs. Wiring says "these steps are connected"; binding says "this value goes here."
Edges
You connect nodes by dragging an edge from one node's Output handle to another node's input handle. The edge represents data flowing from the producer to the consumer.
Every node that takes input has a single input handle (the Input node has none). Multiple upstream nodes can connect into that one handle — you don't wire to individual fields. Which upstream value actually feeds each of the node's inputs is decided afterward, when you bind. This keeps the canvas readable no matter how many inputs a step draws on.
Types are checked on bindings, not wires: if a value you bind doesn't fit the input — an object where text is expected, say — validation flags the mismatch.
Data binding
Wiring makes a value available to a node; binding chooses where it's used. Click an input on a node's card to open the mapper for it. On the left, the Sources list shows every node upstream of this one — not just the ones wired directly in — and you can expand a source to reach its individual fields. On the right is the value for the input you're binding.
A binding can be:
- A reference — click a source, or one of its fields, to use its value. It
shows as a chip such as
Input.topic. - A literal — a fixed value you type in directly. Numbers and true/false inputs get a matching control.
- A template — Use a template to combine text + references builds a piece of text with upstream values embedded in it; clicking a source inserts it.
- An object — for inputs that take an object, build it key by key, each key a reference or a literal.
File inputs only take a reference — pick the upstream value that carries the file. Click Save to keep the binding, or Cancel to discard it.
Bindings created for you
For common cases, drawing an edge sets up the obvious binding automatically:
- Wiring into an Agent node binds its input to the upstream step's output (if you haven't bound it already).
- Wiring into the Output node adds a key named after the source.
Other nodes — integrations and components especially — record the connection and leave the precise binding to you. Wiring never overwrites a binding you've made.
Data edges and tool edges
Most edges are data edges: a value flows from one step into the next. An Agent node also has a Tools handle, and nodes wired into it become tools the agent can call, rather than steps that feed it data. Tool edges and data edges stay distinct; you can't cross one for the other. See Tools on the canvas.
When something isn't bound
Validation keeps you honest about bindings:
- A required input with nothing bound is an error — it blocks deployment until you bind it.
- A node that's wired in but not used by any binding is a warning: the edge says the value is available, but nothing reads it.
Deleting an edge also removes any bindings that referenced it, so you won't be left pointing at a value that's no longer there.