Pipelines · Semantix

One agent answers a question. Several agents can check each other's work, split a job up, or keep revising until something is good enough. Pipelines are how you say which.

There are three, and they sit together in the palette's Pipelines group.

How a pipeline holds its agents#

Linear and Feedback Loop hold theirs as a chain: wire the pipeline node to the first agent, then wire that agent to the next, and so on. The chain follows agents only — an agent can feed both the next agent and a Text Output, and the output box is simply passed over. It ends when an agent has no onward wire to another agent.

Parallel works differently, through numbered branch slots rather than a chain. See below.

An agent that belongs to a pipeline stops being a top-level step — it runs when the pipeline says so, not on its own. That happens as soon as you draw the wire; you don't declare it anywhere.

Linear#

Linear runs its agents one after another, each one receiving the previous one's output.

That's the pipeline you want when the second agent's job depends on the first agent's answer: research then summarise, draft then edit, plan then execute.

Note

Even a flow with no pipeline node in it runs as a linear sequence underneath — the top level of every flow is one. Dropping a Linear node is how you make a nested sequence, or keep a group of steps together inside a bigger flow.

Parallel#

Parallel runs its agents at the same time, all reading the same input.

Its node looks different from the others: instead of one output handle it grows a numbered slot per branch — branch 1, branch 2, and always one faint + branch waiting for the next wire. Below those sits a separate tap handle, which is where you wire an output box.

Every branch starts from the same frozen snapshot of the flow's state, so branches never see each other's results. On the canvas you'll see several agents light up together.

Note

Branches can only be agents. The canvas won't let you draw a branch wire to anything else — the connection is simply refused, so this is a rule you meet as a wire that won't attach rather than as an error.

Important

Parallel has no merge step, and only one branch's answer survives. It does not gather the branches into a combined result. What leaves the Parallel node is whichever branch happened to finish last with something in it — which is not stable between runs. The other branches' answers are not passed on anywhere.

So use Parallel for work whose value is in the doing — several agents each writing their own file, each running their own checks — and watch them individually with an output box wired to the tap handle. Don't wire the Parallel node into a next step expecting to receive everything it produced.

Feedback Loop#

Feedback Loop runs its chain of agents over and over, up to Max Iterations times (default 4, set in the Inspector).

The usual shape is two agents: one that does the work, one that criticises it. Each pass, the critic's notes become the next pass's input.

Two things make it work:

Every pass starts fresh. Agents in a flow keep no history at all, so each iteration is a genuinely new look at the text it's handed rather than an argument the agent is having with itself.

A critic can end it early. Turn on Can Stop Feedback on the agent whose judgement should decide, and it gains a way to declare the work finished.

Note

There's a second, less obvious way a loop can end early: an agent whose final answer is a JSON object containing a content field is read as a structured result, and that is treated as a signal to stop — whether or not Can Stop Feedback is on. If a loop keeps ending after one pass, look at whether the agent is replying in JSON.

While it runs, the node's pill reads loop 0/4, loop 1/4 and so on.

Note

The iteration counter starts at zero, so the first pass shows loop 0/4 and the last shows loop 3/4. Four passes, counted from nought.

Containers are not pipelines#

Group and Flow in the Containers group are dashed boxes that hold nodes on the canvas. They look organisational, and they are — visually, and only visually.

They never execute. The engine steps straight past them; the nodes inside run exactly as if they were loose on the canvas.
They have no handles, so they can't be wired to anything.
They can't nest — a container won't go inside another container.
Membership comes from dragging, not from dropping. A node joins a container when you drag it so its centre lands inside the box; after that the container moves as one unit. A node dropped straight from the palette into a container's rectangle is not a member until you nudge it.
Both offer the same eight colours in the Inspector.

Important

Deleting a container deletes everything inside it, and there is no undo. Drag the contents out first if you only meant to remove the box.

If you want nodes to actually run as a unit, you want a Linear pipeline, not a container.