MAI video tools (alpha)

Three nodes and one widget that remove drudgery around renders without taking any decision away from you. None of them runs a model.

MAI Video Out (file + sidecars + draft preview)

Save Video with the record beside it. Frames (+ audio) go through ComfyUI's own encoder (h264 / av1, CRF), exactly like Create Video + Save Video; the extras are each off unless wired or toggled:

hold_map -> <prefix>_00001_.holdmap.json: the clock that produced these frames. H3 Load Hold Map and the deck's hold-map staircase read it.
write_meta -> <prefix>_00001_.meta.json: seeds, models, LoRAs, steps, samplers, inject schedule, encode time, your notes, all read out of the graph that ran. The compare viewer's metadata strip and the scorer's labels come from here instead of from file names.
draft_preview + latent: decode the sampled latent through the tiny VAE in models/vae_approx (taeh3 for H3; any stem) into <prefix>_draft.mp4. The tiny VAE is loaded for that call and released after; with the toggle off nothing is loaded and nothing runs. Cost measured 2026-08-21: 8 ms per latent frame at 864x480, 21 ms at 1344x768, 42 ms at 1080p.

MAI Load Video (path) / MAI Select Every Nth

The two things the graphs still took from VideoHelperSuite: a video by absolute or input-relative path (as ComfyUI's VIDEO type, frames and fps alongside), and every n-th frame from an offset. For a smeared clip use H3 Exact Recover instead; it is exact.

MAI Video Compare (2-6, synchronized)

The player has grown since this page was written: a waveform timeline with loop brackets, a frame stepper, and a frame-exact export. The README's MAI Video Compare section is the current reference; this page keeps the original wiring notes.

A media UI, not a processing stage. The node writes each wired VIDEO once as a small h264 preview into the temp directory (CPU, no VAE, no tensors kept) and the widget plays them in the browser with the flipbook's player: one set of live <video> elements, buffered start-together, flip / wipe / side-by-side for a pair, a grid for more.

hover a source to hear it, click to lock its audio
space play/pause all, arrows step all one frame (shift: 12), F flicker A/B
1-6 pick the pair (last two pressed), Enter stars the B side
the star sets the node's winner widget; the NEXT queue passes that source through winner_video (and winner_index). Pick, then finalize in a second execution: a graph never waits on a human mid-run.

The flipbook deck (https://matlowai.github.io/flipbook/derope.html) is the offline twin, same player code.

MAI Seed Hunter (compare + winner seed)

Video Compare that knows about seeds: wire 2-6 cheap candidates and the seed each ran on (labels default to the seed), star the keeper, and the NEXT queue passes the starred candidate's seed out of winner_seed for the finalize pass's RandomNoise (and its video out of winner_video). The seed-hunt pass and the finalize pass are two executions by design.

MAI Motion Editor additions

Alpha. The editor's rows, modal, undo and run buttons have only been exercised by an automated browser so far; expect rough edges, and treat anything surprising as a bug to report rather than a design choice.

Verified headless against a lab instance (2026-08-22, Playwright): run-to-here renders base + oracle + filmstrip and holds the graph; a drag on the block lane creates exactly the dragged range (snapped to the token grid); the live envelope drives the dilated clock, the play loop and the price before any render; the modal applies as one undo step; run-from-here resumes at the editor with the whole base chain from ComfyUI's cache (14 nodes cached, editor + downstream executed); a fresh page load restores the last run's filmstrip from the server.

run to here / run from here on the node: the first is partial execution (nothing downstream), the second a normal queue where unchanged upstream nodes come from the cache, so it resumes at this node. Editing a row then "run from here" is the retry loop.
Undo: the node's undo/redo is the fine-grained one (every row edit, drag, modal apply). ComfyUI's own ctrl+z jumps back to the graph's last snapshot (the widget re-hydrates from it and says so); the graph tracker does not see edits made inside the widget individually, so ctrl+shift+z at graph level has nothing to redo after that. Use the node's buttons or ctrl+z/ctrl+shift+z while the editor has focus.
hold_until_edited (default on): with no rows, a run stops after the filmstrip; lay out rows and run again.
Cache reality: ComfyUI keeps only the previous prompt's outputs, so running other graphs in between evicts the base pass and the next run-from-here re-renders it. The other way to lose the cache is a seed that moves: the frontend's default "control after generate" is randomize on nodes it builds, so the plain Run button re-renders the base every time until both RandomNoise nodes are set to fixed. The node's run buttons pin every seed control to fixed before queueing.
Play (space): the filmstrip plays at fps; in the dilated clock each frame lingers for its hold, so the slowdown is seen, not inferred.
clock: world / dilated: the timeline's x-axis reads as "when" (frame) or as "how long it costs" (cumulative holds). The compiled hold curve from the last run is drawn over the jerk profile in both.

Paste an API workflow

With the pack installed, Ctrl-V of API-format JSON on the canvas works: the stock paste handler only takes UI-format workflows, so web/api_paste.js catches API JSON first and routes it through the frontend's own loadApiJson (widgets built from the server schema, never by position). It replaces the graph, so a non-empty canvas asks first. The deck's "api" links and every *_api.json in examples/ paste directly now.

What these replace

Our graphs used VHS_LoadVideoPath and VHS_SelectEveryNthImage; both are covered. Create Video + Save Video stay valid; MAI Video Out is those plus the sidecars. The compare node replaces opening three files and scrubbing them to roughly the same place.