Triggers and pulled data

Every wire in Boltjar carries one of two things: an event that says “run now”, or data that a node reads when it runs. Once that clicks, every graph reads the same way.

Triggers push

A trigger starts a turn on its own: a Chat Input when you send a message, a Webhook when a request arrives, an Interval or a Schedule on the clock, a Manual when you press Fire. What it fires travels along the red event wires.

A node that does work, such as an LLM, an HTTP Request or a DB, has a trigger input. It runs when an event lands there, and when it finishes it fires its own trigger output, so the next node can run after it. That chain of events is the order of the graph.

A data wire never fires a node. Every node that acts, a Log or a Preview included, has a trigger of its own, and a trigger input takes only an event wire: the editor will not let a data wire land there, and a graph saved with one does not turn On.

1. An event wire: pressing Fire runs the Prompt, which asks for a subject line for an email telling customers the shop is closed on Friday.
2. A data wire: the Prompt’s text, ready for whoever reads it.
3. The LLM runs when the Prompt’s trigger reaches it, and reads its prompt at that moment.

Data is pulled

The other inputs of a node that fires are data. They are not pushed to it: at the moment it fires, the node pulls them. A pulled input asks the node upstream for its value, and if that node is a data node, such as a Text, a Template or a Compute, it runs right then to produce it.

So in Text → Template → LLM.prompt, nothing happens until the LLM fires. Then the LLM pulls its prompt, the Template assembles its text, and the Template pulls the Text. A Template never sits on a clock; it runs when something needs its words.

1. The LLM fires and pulls its prompt.
2. The Prompt runs when Fire’s event reaches it and fills in its text.
3. To fill in {note} it pulls the Text node, which runs right then. The Text node has no trigger at all: edit the overdue invoice in it, and the next Fire writes the reminder for the new one.

One value per turn

Everything that happens because of one event is a turn. Within a turn, a data node runs once and every reader gets the same value, so three nodes pulling one Template see one text. A sensor such as Time or Screen Capture is the exception: it reads fresh on every pull.

Data before the trigger

A trigger that carries data sets its data outputs first and fires last. The Chat Input sets text, then fires trigger; the Webhook sets body, json, headers and query, then fires. So a node fired by the trigger always reads the new values.

The four ways a node runs

Each page of the node reference says which one a node is:

Runs	When	Examples
trigger	on its own: a message, a request, the clock	Chat Input, Webhook, Schedule
fired	when an event lands on a trigger input	LLM, HTTP Request, DB, Write File, Log, Preview
pulled	when a node that fires reads its output	Text, Template, Chunk, Read File
routing	never: the runtime joins the wires around it	Router, Wireless In, Wireless Out

A few nodes shape the flow of events themselves: For-each loops, Sync waits for several branches, Queue lets one job through at a time, Wait delays, and Logic fires its true or its false event, so the turn goes one way or the other.