Swarm Canvas

Open Build → Agent Swarms. Drag a node from the palette, click it to open the inspector on the right, and configure it there. Connect nodes by dragging from one handle to another.

Flow state and templating

Every node can read from and write to a shared key/value flow state. This is what makes a graph more than a chain.

Anywhere a field accepts a template, these forms resolve:

All eighteen node kinds

input

The entry point. Optionally renders a typed form in the Run panel instead of one free-text box — each field's value is seeded into flow state under its own name.

agent

The workhorse: one LLM call, with optional tools, knowledge and memory.

Node memory scope

condition

Two-way branch. The LLM answers a yes/no question and the matching edge is taken.

Does the customer's message describe a fault with a physical product
(as opposed to a billing, delivery or account question)?

router

N-way branch. The LLM picks one of the outgoing edge labels; the matching branch runs and the others are marked skipped.

loop

foreach

Maps this node's agent body over each element of an array.

approval

Pauses the run until a human decides.

evaluate

LLM-as-a-judge scoring. Five metrics ship enabled, with these default weights:

function

Sandboxed JavaScript. Receives ctx = { input, vars } and must return a value.

// Normalise a messy list into the shape the next node expects.
const rows = ctx.input.items ?? [];
return rows
  .filter((r) => r.status === "open")
  .map((r) => ({ id: r.id, owner: r.assignee?.name ?? "unassigned" }));

set_var

Writes named keys into flow state. Each value is a template resolved against current state.

http

A deterministic outbound request — no LLM involved.

Method:  POST
URL:     https://api.example.com/v1/tickets
Headers: Authorization: Bearer {{secret:SUPPORT_API_TOKEN}}
         Content-Type:  application/json
Body:    {"subject": "{{summary}}", "body": "{{input}}", "priority": "{{priority}}"}
Path:    data.id

tool

Runs one built-in tool deterministically, with arguments you supply — no LLM decides.

extract

LLM structured output. Produces a JSON object matching a schema you declare.

name: customer_name   type: string   "Full name as written"
name: order_id        type: string   "Order reference, e.g. NW-10482"
name: refund_amount   type: number   "Amount in GBP, 0 if none requested"
name: is_urgent       type: boolean  "True if they mention a deadline"

merge

Combines this node's declared inputs into one value.

retrieve

Standalone knowledge-base retrieval with no LLM call.

subswarm

Runs another saved swarm as a single node; its final output becomes this node's output. It executes in isolation with the input you gather for it.

a2a_remote

Delegates to a remote agent server speaking the A2A protocol.

output

Terminal node. Its value is the swarm's result — what an API run returns and what a callback delivers.

Error handling

These apply to agent, http, tool, foreach, extract, evaluate, a2a_remote, function and loop:

Worked example — a support triage swarm

input ──▶ extract ──▶ router ─┬─[billing]──▶ agent(billing) ──┐
        (customer,          │                                │
         order_id,          ├─[technical]▶ agent(tech KB) ────┤
         refund_amount)     │                                │
                            └─[refund]───▶ approval ──▶ http ─┤
                                                              ▼
                                                            merge ──▶ output
                                                          (mode: first)

1. 1

   input

   One field: message, type textarea, required.
2. 2

   extract

   Schema as shown above. outputVar = ticket. Now {{ticket.refund_amount}} is available downstream.
3. 3

   router

   Three outgoing edges labelled billing, technical, refund. routerPrompt: "Classify this message as billing, technical or refund." Model: a small fast one — this is classification, so temperature 0.
4. 4

   agent nodes

   Each links a saved agent and sets its own knowledgeBaseId. All write to outputVar = reply.
5. 5

   approval

   Title "Approve refund", risk high, approverGroupIds = your finance group. No timeout, so it waits.
6. 6

   http

   POST to your refunds API with Authorization: Bearer {{secret:REFUND_API_TOKEN}}. onError fail — a silently failed refund is worse than a stopped run.
7. 7

   merge → output

   mergeMode first, since exactly one branch ran.

Running and observing

• Run panel — fills the input form, streams node status live (idle, running, done, error, waiting, skipped) and shows each node's last output.
• Recent runs — history with inputs and results.
• Traces — per-node steps with prompts, tool calls, tokens and cost. See Logs & traces.
• Versions — the graph is snapshotted on save; diff and restore.

Deploying

Deploy gives a swarm an API key so your own systems can run it, and Chat exposes it as a conversational surface. A schedule can run it unattended. Full detail in API & webhooks and Web embedding.

The canvas edits a draft; deployed runs execute the published snapshot. Creating the first key or schedule publishes the current graph, and after that your saves stay private until you press Publish — so you can rewrite a prompt at 3am without changing what a live integration receives. The Deploy dialog shows Draft ahead whenever the canvas has moved on, and API & webhooks covers the states.

Custom components

A Function node holds a snippet used once. Components are the reusable form: author a snippet with a declared parameter schema in the palette’s My components → Manage, and it appears in the palette of every swarm you build.

File inputs

A start-form field of type file lets whoever runs the swarm attach a PDF, DOCX or text document. The file is converted to text in the browser and that text is seeded into flow state under the field’s name — so downstream nodes read it like any other variable, and no document is ever uploaded to the server.

Batch evaluations

A swarm that works on the prompt you tried it with can still regress on the other forty. Evaluations (under Experiment in the sidebar) runs a whole dataset of test cases through a swarm headlessly and scores every output, so a prompt tweak is measured rather than guessed at.

Runs are resumable and cancellable: cancelling is enforced server-side, and a case that already has a verdict is never scored twice, so “run remaining” picks up exactly where it stopped. Approval nodes are auto-rejected by default — leave that on unless the swarm is safe to auto-approve in a batch. Each result links to its full execution trace.

Export

Troubleshooting