Workflow Editor Tour

A workflow is a mini visual program — a pipeline of operations that runs code, calls AI, processes an image, connects to an online service — laid out as nodes on a canvas and wired together. Press Run and watch it execute in front of you. The board is where you design and test exactly how a part of your system should operate: every box is a real, running component you can open, configure, and inspect, so you iterate on the behaviour until it's right.

That precision is the point. A business needs certain procedures to run exactly as designed — an approval that can't be skipped, a check that runs every time — and feeding the rules to an AI in chat is not a promise they'll be followed. A workflow is the rules: every step explicit on the board, every run inspectable, the same procedure every time — with AI doing the work inside steps you control.

And a working pipeline is never a dead end. Hand it to the coding agent to implement that business logic exactly in your code; deploy it to the cloud as a webhook to form part of an application's backend; or expose it as an API for any kind of home or business automation.

Nodes connect from any edge, and connections route themselves automatically — drag a link out of whichever side is closest and the board keeps the wiring clean as you rearrange.

Here's that idea running for real — a pipeline that reads images from a folder on your machine, loops through each one, shows it, removes its background with AI, and saves the result back to disk. One click of Run and the badges count each image through the loop:

Reading the board left to right: the green Start button begins the run; a Files node points at a folder on your computer; the orange braces are a Loop — everything between { and } runs once per image; inside it an Image node displays the current picture, Remove Background does the AI work (you can see the transparent result on its thumbnail), and Save writes each finished file back to disk — its footer confirms every write. The green badges count how many times each node ran. Files on your computer are reachable from the cloud editor through the Circuitry desktop app or Circuitry Server. The full recipe for this exact pattern is in Batch File & Image Processing.

And the boxes aren't limited to prebuilt steps — real code is a first-class node. Write Python or JavaScript right on the canvas with syntax highlighting and a run button per node; here two Python nodes compute fractals, and the image node between them shows the rendered Mandelbrot:

Edit wherever suits the moment: directly in the node, in a side panel beside the board, in a full editor tab, or open the flow as a CodeBook — a notebook view of the same nodes. The red dots in the gutter are breakpoints: enable debugging ⌘⇧D and a run pauses right there, with stepping and variable inspection (see Debugging). Node output flows to whatever you wire it into — an image node renders pictures, a chart node plots data.

And when a step needs configuring, you don't have to do it by hand: every node has its own AI wizard , and it's aware of the node's inputs. Here two images — a selfie and a dress — feed an image node; its wizard already has both as inputs, takes the prompt "put the dress on the lady", and generates the composed result right into the node:

The same input-aware wizard sits on every node type, so implementing each step is a one-liner whether it's data, AI, images, or whatever the step happens to be.

Workflows also reach outward — they can connect to thousands of services. The Plugins Library ships a growing catalogue of ready-configured plugins from hundreds of well-known providers, browsable by category and searchable by name:

And a missing service is never a dead end: Create plugin hands the job to the AI wizard, which auto-configures it from API-spec databases or researches and reads the service's documentation itself; Import from API spec builds a plugin straight from a spec file — including your own private company endpoints. See Integrations & Plugins.

The board is also simply a great place to think in flowcharts. Design a flow and walk your team through it with sharing and live collaboration — or hand it to the chat agent to implement in code. It works in both directions: here we asked the coding agent to read a project's payment flow, draw it as a flowchart, and highlight any areas of concern — and this appeared on the board, problems flagged in red:

Edit the chart — reroute a branch, fix a flagged problem — and tell the AI to implement your changes, and it gets done. That's two-way visual communication in the format of a flowchart; Circuitry gives you the same two-way channel through every editor — code, notes, designs, workflows, flowcharts, and spreadsheets.

A tour of the controls

The node palette

The left panel is the node palette — the board's parts bin. Core Nodes covers agents, code, text, web, images, data and more; Control Flow holds Start, triggers, conditions, loops, forks and joins; UI Interaction adds human-in-the-loop nodes (confirmations, forms, choices); and Plugins lists your installed integrations, with Open Plugins Library to browse more and Create new plugin with AI to build one. Drag any entry onto the board, or skip the palette entirely and press Space (below). The rail above it switches the panel between your files, workspace, and the palette.

Every node in the palette

On the canvas, many of these draw as little pictorial glyphs when compact — you've already met the folder (Files), the floppy disk (Save), the polaroid (Image), and the orange braces (Loop) in the scenes above. Here's the whole parts bin, with the icon each one wears in the palette. Full reference: Node Reference.

Core Nodes

Control Flow

UI Interaction — human-in-the-loop steps that pause the run for a person:

Notice the pairings woven through the table — they're not coincidences. Circuitry nodes and wizards carry connection awareness: a Chart watches its upstream Sheet, a Loop reads what kind of collection is flowing in, an Agent gathers tools and knowledge from MCP and Store nodes wired into it, and every wizard reads its upstream inputs before suggesting anything. Connect the right neighbours and features light up on their own.

The bottom toolbar

A floating pill at the bottom-center of the board carries the everyday actions. (Shortcuts below show Cmd — use Ctrl on Windows/Linux.)

• Add Node — opens the node search overlay to add a new node. Space
• Agent Chat — toggles the workflow agent chat pane, so you can direct the board conversationally.
• Drawing Mode — switches to ink mode: the bottom toolbar slides out and the pen tray slides in. D
• Select Mode — drag to rubber-band multiple nodes. A
• Pan Mode — drag to move the canvas. H (or hold ⇧ for a temporary pan that releases when you let go)
• Undo ⌘Z and Redo ⌘⇧Z
• Auto-connect — when on, newly placed nodes wire themselves into the flow automatically.
• / — choose whether new nodes arrive expanded in detail view or small.
• — sets what double-clicking a node does: open its linked side editor, or expand the node in place (the icon becomes in that state).
• Run — runs the workflow. While running it becomes a red Stop button. The button appears once your board has an active Start node.
• Generate Code — exports the workflow as code (appears when the flow contains an agent or code node).
• Save — saves the workflow; the icon flips to a check briefly to confirm.
• Deploy — appears when the workflow has a deployable trigger with a hosting target; deploys it in one click.
• Deployment history — lists past deployments with one-click Roll back per version.
• A small ↻ Reset glyph appears after a run to clear the per-node execution statuses.

Adding nodes — press Space

If you prefer the keyboard, the board is mostly drivable without touching the mouse. Space opens the node picker — start typing to filter, ⏎ to place — and the new node lands continuing the chain from your current selection (⇧Space places it perpendicular, for branches). From there the arrow keys move your selection between nodes, ⇥ walks the flow connection by connection, ⏎ drops into the selected node to edit and Esc climbs back out. And with Vim mode switched on, you can code and navigate across many nodes and terminals without leaving the home row. The full list is in the Keyboard table below; Adding Nodes covers the picker in depth.

Run controls

While a workflow is running, a control pill appears at the top-center of the board:

• Stop — halts the execution.
• Follow — toggles follow mode: the viewport auto-centres on each node as it executes, so you can watch a long flow run hands-free. It turns green and reads Following while active.
• Pause, resume, and single-step controls are visible in the pill but marked coming soon.

Zoom, minimap, and full screen

• Bottom-left: Zoom In, Zoom Out, and Fit View — fit is ink-aware, framing your nodes and anything you've drawn on the board.
• Top-right: a minimap with nodes colour-coded by type; hover it and press to hide it. Both the minimap and the zoom column can be switched off in settings.
• Full Screen — top-right of the canvas; hides the app header, menus, and tabs for a clean board. ⌘⇧⏎ — press (or the same shortcut) to exit.

The node selection toolbar

Select a node and a row of pill buttons appears at the top of the canvas — a touch-friendly stand-in for the right-click menu:

• Rename — first in the row, for quick relabelling.
• Convert to — on sketch (flow) nodes, opens the node picker in convert mode to turn a diagram box into a real node type.
• Run from Here and Run This Only — execute from this node onward, or just this one node (R with a node selected).
• Configure — opens the node's configuration panel.
• Open Editor — jumps to the node's full linked editor for code, agent, chat, data grid, 3D, and web nodes; database and vector-store nodes get a direct Edit Database button.
• Duplicate and Delete.
• More — opens the full context menu right below the button for the long tail of actions.

Select two or more nodes and the row switches to layout tools: Align (left/center/right/top/middle/bottom), Distribute for even spacing (with 3+ nodes), and Auto Layout for one-click horizontal or vertical arrangement.

Drawing on the board

Press D and the board becomes a whiteboard: the bottom toolbar slides away and the pen tray slides in — and the rest of the drawing kit, the same tools you get on the whiteboard. Ink and nodes live on the same canvas, so you can annotate a running system, sketch the next part of the architecture beside the built part, then select the sketch and press To Node to convert labelled boxes and arrows into real nodes and live connections.

Drawing mode is also where the board's theme lives: the / toggle in the floating capsule flips the whole board between light and dark (your drawn ink recolours with it). The same switch is available any time from View → Dark Theme.

Keyboard

Shortcuts below apply while a workflow tab is active (Cmd = Ctrl on Windows/Linux).

Works with the rest of the studio

The board is one surface of one studio. The systems you draw here run on the same documents everything else edits:

• Workflows Overview — what workflows are and what they can do
• Adding Nodes — the node picker in depth
• Node Reference — every node type
• Whiteboard Tour — the same canvas in thinking mode: sketch first, convert to nodes when ready