Features · Workflows
Chain models into pipelines.
A visual canvas where prompts and files go in one side and finished, post-processed assets come out the other. Mix any models across text, image, audio, and video in a single graph, fan edits over batches, merge tracks — then re-run the whole thing whenever the inputs change.
Build
Seven node types, any pipeline.
Inputs hold your prompts and files, Models generate, Edits transform, Combine merges, Switch picks between alternatives, Files save the result — and Notes document the graph for later. Drop nodes with single-key shortcuts, wire them with edges, auto-arrange the canvas in one click, undo freely. The canvas is the whole programming model: if you can draw it, you can run it.
Describe
Or skip the wiring — just say it.
An assistant sits beside the canvas and speaks graph. Describe the pipeline you want and it builds one; ask for a change to the graph you have and it makes exactly that change — adding nodes, picking models, rewiring handles, tidying the layout. Everything it does lands as one undo step, so a suggestion you don't like costs you a single ⌘Z. The conversation stays with the workflow.
Mix
Any model, at any step.
Every Model node picks its own modality, provider, and model — a local Gemma can write the prompt that a cloud Flux renders and a Veo clip animates, all in one graph. The node's connection points adapt to what the model accepts: video models with start- and end-frame support grow image handles for them, and vision-capable local models accept images too.
Assemble
Fan out, then merge.
Edit nodes fan across their inputs — ten images in, ten crops out, processed in parallel on your machine. Combine nodes do the opposite: overlay tracks in parallel mode (a Lyria music bed under a Veo clip, mixed audio) or concatenate files in series. Between the two, one graph can turn raw generations into a finished deliverable.
Run
Run it all — or just one step.
Independent branches execute concurrently, with live status on every node. Hover Run and you see what a full pass will cost before you commit; a node that can't succeed is flagged before you press it. Iterating on one stage? Run from that node and execution stops at the next model boundary, so you never re-pay for the upstream steps that already worked. Stop aborts the run — and cancels the cloud calls it started, rather than letting them finish on your bill. If a step fails, its error stays on the node with a Retry that resumes from there.
Share
Start from a template, share as a file.
Your first workflow arrives pre-built so you see the shape before building your own, and templates give running starts — text to image, image to video with a music bed, a product shot in four styles, a podcast intro. Save any graph of your own as a template too. Every workflow exports as a plain JSON file: share it with a teammate, publish it, or keep versions in git, and importing it recreates the pipeline with nodes and wiring intact. Once a workflow is saved you can also just ask for it by name in Chat.
Catalog
Every model is a node.
Workflows draw on the entire catalog — every text, image, audio, and video model, local or cloud, is available to any Model node. Browse them all, with real sample outputs, in the models catalog.
FAQ
Workflow questions, answered.
How the node pipeline engine works in CSuite — node types, the AI assistant, model mixing, parallel runs, failures, sharing, and costs.
A visual graph you build on a canvas: Input nodes hold prompts or files, Model nodes run an AI model, Edit nodes apply deterministic operations, Combine nodes merge files, Switch nodes pick between alternatives, and File nodes save results into your project folder. Connect them with edges and press Run — plus Note nodes to annotate the canvas for future you.
Yes. An assistant panel sits beside the canvas and takes plain-language instructions: describe the pipeline you want and it builds the graph, or ask for a change to the one you have — "add an upscale step before saving", "branch this into 16:9 and 9:16". It adds, removes, configures, and wires nodes, lays them out, and lands the whole edit as a single undo step. The conversation is saved with the workflow.
Any model in the catalog, in any combination. Each Model node picks its own modality, provider, and model — so one graph can have a local Gemma writing a prompt, Flux 2 Pro rendering it, and Veo 3.1 animating the result. New nodes pre-fill with your globally selected model for that modality.
Independent branches run concurrently — only a node's direct predecessors serialize it. You can also run just a segment: start from any node and execution steps to the next model boundary, so you can iterate on one stage without re-running (and re-paying for) everything upstream.
Images resize, crop, and convert format. Audio trims, converts, fades, and takes a volume change. Video resizes, crops, transcodes, trims, changes speed, mutes, and can extract its audio track or a single frame as an image — so a video branch can feed an audio or image branch downstream. Text overlay works on both images and video. All of it runs locally through ffmpeg, and an Edit node fans out: feed it ten images and one crop setting, and it processes all ten in parallel.
Yes — write {{topic}} anywhere in an Input node's prompt and the node grows a connection point by that name. Wire anything that produces text into it and the value is substituted in at run time, so one prompt template can be driven by several upstream steps. Unconnected placeholders are left alone, so a half-wired prompt still runs.
The node keeps its error message with a Retry button that resumes from there instead of re-running the whole graph, and its dependents are skipped rather than fed garbage. Before you even press Run, CSuite flags nodes that can't succeed — no model picked, nothing connected, no operation chosen — and disables Run with the reason in the tooltip.
It merges multiple files into one: in parallel mode tracks play simultaneously — lay a music bed under a video clip, or mix audio tracks together — and in series mode files concatenate in order. It grows an extra input slot whenever you fill the last one.
Yes — workflows export and import as plain JSON files, so you can share a pipeline or keep versions in git. Ready-made templates give you running starts (text to image, image to video with a music bed, a four-style product shot, a podcast intro), any graph of your own can be saved as a template, and your very first workflow arrives pre-built (Input → Model → File) so you see the shape before building your own.
Yes — ask for it by name in Chat ("run my podcast intro workflow") and it executes headlessly, with each saved output posted back into the thread. The canvas shows the same results next time you open it.
Intermediate results live in a scratch space; only what a File node claims is saved into your project folder, with sensible naming and collision handling. That keeps experiments cheap and your folder clean — and File nodes holding text are editable inline, right on the canvas.
Each Model node is billed like any other generation — by the platform, directly to your account, at that model's rates; local models cost nothing. Edit and Combine nodes are free: they run on your machine. There is no extra charge for the workflow engine itself.