Running

Press ▶ Run. For most graphs that starts a server job — close the browser, reopen later, and the canvas still shows progress and results.

Where the run actually lives

Control	Where it runs	Survives closing the tab?
▶ Run (full graph, no interactive gates)	Server job (`POST /api/run/workflow`)	Yes
≫	Same server path — explicit “run detached / approve-all”	Yes
▶ Run with approval / live-handoff gates	In the browser tab (so splice still works)	No — use ≫ + approve-all for unattended
Partial run (right-click Run from / Test)	In the browser tab	No

After a server run starts, you can quit the tab. Reopen the workflow: threadle re-attaches to any still-running jobs for that graph, keeps mid-run node statuses, and polls until outputs land on the canvas.

Inspect the same jobs from a terminal while the server is up — see Detached runs and the CLI.

Before the run starts

threadle performs a readiness check and refuses to start if something can’t possibly work:

Blocker	Fix
Agent node without a model	Pick one in the inspector
Required input not wired	Wire it, or mute the node
Required named port empty	Wire that port
Context node with no payload and no session source	Materialize it, or wire a session
Skill / rules node with nothing selected	Pick the file
Cycle in the graph	Break it — a cycle can never finish

Offending nodes flash red on the canvas and the Issues tab lists them (the dock opens on that tab). Soft problems — dangling outputs, unused params — appear in Loose ends and never block.

Server jobs also refuse context nodes without a payload and gates without approve-all — same rules as detached.

Params

If the workflow declares params, threadle asks for them first, pre-filled with defaults and validated against their types. A bad value stops the run before any agent is called.

Watching a run

The bottom dock shows the Run log: node starts and finishes, durations, token and spend lines, tripwire evaluations, and stderr from custom nodes. On the canvas, the running node glows and its inbound wire marches.

Keep an eye on Issues before you press ▶ again, and Loose ends for soft hygiene.

Gates park the run and show an editable box — see Splice.

Stop ends an in-tab run. For a server job, cancel from Runs, or threadle stop <jobId>.

Graph settings (≔)

Setting	Effect
ply	Max independent nodes executing at once inside one graph — see Ply
spend tripwire (USD)	Abort when the run’s tracked spend reaches this ceiling

Parallelism across workflows is “start several server jobs” (several ▶ / ≫ / threadle run --detach), not a higher ply.

Partial runs

Right-click a node:

Run from this node — that node plus every descendant
Test this node — only that node

These stay in-tab (the server executor has no scope filter). Out-of-scope nodes contribute their last known result read-only instead of re-executing. See Graph & wires.

After the run

Where	What you get
Output nodes	The captured text, rendered per the node’s render mode (persisted on disk for server jobs)
Canvas	Result session nodes for in-tab agent runs; server jobs write statuses/outputs back to the graph
Runs view	One row per job: status, duration, errors
Sessions	The real sessions agent steps created
Statistics	Tokens and costs for what you just spent

The Runs view listing every executed run

The Runs view keeps the whole history — workflow runs, agent runs and custom-node runs, with status, duration, tokens and result.

Re-running a graph whose agent has a linked session continues that conversation rather than starting fresh.

Running it again, elsewhere

Same graph, same server executor: Detached runs, threadle run, or portable JSON on another machine — portable graphs.

Detached runs — close the browser, CLI jobs, parallel workflows
Errors & retries — when a node fails
Recipes — job graphs with contracts
Examples — teaching set