daemon: in a workflow can send work somewhere else again.
When a workflow run has to choose, Reliant resolves it in a fixed order, from the most specific instruction to the least:
daemon: on a single node wins over a daemon: on the whole workflow, which wins over the machine the chat or automation was started with, which wins over your default machine.
Automations
When you enable an automation you choose its machine, or No machine if the workflow allows it. The runs it starts use that machine’s tools, whichever machines your chats use. If you leave it unset for a project that has several candidates, you are asked to choose; an unattended run is never sent somewhere by guesswork.The daemon: field
A workflow, or any node in it, can name where its tools run. The shorthand takes a kind or a machine name:
local, cloud and any are kinds; any other string is matched against machine names. The kind follows who runs the daemon, not where the computer is: local is a machine whose daemon you run yourself (the desktop app or reliant daemon start), even a server in a data center, and cloud is a Reliant cloud machine. Here the workflow defaults to a machine you run, and the build node overrides that to run on a cloud machine.
For more control, use a selector. Every field you give must match:
id, name, type (local, cloud or any), labels and pool. labels, alone or next to id, name or type, narrows the match: every label listed must be present on the machine. A machine advertises the labels it was started with (reliant daemon start --label gpu=true) when it connects, and a selector’s labels match those while it is connected. pool places the work instead, as described below.
The value can also be a CEL expression, such as "{{ inputs.where }}", which may produce a string or a map with the same keys.
Pinning a pool instead of a machine
A name or an id pins one machine. When that machine is replaced, renamed, asleep or busy, every run that names it waits for it, even while another machine that could do the work sits idle. For work that any of several machines can do, such as a CI gate or a nightly build, pin a machine pool instead:daemon: {pool: <name>} places the work on one member of your machine pool of that name. It is chosen the way a pool-bound automation’s run is: the least-loaded member that can take work, skipping members that are not synced to the pool’s agreed workflow catalog, and never more than the pool’s max_runs_per_member live runs on one member. When every member is full the run waits for a slot, and a sleeping member is woken. pool stands alone: combined with id, name, type or labels it is a validation error, because the pool chooses the machine itself. Naming a pool you do not have fails validation when the workflow is saved, and fails the run if the pool is deleted afterwards.
Placement happens once. A workflow-level pool picks a machine when the run starts, and every later step of the run uses that machine. A node-level one picks a machine the first time the node runs, and every iteration of a loop around it reuses that machine. A pool on a loop or workflow node places the node itself, once, and every step inside it runs on that machine unless the step names its own daemon:. A run whose only machine work is placed on pools this way never waits for the chat’s own machine, so an asleep or removed chat machine does not hold it up. The placement holds one of the member’s max_runs_per_member slots for as long as the run is live, and a run’s later placements on a member it already holds take no second slot.
The order is the one above: a node’s daemon: wins over the workflow’s, which wins over the chat’s or automation’s machine. A run an automation already placed on a pool stays on the member it was placed on when the workflow names the same pool, so the run never leaves its checkout.
Pinning a machine by name or id keeps working unchanged.
reliant workflow lint warns about it, so a workflow that should survive a machine swap moves to a pool.Machine status
A running daemon and the gateway exchange a heartbeat every 15 seconds. A daemon that stops cleanly shows as disconnected at once; one that vanishes without saying so (a crash, a dropped network) is treated as gone after 90 seconds without a heartbeat, six missed in a row.