Visual workflows

A workflow is done once, run endlessly: it turns something you did once into a process that runs again on new input, runs unattended, and runs at scale. Start-node inputs and templates make it reusable; it can carry media through the timeline, subtitles, export and publishing to a finished piece; loops, concurrency and branches handle batches and say which item failed; schedules, webhooks, the agent or other workflows can start it; and every run keeps each node's inputs, results and errors. The process itself is the product. While you are still looking, revising and picking between versions, use a creative board.

Workflows connect media, models and tools into reusable steps. Configure node inputs and run the readiness check before starting a flow. Use schedules or webhooks for recurring work. Run history keeps node inputs, results and errors available for inspection.

Download and import official templates#

The website workflow catalog describes every official template, what it needs, and offers Chinese and English downloads; the template gallery in the app can add them directly too.

1. Download a .mosael-workflow.json file; no extraction is needed.
2. Choose your workspace in the app, open Workflows, then use Import workflow to select the file.
3. Open the imported graph, choose your own providers and models, fill in the start node's required parameters and pass the readiness check before running.

Downloads contain no account secrets or private assets, and do not automatically select local default models. Importing needs 1.9.8 or newer. Node names follow the language of the file you downloaded.

For	Templates
Finished videos	Topic to finished video (brief → script and visual bible → characters looked up in the asset library first, with turnarounds / location art drawn and saved only for new ones → storyboard → an automatic 3D blockout → per-shot video from the blockout → narration captions → export; the most expensive one, up to 8 shots by default; the start node's Seconds per shot is set at build time to the duration nearest the default that the chosen video model can make, video length, timeline and storyboard all follow it, and a model that can't make that length is stopped before the run), Long video into vertical clips (picks up to 12 segments, each on its own vertical timeline with short captions)
Clean-up and montage	Transcript-based video cleanup (denoise first, then cut pauses, fillers and repetition by the transcript; for material up to about 30 minutes), Montage from your own footage (orders a tagged batch of your clips and adds narration and captions)
Translated dubbing	Translated dubbing with subtitles (transcribe, translate and subtitle line by line on the original timecodes, dub each line into its slot, strip the original voice but keep the music), Translated dubbing with lip-sync (the same, then the speaker's lips follow the dub)
Products and business	Product photo into on-model shots (the outputs list each group's on-model shot and video), Product into a narrated short (the script goes through Fit narration to its length first; uses a cloned voice when you have one, otherwise the free Edge voice, with nothing to set up, and the finish notice says which voice it used; with a video model that takes a first frame, every beat moves: the beat's frame becomes the first frame of a clip, the clip goes on the timeline with its own sound muted, and every beat is the same length — the start node's beat_seconds, set at build time to a length that model can make, with a length it can't make stopped before the run; that is one more paid video per beat, about 6 clips for the default 30 seconds at 5 seconds a beat; without a video model it lays one still per beat as before), Fabric into applications and a spec sheet
Digital humans	Script into a talking-head video, Product into a presenter-led short (see Digital humans)
Analytics	Social account health check, Why a video went viral, Comment insights and audience (see "Analytics templates" below)

What each one needs (a chat model, an image model that takes references, a video model, a cloned voice, a transcription or separation engine…) is on its card, and the template gallery checks each item off. The reduce-noise node uses the built-in engine by default. For speech-led material with messy noise (keyboards, dishes, chatter) switch it to DeepFilterNet (a deployment admin downloads it first under Admin → Engines); it removes music as well.

Graphs from an older template offer "Rebuild from the new version". When a template has been fixed in ways that would make an old copy fail, opening that copy shows a notice: Rebuild from the new version (keeps this one) builds a fresh graph, carrying over the start parameters and values you filled in, and keeps the old one; dismiss it and a newer version will remind you again. Models are picked again from your current settings: both product pitch templates have since gained moving beats, so rebuilding an older copy adds that step when you have a video model.

Canvas & nodes#

Build a workflow from scratch — use "Add node" to add media and LLM generation nodes, drag between ports to connect them, and configure each node in place; the built-in AI assistant can also build the graph for you:

• The entry page is a gallery of workflow cards. Open one to enter the full canvas; return at the top left and manage nodes, runs and history from the top-right toolbar.

• Add node (⌘N) from the toolbar, grouped by what they are for:

  Group	Nodes
  Flow	Start, Condition, Delay, Loop · for each, Loop · while, Call workflow, Output, Subgraph
  AI	LLM, AI generate, Translate, Translate lines, Fill in angles, Generate expressions, Make it talk (character / image), Lip sync, Lip-sync a dubbed timeline, Voice a long script in segments, Fit narration to its length
  Audio	Transcribe asset, Text to speech, Separate voice and background, Reduce noise, Dub subtitles
  Assets	Export timeline, Asset, Download from a link, Inspect timeline, Append to timeline, Add a track, Clear timeline, Clean up time ranges, Timeline advanced operations, Video to GIF, Split grid, Generate subtitles, Find assets, Get from asset library, List library assets, Save to asset library, Tag assets, Organize assets, Create project, Create video project
  3D	Available 3D props, Build a 3D blockout scene, Build a 3D scene from text, Render blockout references
  Knowledge	Search notes, Read note, Save as note, Document to Markdown
  Data	HTTP request, Code, Text template, JSON extract, Split into batches, Text transform, Read a social media link, Tidy post and comment data, Check quotes
  Publishing	Publish, Send notification
  Browser	Open browser, navigate, click, type, upload file, switch page, screenshot, extract, wait, scroll, run script, Close browser
  Plugins	One node per tool from your installed plugins

• Edges define execution order; drag from a node's right port to a downstream node's left port. The toolbar switches edge shape between curved (bezier) and stepped (right-angle); your choice is remembered.

• Click a node to open its inspector — it sits directly below the node, and a floating bar sits directly above it: content sections on the left (Parameters / Advanced / Outputs, plus This run once it has run — each shown only when the node has it), node actions on the right (open subgraph, delete). "Advanced" holds the knobs that work fine left blank, so the first screen isn't a wall of sampling parameters.

The start node: parameters, required and options#

The start node lists one parameter per row — Name and Default — with a ✱ (required) and a × (remove the row) at the end; Add appends a row.

• Light up ✱ to make a parameter required (hover it to see what it means). A required parameter without a default shows Filled in at run time in its default box: it must be filled in when you run, and until it is, the run is refused — a placeholder example never runs as a real value.
• Option parameters: the Default cell becomes a dropdown (Pick one) limited to the given options. An option whose prerequisite isn't set up is marked "not set up" but can still be picked; the run then says what's missing (that's how the analytics templates' data source works).
• The start node has one output port per parameter, so downstream nodes wire straight from the matching port.
• References to parameters the start node doesn't declare, defaults outside the options, empty or duplicate names are all flagged by the readiness check.

Loops and branches#

• The Condition node has true / false outlets. A node hanging off one outlet runs only when that branch holds; a data connection it takes a value from elsewhere decides only the value, never whether it runs. When the condition's Left value comes from upstream, the canvas draws its input port. Empty lists and objects count as empty, and two numbers compare numerically.
• Loop · for each runs one item after another by default. When items don't depend on each other (such as generating each shot), raise Concurrency to 2–4 under Advanced; results keep their original order. Max items caps the list; When an item fails is either Fail the whole loop (the default: once any item fails no new item starts, items already running finish and their submitted generations are still collected) or Note it and carry on — the failures are listed under Failed items and in the notification. With the latter, when a later step in an item fails, what the item already produced is still returned: an on-model shot that was made before the provider refused the video built from it stays in the results (the item is left out only when the output it hands over is the failed step itself). Without an iteration output, each item returns everything that round produced plus the item itself (loop.item).
• Loop · while stops after 50 rounds by default (adjustable, at most 1000).
• Split into batches divides a list into fixed-size, non-overlapping batches in the original order, ready for a for-each loop. Use it for comments and other long result sets instead of putting the entire list into one model call; it also outputs batch count and original item count.
• Text to speech and Dub subtitles ask for the engine first, then the voice: with "Cloned voice" the voice list is your voice library; pick an engine and the list becomes that engine's voices. Changing the engine clears the chosen voice. With Alibaba Bailian (CosyVoice) the list also carries, after the stock voices, the library voices whose owner has been declared, shown as "Cloned · name": what speaks is that voice's copy cloned into your Bailian account, billed at CosyVoice's per-character price, with no local engine to install (see Editing → Your own voice through Bailian). The first use of a voice needs your agreement to upload its reference clip, and nobody is there to agree while a workflow runs — click Clone on Bailian on the voice under Settings → Dubbing & voices first; without it, the run stops at the voicing step and says so.

Wait for approval#

The Wait for approval node stops the run where it stands until a person approves or rejects.

• Where it stops, where it picks up: the run waits at this node, and it is still waiting after a restart; once approved it continues from this step and none of the earlier nodes re-run. When one run holds several gates, which gate is being decided travels with the decision — approving the second gate resumes from the second gate's own saved point, never re-running the nodes between them.
• Who may approve: the Feishu card and the in-app run record are two entries to one and the same decision. Whoever taps must already have their Feishu account bound to a Mosael account and must still be a member of the workspace.
• Two gates on parallel branches don't fit: a run can only stop at one gate, so two Wait for approval nodes that are not upstream of each other are rejected before the run starts, with the fix spelled out. Two gates on a Condition node's true / false outlets are the exception (they can never both be live).
• Deciding in one place clears the other: approving in the app also retires the Feishu card in place, and cancelling or timing out never leaves a card that still looks clickable.
• Timeouts (24 hours by default; 0 waits forever) follow the node: stop this run (the default), continue with decision timeout, or just remind again and keep waiting. All three notify again; the reminder also says so in the same Feishu chat (without swapping the card — the gate is still open, so its buttons have to stay). Each reminder pushes the next one out by a full interval.
• Rejections follow the node too: stop this run (the default) or hand the decision downstream (a Condition node reading decision = "rejected").
• How it notifies is written on the node: back to where it came from, direct-message someone, a specific group, or in-app only. Anything that fails on the Feishu side degrades to in-app and the run keeps waiting; when nothing got out at all, an in-app notice says the decision has to be made there, and the line "you can also click the card in Feishu" is only shown when the card really was sent.

Top toolbar#

The order matches creative boards: add and undo/redo, comments, markers and their list, search and view controls, then the AI assistant. Readiness, run history and Run form a separate group on the right.

More contains rename, revision history, file export and deletion. The current version shows at the end of the revision-history row; deletion sits in its own group and still requires confirmation. Arrow keys move through the menu and Escape closes it. ⌘F finds nodes across the whole graph (ids too): matches are outlined on the canvas and Enter / ⇧Enter steps through them. ⌘S saves and ⌘Enter runs. In narrow windows, arrows reveal the remaining tools while the assistant, run controls and More stay visible.

When something is buried#

With dense nodes or stacked floating panels, select one and press ⌘/Ctrl + ] to raise it or ⌘/Ctrl + [ to send it down. Floating panels use the same pair, but nodes can never cover a floating panel — otherwise the inspector would end up buried under the very node it's editing.

Node forms use a translucent, blurred surface above the canvas. When an assistant panel is open, selecting a node centers it in the unobscured canvas area. Media nodes have compact previews that open a larger player.

Variables and references: wiring upstream outputs into downstream inputs#

After a node runs it writes results into the context, and downstream fields read them with references such as {{nodeId.output}}. The interface doesn't show raw {{…}}: in parameters, the prompt editor, stale-reference notices and the readiness check, a reference reads "Node title · output · field"; one that points nowhere turns red and says why — the node can't be found (deleted, renamed or mistyped) or it has no such output — so you can pick another upstream output.

Data ports match properties one for one: named configuration inputs and named output variables each receive their own port. Control edges express order, while data edges state exactly which property moves. Each port carries the name of its field in the node's settings, in the interface language: a reference inside the generation parameters gets a port called “Aspect ratio” or “Resolution”, one inside the input media is named after its role, “First frame” or “Reference image” (numbered when a role has several lines; a line without a role is “Input media 3”). No node has two ports with the same name — a generation node hands back “Media” (the cover) and “Media list” (everything from the run). References written inside raw JSON such as a JSON Schema share one port for the whole field.

The canvas draws each reference as a faint dotted line: it only orders things (a node waits for whatever it references), it never makes the referenced node run, it can't be selected, and hovering it says which reference it is. When the referenced node isn't wired into the flow and will never run, the line turns the error colour.

Each field can switch between two input modes (the small pill at the right of the label row):

• Manual: type a value / pick an option; in template fields press @ to pull up upstream variables (keep typing to filter), or click a variable chip to insert at the cursor. Fields that point at something (3D scene, shot, timeline, track, project, account, connection…) are dropdowns: this workspace's items first, then upstream outputs; {{loop.item.…}} inside a loop body can be typed into the search box too. A dropdown that follows another field (shot follows scene, track follows timeline) says its choices are known at run time when that field comes from upstream. When the node has nothing upstream yet, @ says so instead of doing nothing.
• Connected: the field becomes a port; pick one from the upstream outputs dropdown — equivalent to binding that reference. Switching back to manual keeps the previous value.

Code fields such as Run script and Code don't interpolate references: upstream values go into input and arrive as JSON data — text scraped from a page can't rewrite the script.

Readiness check / run gating#

The toolbar's Readiness button gathers every issue and shows a count: red blocks the run, amber is advisory, and with nothing left it says all set — ready to run. It checks: a missing start node, missing required fields, one-of fields with nothing filled, stale references, references to start parameters that don't exist, values outside their options, empty loop / subgraph bodies, an Output node inside a body, nodes not wired into the flow, references to nodes that will never run, references to outputs a node doesn't have, models / providers missing or without keys, type mismatches, references written into code, plugin nodes that can't run (with the real reason)…

Problems are described with the names you see on the canvas: nodes by their title (the node type's name when untitled, with the id added when two in the same layer share a name), fields by their on-screen label, a node inside a loop as "Shot by shot › Generate frame", and the whole sentence in English when the interface is English. Pressing Run when something is missing tells you which node and field by name, not by node id and raw setting key.

A reference to an output the node doesn't have is stopped before the run. A reference like {{script.titel}} — the node exists but the output name is misspelled (or the upstream output was renamed) — used to come out empty while the workflow still reported success; now the readiness list marks it red and Run stops, saying who references which output of whom and which outputs it does have. When an LLM node has a JSON Schema, sub-fields are checked against it; outputs whose keys are only known at run time (code, HTTP responses, sub-workflows) don't raise false alarms below them.

• Problem nodes get a warning badge on the canvas with a tooltip listing the issues; each issue is clickable and jumps to the node.
• With blockers present the Run button is disabled, and ⌘Enter opens the readiness list instead.
• A node that will run but references one that never will is stopped before the run, naming who references whom and suggesting you wire it into the flow — or, for a graph built from an official template, use Rebuild from the new version at the top. Before, such a reference just came out empty.
• There is one pre-run check, shared by the editor's Run, sub-workflows, the agent's cards and scheduled tasks. A sub-workflow's required parameters, digital-human consent, a clone engine that isn't installed, an aspect ratio the video model won't take, or no chat model at all — each is reported before any node spends money.

Once a run starts, Run becomes Stop run, and ⌘Enter during a run doesn't start another one. The run's detail dialog in the task centre carries Cancel task as well. Cancelling cuts in-flight LLM, voice, translation and HTTP requests on the spot, without retrying or sending new ones — a local model doesn't keep generating and a paid endpoint doesn't finish and bill anyway; a script running in a browser node stops too. Whatever the run already produced (assets, timelines, 3D scenes) is kept, derived sub-tasks are cancelled with it, and a node that fails only because of the cancellation is recorded as cancelled in the run history.

When a run fails partway, the outputs of the nodes that already finished stay in the result instead of disappearing with the last step.

Each run in the history also says what it cost — "Cost $1.20 · 5 billed calls" — including the sub-jobs it started (LLM calls inside the workflow, generation, voice-over…); calls that couldn't be priced are noted as not included. The free Edge voice records 0, not unpriced.

A few node details:

• HTTP request escapes upstream text inserted into a JSON body as JSON and sets Content-Type; Fail on non-2xx is on by default (switchable under Advanced). Only the public internet by default: loopback such as http://127.0.0.1:11434, private networks and cloud metadata addresses are blocked before anything is sent, and the error says which entry a deployment admin should add under Admin → Deployment → Internal network access. The agent's page fetches and requests and import from link work the same way.
• Code: the only thing it can hand over is output — when the code finishes without assigning it you're told on the spot (written as a function, call it at the end: output = main(inputs)) instead of a "successful" empty value; print for debugging doesn't affect the result.
• JSON extract recognises text wrapped in a ```json fence (the usual shape of a model's text output) instead of quietly returning nothing. A * in the path means "every item in this list": results.*.asset_id takes each item's asset_id, and items without it leave no gap.
• Fit narration to its length takes a list of segments (the beats of a script, say), each with its narration and length; it estimates how long each takes to read (about 4 Chinese characters or 2.5 English words a second), sends only the segments that run long back to the chat model to shorten (for a configurable number of rounds, keeping a rewrite only if it is shorter), hands anything still too long to the voice-over alignment that follows to speed up or trim, and names those segments in its output. If the rewrite step fails, the flow carries on with the original text and says so.
• Voice-over nodes have a new Voice used output that says which engine and voice actually read the line (a cloned voice by name), ready to go into a finish notice. When a line has to be sped up to fit its beat, the rate is rounded up, so a beat that fits at 1.19× is no longer reported as too long.
• The texts a template shows people (finish notices, too-long warnings, the new project's name) follow the language it was built in, so a graph built in English says them in English; what is only worked out at run time (which voice was used, which segments were shortened) follows the language of whoever started the run, and runs nobody started, such as scheduled ones, use the default language.
• Call workflow: inputs wired to upstream values (references) are not checked against the sub-workflow's required fields and options before the run — that happens at run time; when a sub-workflow chosen only at run time can't start, the error names which one.
• Check quotes looks up every quoted passage (「」, “”, and in English straight quotes that look like quotations) in text such as a report against the source: after normalising full/half width, whitespace and emoji codes it must be part of one source item, and a passage shortened with an ellipsis must have each piece in order within the same item. Anything not found loses its quotes and is marked "(paraphrased)"; it outputs the checked text, counts, the list not found and a one-line summary. Put the fetched data (comments, video data, transcripts…) in Sources; what the model wrote itself doesn't count.
• Available 3D props lists this workspace's 3D models as a catalogue (id, name, measured width/height/depth) to feed into the node that designs the blockout, so a set can hold real props.
• Video to GIF and Split grid always output new assets and never overwrite their input.
• LLM nodes use a Preset (Precise / Balanced / Creative) instead of a raw temperature, and a node's max output tokens never exceed the model's output limit.

Browser nodes#

• Open browser and Browser · navigate fail on a 404 or 5xx by default, saying what the server returned; to carry on anyway (to read the text on an error page, say), turn on Allow error pages under Advanced. Both nodes gain an HTTP status code output.
• The six nodes that find elements by selector — click, type, upload file, extract, wait, scroll — have In frame under Advanced: when the element sits inside a same-origin iframe on the page, fill in that frame's selector. A cross-origin frame can't be reached, and you're told so, with the suggestion to open its address directly with Browser · navigate; a selector that isn't a frame or a frame that never appears each get a clear sentence too.
• Browser · screenshot captures the session's current page — the visible area, the full page, or one element (by selector; an element off screen is still captured whole) — straight into the media library and outputs the asset id, with the page URL, title, capture time, and which run and node took it. Which page under Advanced captures another page of the session (by position, title or URL), even one that isn't in front or was never shown.
• Browser · switch page: when a clicked link opens a new window, the new page joins the session and the next step already runs on it; to go back or close it, this node switches to a page by position, title or URL, or closes the current one. It outputs the current page's URL, title and the page count.
• Downloads triggered by Browser · navigate and Browser · click go straight to the media library, and the node gains an output with the asset id (empty when nothing downloaded); types the library doesn't take and files over 2 GB fail the step with the reason.
• Browser · upload file with a selector uses exactly that one; if it isn't on the page it says the file input didn't appear, instead of putting the file into another file input on the page.
• Browser · run script reports the script's own error message, and on a timeout how long it ran; it gives a script 20 seconds by default, and long paged reads can raise the timeout under Advanced, up to 180 seconds.
• If the browser executor disappears mid-step, its lease running out reports that the executor was lost, instead of waiting for the full time limit. How the session shows up and resizes on the desktop is in Browser pool → the floating browser workflows and the agent use.

Analytics templates: accounts, viral videos, comments#

The three analytics templates take a profile or post link (Douyin, Xiaohongshu, Bilibili), fetch the account, recent posts, video stats and top comments, compute posting frequency and times, engagement, top posts and growth signals, and write it up as a note. Three nodes exist for them: Read a social media link, Tidy post and comment data and Download from a link.

• The data source is a two-way choice in the start node's data_source dropdown: Built-in browser (no setup, no cost; Xiaohongshu always needs a sign-in and Douyin mostly does — switch the template's "Open in the built-in browser" step to the browser pool and pick a signed-in profile; Bilibili's post pages need none, but signed out it gives only the first 3 top-level comments (and 20 replies under each), so use a profile signed in to Bilibili to fetch every comment; page numbers are rounded) or TikHub (install the TikHub plugin, create a connection and enable the tools the template lists on the Plugins page; billed per call, complete fields, no sign-in). If TikHub is chosen but not ready (plugin missing, no connection, tools not enabled, an extra connection for the same platform), the run says what's missing before it starts — or switch back to the browser.
• Comment insights analyses every comment it fetches, and says how many it fetched and how many the platform shows: on Bilibili it pages through the site's own comment API until the platform stops returning top-level comments, then pages through the replies under each (up to 2000 for comment insights and 1000 for the viral breakdown, within a time budget); when it falls short the report and note say why (not signed in, a limit was reached, or the platform withheld deleted or folded comments). Elsewhere it reads the comment section, which only shows what the page has loaded, and the result says so too. The fetched comments are taken 80 at a time, the model notes what it sees in each batch, and the notes are synthesised into the report. The comment-count parameter only sets how many top-liked comments go into the appendix table.
• A profile that isn't signed in to a platform that requires it reports "no comments fetched" rather than inventing any.
• Only original words go inside quotes in the report. Before saving the note, all three templates run a Check quotes step: every passage in 「」 or “” is looked up in the fetched comments, video data and transcript, and anything not found (a sentence the model summarised, several comments merged into one question) loses its quotes and is marked "(paraphrased)", with the result noted in the data summary. The viral breakdown's script outline is new writing following the pattern, so it isn't checked.
• Bilibili account links (the profile, the dynamic feed, a bare id) are all read as the uploads list, so the account check reads the most recent posts; escapes such as ' in comment text are decoded before they reach the report; the page-reading path clicks "view more" so nested replies really expand. A graph built from an older version shows Rebuild from the new version at the top.

Triggers#

Use Scheduled tasks to attach a plan and inspect its run history.

Workflows can be bound to scheduled tasks: manual, cron, or webhook. Batch runs of the same workflow are supported.

Messages and files in a Feishu group can start a run too: configure one under ⋯ → Triggers on a workflow's card (the entry lives in the card menu, not the editor toolbar — it changes how the graph gets called, not the graph). A trigger says which bot, which chat (both can be left blank for any), which messages it accepts (text, images, files, video) and optional keywords (fill them in and only messages containing one of them count). The same panel holds the trigger's explanation, its switch, which messages it recently fired on and which run each started, and the mapping from a message field (text, assets, file name, sender …) to a Start node parameter.

• Claimed means claimed: once any enabled trigger claims a message it is not handed to the agent session as well (never both), so you never get "I can't read video" plus a run. Messages nothing claims (wrong type, wrong keywords, wrong sender, throttled) go to the agent as before.
• With "Reply in the group" on: it acknowledges the start ("Trigger … started a run of …") and posts the result back. Turn it off and the record stays in Mosael only (the trigger panel and that run's task card still show it).
• Only people bound to a Mosael account can drive triggers (the same precondition as chat): the bot acts as that workspace member, on their keys and quota.
• Failures are not shouted into the group: a run that fails to start says nothing there (a configuration error is useless to a whole group) — the trigger's owner gets an in-app notice, at most one per minute. Throttled messages notify nobody (the notice would be a second storm) but leave a row in the trigger panel, and a message that started nothing because of throttling falls back to the agent session.
• The same message never runs twice: dedupe keys on (trigger × message id) in the database, so redelivery and post-restart replays are both caught; attachments are turned away before downloading, so no asset is imported twice.
• An attachment that can't be fetched says so: a plain sentence asks the group to try another file or later, and this message starts no run (the asset is the input).

Versions someone else changed#

Version history shows who saved each version. When a run uses a private publishing account, browser profile or files on this computer, both the person running it and the author of the version being run (or someone who approved it) must be able to use them — a workflow started by a Call workflow node counts with its own version too. If a teammate's version would borrow something of yours, the run stops and names the workflow and version; after reviewing the change, click Approve this version in the run history or version history. Approving doesn't change the graph or add a version.

Let AI build it#

The toolbar's AI assistant is the same assistant panel as elsewhere, and each workflow has its own conversations: describe the flow you want in natural language and it builds / edits nodes for you; changes go through confirmation cards. A card that runs a workflow is titled with the workflow's name and pins the version it was opened on — if the graph changes before you approve, it doesn't run and says which two versions differ. Its top-left title is the active conversation — click it to search or switch sessions — and the panel can dock beside the canvas or float above it.

Comments and markers#

The comment and flag buttons enter separate, mutually exclusive modes. Escape exits. Their eye buttons independently show or hide all comments or markers without deleting them. Markers are not listed in Add node.

In marker mode, click empty space to place a position bookmark, then set its name and jump shortcut. Only one marker editor opens per canvas. Clear a binding beside the shortcut field or remove the marker using the footer action. In comment mode, click empty space to write a comment and mention workspace members with @. Submitted mentions keep their interactive labels. Use the pencil to edit your own comment. Adjacent comment pins remain directly clickable.

Switching modes or undoing preserves graph connections. Toolbar groups use separators. Comments and markers are collaboration overlays and do not execute as graph nodes.