Wires
A wire is an edge’s transport: what exactly connects two nodes. There are three channels — trigger (the node starts), value (a payload lands on an input) and token stream (the model’s answer reaches the chat as it is generated). Their combinations, plus a separate family of configuration links, give ten canonical types.
- Execute + Data
- LLM
- Memory
- Extension
- Execute + Data + Streaming
The ten types
| Key | Name in the editor | What it carries | Where it appears |
|---|---|---|---|
execute |
Execute | order only, no value | while_loop → loop body, the event input of the merge node |
execute_data |
Execute + Data | trigger and value on one edge | the most common wire: the output port of most nodes |
execute_data_streaming |
Execute + Data + Streaming | trigger, value and token stream | the outputs of ai_agent and llm_response |
data |
Data | value only, the target is not triggered | entry.data, chat history, service configuration nodes |
streaming |
Streaming | tokens only | llm_response.thinking, the catch_* nodes; accepted by exit and extra_section |
link_llm |
LLM | a model configuration | llm → ai_agent, llm_response, structured_output_llm, summary_memory |
link_memory |
Memory | a memory node | buffer, window and summary memory → ai_agent |
link_extension |
Extension | a tool, a skill or a sub-agent | tool nodes → the extensions, tools, skill_* inputs |
link_embedding |
Embedding | an embedding configuration | embedding → embed_text |
link_rerank |
Reranker | a reranker configuration | rerank_config → rerank |
The colour and dash pattern of an edge on the canvas follow this table: the execute wire is solid amber, data is a grey dash, streaming is green, and configuration links are the violet and teal shades.
Where the type comes from
You do not pick a wire by hand. The type is derived from the ports you connected: their
channels are intersected. A port that emits trigger and value, connected to a port that
only accepts a value, produces a data edge; the same port into exit produces
execute_data. The target port’s name takes part too: llm, memory, extensions,
embedding_config, rerank_config, and any port prefixed tool_, catch_, skill_ or
extension_ immediately yield the matching link.
An edgeType already stored on an edge is not recomputed. Two graphs that look alike
but were drawn at different times can therefore behave differently — when in doubt, delete
the edge and draw it again.
Rules that save time
Configuration links do not affect order. link_llm, link_memory, link_extension,
link_embedding and link_rerank take no part in scheduling: configuration nodes have no
execution input, and the consumer pulls such a node in itself, at the moment it needs it.
One llm node can serve several consumers at once.
A pure data leg may become a trigger. When a node has no other scheduler dependency,
an incoming data edge is promoted to an activating one — otherwise a graph whose value
arrives over data while order is set elsewhere would never run that node at all. The
promotion is conservative: it only adds a dependency where there was none, so graphs that
run today keep their exact ordering.
Streaming is a presentation channel. Tokens go to the chat alongside the value, not
instead of it: an execute_data_streaming edge delivers both. The connection dialog (click
the edge on the canvas) has a toggle that switches the stream channel off — the edge then
behaves as execute_data and the answer appears in one piece once the node finishes.