Execution

When a workflow runs, FlowTrux executes the node graph starting from the Trigger: each node runs once all of its upstream nodes have completed, parallel branches run concurrently, and every node's output is stored so downstream nodes can reference it with {{steps.nodeId.output.field}} (see Template Variables).

The execution panel

Click Run in the editor to start the workflow. The Executions panel on the right side of the editor shows what's happening, in two tabs:

• Current - the run in progress (or the most recent one), streaming live: each node appears in the log the moment it starts, and its result fills in as it completes.
• History - all past runs with status (success / failed / cancelled), duration, and expandable per-node logs.

A running workflow can be stopped with the Stop button - the current node is halted and no further nodes execute.

Reading a node's result

Expand any node in the log to see:

• Input - the data the node received.
• Result - the node's output rendered readably, open by default (see below).
• Output - the raw JSON, collapsed. Useful when you need the exact field names for a {{steps.…}} reference.
• For Logic nodes: the condition, its resolved form, and a TRUE/FALSE verdict.
• For Agent nodes: the LLM request (model, prompts) and any tool calls it made.

The Result section

Instead of making you dig through JSON, the panel detects what a node produced and renders it accordingly:

• HTML (e.g. a generated email body) - rendered as a safe, sandboxed preview, with a Preview / Source toggle to inspect the raw markup.
• Tables (e.g. report output) - rendered as a data table. The first 30 rows are shown, with a Show all button for the rest.
• Files (e.g. a generated PDF) - shown as file cards with name, size, and a download button.
• Markdown / text (typical Agent responses) - rendered as formatted text.
• Anything else stays as JSON in the collapsed Output section.

Very large outputs are stored as a preview only - the panel shows an "Output truncated" notice with the original size.

Output Display (per-node override)

If auto-detection doesn't guess right (say, a JSON field that is actually markdown, or an array you want as a table), open the node's inspector and expand the Output Display section:

• Auto / Text - default automatic detection.
• Markdown - render a text field as markdown. Set Data path to point at the field (e.g. response); common fields like response, text, content are found automatically.
• Table - render an array field as a table. Set Data path to the array (e.g. response.items) and optionally define columns (key + label); leave columns empty to auto-detect them from the data.

This setting only affects how the result is displayed in the execution panel - it never changes the data passed to downstream nodes.

Error handling

When a node fails:

• The node is marked failed with an error message (visible in the log).
• The branch downstream of the failed node stops.
• Other independent branches continue normally - a failure in one part of the workflow doesn't necessarily prevent the rest from completing.

Execution history

Every run is recorded with its status, duration, and per-node logs (input, output, duration, errors, and for Agent nodes the token usage). From the History tab you can:

• Expand any past run to inspect individual node results - the same readable Result rendering applies.
• Delete a single execution, or Delete all to clear the workflow's history.

How long history is retained depends on your organization's plan.

Global Context

Global Context is a persistent key-value store scoped to the workspace. Unlike node outputs, which exist only within a single run, Global Context values persist across runs:

{{global.apiEndpoint}}

Typical uses:

• Configuration shared across workflows (API endpoints, IDs, connection strings)
• State between scheduled runs (last processed ID, counters)
• Sharing data between different workflows in the same workspace

Manage values in Settings → Global Context, or update them from a running workflow.

Related

• Template Variables - referencing node outputs
• Long Delays & Callbacks - runs that pause and resume
• Triggers - starting runs by webhook, cron, form, or manually