Build
Fleet node reference
Deep reference for every node category and type in a fleet, with terminology, parameters, inputs, outputs, and configuration guidance.
Glossary
Terms used across the fleet editor with their exact meaning here.
true or false edge handles. It never calls an agent.Router. A Logic node that matches keyword classifiers against the current input text and routes to one or more downstream branches. It does not call an agent unless you pair it with agent nodes after it.Agent. A model-backed worker with instructions, memory, tools, and an optional JSON schema. Agent nodes run through the same LangGraph engine as the agent builder.Orchestration. Routing, looping, fan-out/fan-in, or model-supervised refinement inside a fleet. Orchestration nodes never invoke a provider themselves — they decide which agents do.Control. Deterministic gates: verify citations, enforce schemas, ask a human for approval, or format the final response. Control nodes are cheap and auditable.Utility. Presentation-only helpers (today: the sticky note). Utility nodes do not execute.Input. A node's input is the concatenated output of every executed predecessor, rendered through the runtime. You can always reference it with {{input}} and stored fleet state with {{state.yourKey}}.Output. A node's output becomes the next node's input. Pick a named outcome on the outgoing handle (e.g. no_evidence) when you want a specific branch for one result.Named outcome. The label written onto an edge handle that the runtime matches with the sourceHandle when a node finishes. Named outcomes only appear for nodes that declare multiple results (e.g. success / unavailable / no_evidence).The runtime in one page
Every node belongs to one of six categories. A run moves through the graph in topological order: triggers execute first, branching is decided by deterministic nodes, agents do the work, and control nodes gate the final answer.
Trigger
Entry and exit marks. The engine always begins on a trigger, and you usually end with a response node or a trigger marked as the end.
Logic
Deterministic branches and HTTP actions. Logic decides routing without spending a token.
AI
Model-backed work: agents, MCP tools, web search/fetch, browser, knowledge retrieval, and code execution.
Orchestration
Structure how agents run in parallel, sequence, or a draft-and-review loop.
Control
Quality and safety: verify citations, apply schemas, require approval, or structure the final response.
Utility
Documentation on the canvas (no execution). Use sticky notes to explain branches or caveats.
Trigger — mission start
The trigger is the only node without a configuration form beyond its labels. Mark it isStart and the runtime begins there; anything without an incoming edge becomes the implicit start.
- No parameters. The trigger runs instantly and passes the input through.
- Use the output to feed the first AI node — the input text is the user's message.
- Mark a node `isEnd` to declare the terminal. If no node is the end, the last executed path forms the run output.
- A single trigger per fleet is recommended; multiple starts create ambiguity about which branch begins.
Logic — conditions, API calls, and routing glue
Logic nodes do not call a model. They follow the input with deterministic checks or HTTP requests and write structured evidence the rest of the fleet can consume.
Condition node (if-else)
Evaluates a predicate against the current `input` (or a stored state field) and follows the edge connected to its true or false handle. This is the cheapest way to branch.
| Parameter | Type | Default | Behavior |
|---|---|---|---|
| conditionKey | string | required | Dotted path into input/state (e.g. state.risk_level), or a raw field lookup. |
| operator | string | equals | One of: equals, not_equals, >, <, contains, in. |
| conditionValue | string / any | required | The target RHS value. Templates allowed with {{state.key}}. |
Inputs: the current input plus stored state. Outputs: condition_result (boolean) and pass-through output; the branch is chosen by outgoing true/false handle.
API action (external HTTP)
Makes an outbound HTTP call to a validated endpoint. Failures attach a named edge outcome so the run can branch into a fallback without crashing.
| Parameter | Type | Default | Behavior |
|---|---|---|---|
| endpoint | string (URL) | required | HTTPS only. Private IPs, localhost, and metadata ranges are rejected. |
| method | string | POST | GET / HEAD / DELETE use query params instead of a JSON body. |
| headers | object | — | Host header is blocked for safety; the runtime injects authentication from your stored secrets. |
| body | object template | { 'input': '{{input}}' } | The HTTP JSON body, supports {{input}} and {{state.key}}. |
| expected_status_codes | number[] | 200–299 | Any response outside the range emits the failed outcome. |
| require_approval | boolean | false | If true, pauses for an explicit approval before calling. |
Inputs: the body template + headers. Outputs: status_code, output (clipped response), and outcome handles (success / unavailable / failed).
AI nodes — the model-backed workhorses
AI nodes spend tokens. No fleet runs spend tokens until an AI node (agent / MCP tool / knowledge retrieval / web / browser / code) actually executes. Output can be plain text or validated JSON.
Inline agent
An agent created in-place. It needs a provider, model, and instructions. Gateways and knowledge bases can be attached inline or left empty.
- Use fallback_provider to survive provider outages.
- Keep max_input_tokens conservative so the run token budget stays predictable.
- Attach gateways/KBs only when the agent genuinely needs them.
MCP tool node
Calls a discovered tool on a connected MCP gateway. The gateway, tool name, and allowlist are required — you can only reach tools the connector exposes.
Inputs: arguments template + tool_name. Outputs: tool result text, plus named outcomes success / unavailable / denied.
Knowledge retrieve node
Searches attached knowledge bases and returns the top-K chunks with scores. Attach the right KBs to keep the context small.
Parameters: limit (1–10), minimum_score, fail_on_empty. Outcomes: success or no_evidence.
Web search / fetch / browser nodes
Web search uses a configured provider (Tavily by default) or DuckDuckGo, and marks its results as citable evidence. Web fetch extracts the contents of a URL into text. The browser node runs an isolated Playwright session — you pass a URL, an allowed-domains allowlist, and an ordered action list of clicks/fills, and it returns the final page body.
All three write evidence objects for the Verify node. The browser is domain-blocked — anything outside the allowlist is aborted before leaving the sandbox.
Code node
Runs a Python snippet in a sandboxed container. The snippet sees `INPUT` (a dict with `input` and `state`) and must assign `RESULT`. It can write to fleet state with `store_in_state`.
Parameters: source_code, timeout_seconds (1–30), store_in_state (key name). Disabled entirely when ALLOW_CODE_EXECUTION=false.
Memory / state node
Reads or writes the typed per-run state dict. Operations: set, delete, select, append, transform. Value types are cast to string/number/boolean/json/list before writing.
Parameters: operation, key, value (template), value_type. State keys are referenced by other nodes via {{state.key}}.
Orchestration — shape the flow
Orchestration nodes are cheap control flow. Use them to run agents in parallel, loop with a hard cap, or chain critic-refine drafting.
Router
routes[].label, routes[].classifier_keyword, routes[].target_agent
Reads the incoming text, matches keywords in order, and follows the first route. Writes routed_to and route_label so downstream nodes pick the right branch. Keyword matching is case-insensitive and substring-based; if nothing matches, the first route wins.
Parallel (fan-out / consume-merge)
merge_strategy
Executes every outgoing branch and concatenates their outputs. merge_strategy is declared but the engine always emits the -joined outputs of all predecessors.
Critic-refine loop
agent, critic, critic_threshold, max_iterations
The agent drafts, the critic writes a SCORE: N verdict, and the loop repeats while N is below critic_threshold. Up to 3 iterations (hard cap).
Loop (bounded)
agent_id, max_iterations, stop_field, stop_operator, stop_value
Runs an agent repeatedly until the output satisfies stop_value (e.g. completion signal). Has a 10-iteration hard cap and oscillation detection.
Control — guardrails and final output
Control nodes run deterministic checks on the flow. They do not call a model — except for the optional model judge on verify nodes. Use them so the fleet never publishes unchecked work.
Verify
contains, equals, schema, minimum_evidence, citation_coverage, allowed_domains, custom_assertions, judge_agent_id, judge_threshold
First runs free deterministic checks (schema validation, evidence count, citation coverage, optional field assertions). Optionally calls a judge model to score outcome quality. Marks every evidence item verified:true on pass. On failure, emits verify_failed and the runtime follows the corresponding branch.
Response
output_mode, output_schema, response_description
Declares the fleet's final public output. With output_mode="structured" and an output_schema JSON Schema, the run only completes when the output validates.
Human in the loop
prompt, assignee, sla_minutes, editable_fields
Pauses the run for a human decision. Assignee gets an escalation email if the SLA expires. Approved runs can optionally carry edited_output back into the flow. A request_changes decision passes the note to the next step.
Utility — canvas notes
The sticky note is the only utility node. It renders on the canvas but never executes, so use it to document onboarding, known limitations, or why a branch exists.
Inputs, outputs, and named outcomes
The runtime hands every node a single input — the concatenated output of every finished predecessor, so a parallel branch merge automatically becomes the parent's input. Signature the same way: every node returns an output object; the object it writes is what downstream nodes read.
| Node | Input | Output | Outcome handles it can emit |
|---|---|---|---|
| Trigger | The run input | {"output": input} | — |
| Condition | input + state | {"condition_result": bool, "output": input} | true, false |
| API action | body template | {"status_code": number, "output": string} | success, unavailable, failed |
| Agent | Prompt + tool calls + context policy | {output, structured_output?} | success, unavailable |
| MCP tool | arguments template | Tool result text | success, unavailable, denied |
| Knowledge retrieve | Query from input | {query, hits[]} with richness scores | success, no_evidence, unavailable |
| Web search/fetch | query / url template | {query, answer/results/text} + evidence | success, no_evidence, unavailable, denied (fetch), failed |
| Browser | url + actions | Page body text + screenshot evidence | success, unavailable, denied |
| Code | {"input", "state"} | RESULT assigned value | — |
| State/memory | input + state | Updated value / pass-through | — |
| Router | input | Pass-through + routed_to/route_label in context | — |
| Parallel | input | concat of inputs | — |
| Critic-refine | input | final draft text | — |
| Loop | input | latest agent output | done, limit_reached, no_progress |
| Verify | input + evidence | {"outcome","detail"} | pass, verify_failed |
| Response | input | public answer / structured JSON | — |
| Human in loop | input | approved / edited_output / rejected | — |
| Sticky note | — | None (canvas only) | — |