Pipelines

A Pipeline is a visual, multi-step agent workflow that lives directly on the board. Instead of typing one long prompt, you lay out a chain of connected node frames — a starting brief, one or more steps, and a final results area — and let an agent walk the graph: it runs each step in order, flips a status light as it goes, and writes the output of every step back onto the canvas where you can see it.

Think of it as a storyboard for the agent. You design the recipe once (the steps, the inputs, the order, where approvals are needed), and then run it — or save it as a reusable preset and run it again on new inputs.

Pipelines reuse ordinary frames, notes, media, and connection arrows — there is no special “pipeline mode” to learn. Any frame can become a pipeline, and you build the rest with the canvas tools you already know.

Pipelines run best with GLAI — the terminal coding agent has full access to your computer and every board action, so it can chain real generation, file, and render steps end to end. See Better with GLAI below.

Turn a frame into a pipeline

Start with any frame on the canvas. Open its context menu (the ··· button on the frame’s floating toolbar, or right-click the frame) and choose Convert to Pipeline.

The frame becomes a pipeline container: it gains a status dot and a dedicated toolbar, and it’s now ready to hold node frames. To turn it back, open the same menu and choose Convert to Frame — this only removes the pipeline flag; your content stays put.

The pipeline toolbar

Once a frame is a pipeline, its title bar shows a few extra controls:

• Status dot + label — Waiting, In Progress, Finished, or Error. This reflects the whole pipeline’s state and updates live as the agent runs.
• + Add Node Frame — adds the next building block (see below).
• ▷ Run in GLAI — hands the pipeline to an agent to execute.
• ⊟ Save as Preset — packages the pipeline so you can reuse it later or share it.

Add node frames

Click + Add Node Frame to drop a building block into the pipeline. There are four kinds:

Node	What it’s for
Starter Instructions	The opening brief for the whole run. Splits into two panes: Instructions (the overall task) and Assets (shared input media every step can use). Optional, and you can have only one. It only has an output, so it always sits at the start.
Step Frame	A single unit of work. Splits into three panes: Instructions (what to do in this step), Assets (input media for this step), and Results (where the agent writes this step’s output). Add as many as you need. Each step has its own status dot.
Final Results	A landing area for the finished output and a summary. Optional, only one, and it only has an input, so it sits at the end.
Empty Frame	A freeform node with input and output but no panes. Use it for scratch input, an intermediate hand-off, or a custom step the standard panes don’t cover — drop any notes or media inside and wire it into the run.

When you add a node, the app positions it, gives it its panes, and automatically connects it to the previous node so the graph stays in order. The Instructions, Assets, and Results panes are resizable — drag the divider between them to give a pane more room.

Filling in a node

A pane is just a frame, so you fill it the way you fill anything on the canvas:

• Instructions — type a note, or drop in a .txt / .md / .pdf brief. Plain language is fine: *”Make me several angles”*, *”First, use Higgsfield nano banana pro”*.
• Assets — drag in reference images, source clips, or any media the step should work from. Anything you place inside the pane’s box counts as belonging to it.
• Results — leave empty. The agent clears and fills this when it runs the step.

Connect the nodes

Nodes run in the order defined by the connections between them, not by where they sit on the canvas. Each node has ports: an input on its left edge and an output on its right edge. Drag from one node’s output to the next node’s input to wire them together.

The natural flow is left to right: Starter Instructions → Step 1 → Step 2 → … → Final Results. A node can fan out to several others or receive several inputs, so you can branch and merge when a workflow needs it. The indigo dashed arrows you see between nodes are these connections.

Status while it runs

Each step and the pipeline container carry a colored status light so you can watch progress without reading anything:

Dot	Status	Meaning
🔵 Blue	Waiting	Not started yet.
🟡 Yellow	In Progress	The agent is working this step now.
🟢 Green	Finished	Done; the result is in the step’s Results pane.
🔴 Red	Error	Something failed — the agent leaves a short note in the Results pane and stops so you can fix it and resume.

A step can also show a small grey line of text underneath it (the meta note) — agents use this for things like an Estimated Cost before a step runs, updated to the real cost once it finishes.

Because a pipeline keeps its state on the board, a run can be stopped and resumed. If you close the app or hit an approval gate, the next run picks up from the first step that isn’t already finished — it won’t redo completed work.

Run the pipeline

Click ▷ Run in GLAI and pick how to execute it:

• GLAI for Claude Code / Codex / Gemini CLI — runs the pipeline in the GLAI terminal using your chosen coding-agent CLI. *(Desktop app + Pro.)*
• Run with Board Agent — runs it through the in-app Board Agent, which uses your configured API keys. The agent dock opens and the run prompt is copied to your clipboard — paste it to start.

Under the hood, running a pipeline hands the agent a short prompt that names *which* pipeline to run; the agent already knows *how* to run pipelines (read the graph, order the steps by their connections, do each step, write results back, keep the status lights current). You don’t need to write any of that — just design the nodes and press run.

As it works, you’ll watch each step’s dot turn yellow, its Results pane fill in (often with a skeleton placeholder first, then the real media), and the dot turn green before it moves to the next step.

Human action loops (Require Approval)

Sometimes you don’t want the agent to barrel through the whole chain — you want to review a step’s output before it continues. That’s a human action loop, set per step.

Open a step’s context menu and choose Require Approval.

The step now shows a blue Requires Approval badge. When the run reaches that step, the agent finishes the step’s work, then stops and waits — it presents the result and asks you to sign off before touching the next connected step.

• Approve — the badge turns green (Approved) and the agent continues to the next step.
• Reject — the agent leaves the step gated; tell it what to change, and it reworks the step (or stops) instead of moving on.

Use approval gates at the decision points that matter — for example, approve the chosen camera angle before the agent spends time rendering all of them, or approve a script before it’s voiced. To remove the gate, open the same menu and choose Disable Approval Requirement. A step only pauses once: after you approve it, a later resume won’t stop there again.

Scheduled tasks

A pipeline can carry a schedule — a recurring instruction that says “run this pipeline every N minutes/hours/days, starting then.” It’s how you turn a one-off workflow into a repeating job: a daily news digest, an hourly render check, a weekly report.

The schedule does not run anything on its own. It is instruction metadata stored on the pipeline — the app saves it and displays it, but it never starts a timer or launches an agent by itself. An agent has to read the schedule, work out which pipelines are due, and run them. Nothing happens until an agent processes the schedule. Think of it like writing “water the plants every morning” on a sticky note — the note doesn’t water anything; someone has to read it and act on it.

Add a schedule

Open the pipeline’s context menu (the ··· button on its toolbar, or right-click it) and choose Add scheduled task.

The Scheduled task dialog opens:

• Schedule enabled — the master switch. Turn it off to keep your settings but pause the schedule; turn it on to arm it. While it’s off, the rest of the fields stay hidden.
• Repeat — how often the pipeline should run: a number plus a unit (minutes, hours, days, weeks, months). “1 hour” means an agent should run it once an hour.
• Start — when the schedule becomes eligible: Immediate (due right away) or Specific date (not due until the date and time you pick).
• A live summary at the bottom restates the rule in plain English — e.g. “Every 1 hour. Starts 20/06/2026, 23:56:00.”

Click Save Schedule to store it on the pipeline, or Remove schedule to clear it entirely.

Save Results of each interaction

The Save Results of each interaction toggle controls what happens after each successful scheduled run. When it’s on, the agent archives a snapshot of the finished pipeline — its results and final output — to the pipeline’s schedule history as a reusable .glpipe package. Each successful run adds one history entry; partial or errored runs aren’t saved.

You can revisit those snapshots from the Schedule History tab in the dialog (it appears once there are saved runs) and click Place pipeline with results on board to drop a full copy of that run — results and all — back onto the canvas. It’s how you keep and compare the output of every cycle instead of overwriting it each time. Leave the toggle off if you only care about the latest run and don’t want a growing archive.

Save and reuse as a preset

A pipeline you like can be saved as a reusable preset so you (or someone else) can drop the whole workflow onto a fresh board and just swap the inputs.

Click ⊟ Save as Preset and fill in the form:

• Title and Description (markdown supported)
• Requirements — anything the workflow needs (e.g. *”Needs a Higgsfield CLI login”* or a specific API key)
• Category and optional Tags to make it findable
• Thumbnail — upload one, or let it use the first image found in the pipeline
• PRO preset — mark it if it should be gated behind a license

The preset is packaged as a single .glpipe file that bundles the node layout, the connections, and the referenced media. Import one later from the pipeline library and it lands on your board as a fresh copy with new IDs, ready to run.

Better with GLAI

Pipelines work with the in-app Board Agent, but they shine with GLAI. A pipeline is a recipe of *real* work — generate these angles, download that clip, render this title card, stitch the result — and GLAI runs a coding-agent CLI in a real terminal with full access to your computer and every board action. That means it can:

• Call external generators like the Higgsfield CLI for a step, then place the result in that step’s Results pane
• Chain file, render, and video-editor operations that a chat agent can’t reach
• Run long multi-step pipelines end to end, with sub-agents and loops

If you haven’t set up GLAI yet, start here:

• GLAI — install a coding-agent CLI (Claude Code, Codex, or Gemini) and launch the terminal
• GLAI → Set up the Higgsfield CLI — add external generation for pipeline steps
• GLAI → Skill presets — ready-made board skills you can combine with a pipeline

Where to go next

• GLAI — the recommended way to run pipelines
• Agent Types — running a pipeline with the in-app Board Agent
• Giving Commands
• Reviewing and Reverting Actions