Node reference

A workflow is built from nodes, grouped in the palette by what they do. This is the catalogue — the same icons and colors you see in the editor. Every node reads earlier nodes’ values with {{ nodename.field }} references and publishes its own fields for later nodes to read the same way.

Flow

Input Output Condition Loop

AI

LLM Agent

Code

Python Template

Actions

Email Image Search

Integration

Tool HTTP Sub-workflow Store Document Query Documents

Reading the outputs

Each entry lists what the node publishes. If a node is named llm, you read its text elsewhere as {{ llm.text }}. Rename a node and the references use the new name.

Flow

The nodes that move data in, out, and around your graph.

Input

Declares the parameters your workflow takes — name, type, default, and description. You supply these values when you run the workflow. Required parameters (no default) are checked before a run starts. A parameter’s type can be string, number, boolean, array, object, image, or file. An image parameter shows a file picker at run time — you upload a picture and the parameter’s value becomes the uploaded image’s URL, which you can feed to a vision model (see the LLM and Agent Images field) or anything else that takes an image URL. A file parameter works the same way for any file type (CSV, xlsx, PDF, JSON, …) — the run dialog shows a file picker, you choose one file, it uploads, and the parameter’s value becomes the uploaded file’s URL. Publishes: parameters — read a value as {{ input.parameters.<name> }}.

Image & file params are also staged for Python

When a run has an image or file input parameter, Catalyst doesn’t just give you the URL — it also stages the uploaded asset onto disk in the run’s Python sandbox at ./inputs/<parameter-name>.<ext>, so a Python node can read it directly with no download. The extension follows the upload: a photo param uploaded as a JPG lands at ./inputs/photo.jpg, the same param uploaded as a PNG lands at ./inputs/photo.png. So don’t hardcode the extension — glob it: glob.glob("./inputs/photo.*")[0]. This is the same read-only ./inputs/ directory that holds workflow-attached files.

Output

Collects the final results. Map each output field to a value from another node, e.g. {{ summary.text }}. This is what a run returns and what gets delivered. Publishes: result — the mapping you defined.

Condition

Branches the workflow. It evaluates an expression and sends the flow down a true or false path, so later nodes only run when they should. Publishes: branch (which way it went) and value (the evaluated result).

Loop

Runs a section of the workflow once for each item in a list — sequentially or several at a time. Covered in detail in Loops. Publishes: results (a list, in input order) and count.

AI

The nodes that think.

LLM

A single call to an AI model. Give it a prompt (with {{ }} references to other nodes), pick the model, and optionally set max tokens and reasoning effort. Use it for a discrete step — summarize, classify, rewrite, extract.

An Images field lets the model see pictures, not just read about them. Add one or more image-URL references — an uploaded image input parameter like {{ input.parameters.photo }}, or an image produced upstream like {{ generate_img.data.url }} — and Catalyst attaches them to the model as vision content. This is the only way to make a model actually look at an image; an image URL placed in the prompt text alone is just text to it. The model must be vision-capable for this to work — if it isn’t, the URLs are appended to the prompt as text instead of failing the run. Publishes: text (the model’s answer) and usage (token counts).

Agent

A model that can use tools in a loop until a task is done, not just answer once. Use it when a step needs to investigate, call tools, and decide its own next move. It has the same Images field as the LLM node — give it one or more image-URL references (e.g. {{ input.parameters.photo }}) and a vision-capable model can see them while it works. Covered in detail in Agents. Publishes: result/text (final answer), tool_calls, iterations, stop_reason, usage.

Tip

Rule of thumb: reach for an LLM node when you know exactly what one call should produce, and an Agent node when the step needs to figure out the steps itself.

Code

The nodes that compute.

Python

Runs Python in a private sandbox. It reads upstream values from an inputs dict, can read files attached to the workflow (mounted read-only at inputs/), and assigns its answer to a variable called result. Any files it writes are uploaded and exposed for later nodes (see Delivery & files). Use it for anything code does best — transform data, call a library, do real math, render a file.

The read-only ./inputs/ directory also holds any image or file Input parameters for the run, each staged at ./inputs/<param-name>.<ext> where the extension follows the upload — so don’t hardcode it, glob it. A file param named sales is pd.read_csv(glob.glob("./inputs/sales.*")[0]) and an image param named photo is Image.open(glob.glob("./inputs/photo.*")[0]), no download needed. (The param’s value is still also available as a URL via {{ input.parameters.<name> }}; the on-disk copy is the convenience for Python.) Note that workflow-attached files keep their original filename, so those are referenced directly — e.g. ./inputs/customers.csv. Publishes: result (your result variable), stdout, stderr, and files.

Template

Fills in a text template with values from other nodes, using {{ }} placeholders. Use it to assemble a prompt, an email body, or a final document from pieces. If a reference points at something that doesn’t exist, the run stops with a clear error instead of producing garbled text. Publishes: text — the rendered string.

Actions

Built-in things a workflow can do. (These are preset Tool nodes.)

Email

Sends an email — to you by default, or to recipients you specify — with a Markdown, HTML, or plain-text body and optional attachments. See Delivery & files. Publishes: result and is_error.

Image

Generates an image from a prompt — the same engine as image generation in chat. Publishes: result and is_error.

Search

Searches the live web and returns results your other nodes can use. Publishes: result and is_error.

Integration

The nodes that reach outside Catalyst.

Tool

Calls a tool from one of your connected integrations (MCP) — or a built-in tool. You pick the tool and fill in its arguments from other nodes’ values. Publishes: result and is_error.

HTTP

Makes an HTTP request — method, headers, body, timeout. Use it to call any API that doesn’t have a dedicated integration. A 4xx/5xx response marks the node as failed so the workflow can handle it. Publishes: status, body, and headers.

Sub-workflow

Runs another saved workflow as a single step and returns its output. Use it to factor a common sequence out once and reuse it everywhere — the same idea as a function call. Publishes: result and status.

Store Document

Saves a JSON document into one of your named collections — data that persists across runs and chat sessions. Defaults to append (one new document per run); switch to upsert with a stable key to overwrite current-state data in place. Covered in detail in Store data between runs. Publishes: id, doc, and created (true if a new document was written, false if one was updated).

Query Documents

Reads documents back out of a collection — by recency, date range, key, or a JSON filter — to feed a Python or Template node for a report. Publishes: docs (the matching documents), count, and first (the newest document’s body, for single-doc lookups).

How nodes connect

You rarely draw every connection by hand. When one node references another with {{ othernode.field }}, Catalyst infers the dependency and runs things in the right order. If any node fails, the nodes that depend on it are skipped (and shown as skipped) rather than running on missing data — so a workflow fails loudly and clearly, never silently.

Want to see it built end to end? Start with Build your first workflow.