Bragproof

← Reports

limostudio-mcp

Starts with no setup0.10.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 5 tools tried
Contacts while installing and starting: limostudio.ai

189tools listed
1host contacted
0files written
0.5 sto start
96dependencies

What it contacted

Hosts it looked up or connected to while installing and starting with no input, watched from outside its sandbox. The npm registry is left out. Says nothing about what its tools contact when called.

Starting it

npx -y limostudio-mcp@0.10.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

5 tools that take no input and look read-only were called once with nothing. 0 returned a result.

studio_infoNo usable answer tool reported an error: Error in studio_info: Could not start Google Chrome (browserType.launchPersistentContext: Chromium distribution 'chrome' is not found at
ui_findNo usable answer tool reported an error: Error in ui_find: Could not start Google Chrome (browserType.launchPersistentContext: Chromium distribution 'chrome' is not found at /op
list_projectsNo usable answer tool reported an error: Error in list_projects: Could not start Google Chrome (browserType.launchPersistentContext: Chromium distribution 'chrome' is not found
list_text_looksNo usable answer tool reported an error: Error in list_text_looks: Could not start Google Chrome (browserType.launchPersistentContext: Chromium distribution 'chrome' is not foun
list_animatable_propsNo usable answer tool reported an error: Error in list_animatable_props: Could not start Google Chrome (browserType.launchPersistentContext: Chromium distribution 'chrome' is no

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

6 tools with commands in capitals or very long text
  • Very long description in generate_shots: 3000 characters or more
  • Gives the agent orders in create_drawing_plugin: f[i] : fallback). DETERMINISM (critical for export): draw MUST be a pure function of t / p / env. Do NOT call Date.now(), performance.now(), or Math.random(). For
  • Very long description in create_drawing_plugin: 3000 characters or more
  • Gives the agent orders in create_expr_plugin: alues are ignored. DETERMINISM (critical for export): expr MUST be a pure function of t / p / env. Do NOT call Date.now(), performance.now(), or Math.random(). For
  • Very long description in create_expr_plugin: 3000 characters or more
  • Gives the agent orders in edit_synth_params: partial `patch` object that is deep-merged over the sound. ALWAYS read get_synth_sound first to use valid indices and current values. Use for "make it brighter" (rai

Common and usually harmless: it is how many makers stress how a tool should be used.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

open_studio projectId, projectName, newProject, discard, settings, url
Open LimoStudio in a browser window the person can see and connect to it as an AI agent (the person allows it there). Every other tool opens the studio itself when needed, so call this only to open a particular project: projectId opens one of the person's projects (list_projects lists them), projectName one by its name (one match; several: their names and ids), newProject a new empty one (either replaces what the window shows — the project open now is saved first; it answers unsaved, and opens nothing, when that save fails or background work still runs there). A project whose local folder is not linked in this window answers needsFolder — only the person can link it. The person can also open any project in that window themselves (File › Open project…).
screenshot what, time, width, hideSelection
A picture of the studio, so you can SEE the result of your edits: the frame at the playhead (what: "canvas", default — rendered as the export renders it, `width` px wide (default 1280) whatever the window's layout, without selection handles), the preview exactly as the person sees it ("preview"), or the whole studio window ("studio"). `time` (seconds) seeks there first and waits for that moment's video frame to be decoded and drawn — the sure way to look at a clip (a seek followed by a screenshot could show the frame before). Screenshots asked together are taken one after the other, each at its own `time`; the answer says the moment it shows.
save_project name
Save the open project to the person's account now (autosave also runs; clips a background job laid — a narrator line, sound effects — are included). `name` RENAMES the open project (it is not Save as: duplicate_project makes a copy). Nothing changed since the last save (autosave saved it): ok with alreadySaved; not saved: the reason.
get_guide topic
The server's instructions WHOLE, one part at a time — for an app that cut them short (Claude Code keeps only their first 4,096 characters): topic "rules" (how to work in the studio), "tools" (which tool for which request), "film" (making a film with shots: the order that works and the checks — read it before plan_shots), "prompts" (picture / video prompt traps met in real films), "window" (this window: saving, crashes, recordings), or "all". Needs no studio window.
studio_info
Which project is open (id, name, playhead), whether this agent is connected, which tools are waiting for the person's yes in the studio window (waitingFor — a call that seems to hang), whether a "saved elsewhere" dialog waits (saveConflict), what is saved (unsaved, savedAt, autosave; changedSinceSave — your changing calls since), the person's spending rules (spending: ask / auto with its budget, what is left and the latest runs it let through / off), how many videos a shot batch makes at once (videosAtOnce: comfyCloud, limoStudio, limoStudioMax — the person's Settings › AI Assistant › Speed), the files the window downloaded to this computer (downloads: an export's path), and this server's version and tool catalogue.
184 more tools
undo
Undo the latest change in the studio (each of your tool calls that changed something is one step; runs after the calls before it).
redo
Redo the step the last undo took back (answers redone:false when there is none — a new change after the undo drops it, as in the studio).
import_file path, destination
Put a file from THIS computer into the open project — a picture, video, sound, 3D model, font, subtitle file or LUT the person has on disk (a path you can read). It is uploaded to the project's files (destination "cloud", default) or saved to its linked folder ("local", when one is linked); a project file of the same name is kept — the new one gets a new name. Answers the filename to use (add_clip url:<filename>, import_subtitles file:<filename>, attach_mask file:<filename>). Free; a big video takes as long as its upload.
disconnect closeWindow
Disconnect from the studio; the window stays open for the person (closeWindow: true closes it).
ui_find query, panel, role, limit, commands
The visible, named controls of the studio window — buttons, tabs, fields, menus, the timeline's clips (clip:<id>), the preview (canvas) and, when asked, the keyboard commands (cmd:<id>) — each with an id, role, label, panel and box in CSS px (a slider also its state min / max / step and its trackBox): the ids the other ui_* tools take — ui_set sets a slider, select, checkbox or colour to a value. `query` narrows by words; the whole studio has hundreds, so ask for what you need. Call this before clicking, and again after the window changed.
ui_click target, button, count, speed
Click a control in the studio window with the real pointer, as a person would — the demo cursor glides there and ripples (speed human). For a demo or teaching recording; otherwise edit with the project tools. The person allows the agent's UI control once per connection in the window; a control that spends credits is refused.
ui_set target, value, speed
Set a control in the studio window to a VALUE — a slider exactly (inside its own min / max / step; ui_find shows them), a select by an option's label, a checkbox true / false, a colour #rrggbb — with the real events, so the studio reacts as to a person. Answers the control's value now (and a note when the value was outside its range). The paid fence holds as for ui_click.
ui_type target, text, clear, enter, speed
Type text with the real keyboard, into `target` (clicked first) or into the control that has the focus; `clear` empties the field first, `enter` presses Enter after. Keys fall at a person's pace (speed human).
ui_hover target, speed
Move the pointer onto a control and rest there (its tooltip shows; the demo cursor glides).
ui_press key, command, step
One of: `key` — a key or chord with the real keyboard ("Enter", "Escape", "Mod+S", "Shift+ArrowRight"; Mod is the platform's command key); `command` — a studio command by id, as its shortcut would run it (ui_find commands:true lists them as cmd:<id>); `step` — a name for what comes next in the recording's cursor log (no key is pressed).
ui_drag from, to, speed
Drag with the real pointer from one place to another (a clip along the timeline, a handle, a slider) at a person's pace.
ui_scroll target, dy, dx
Scroll with the wheel over a control (dy > 0 down, dx > 0 right), in CSS px.
set_stage size, workspace
Make the studio window a clean recording stage: size "fit" (default) makes the page area the largest 16:9 this screen holds, "1600x900" an exact one if it fits, "restore" puts the window back as it was; `workspace` arranges the panels (all · all-columns · music · video · focus). Answers the page size it got — the recording's frame.
record_start production, productionName, quality, format, countdown, cursor, audio
Start recording this studio window (the tab itself, no share picker) for a teaching or ad video, with the demo cursor, click ripples and key captions on screen and a cursor log kept. `production` is the project the file goes to — another of the person's projects (from save_project / studio_info): the recording and its .cursor.json land in THAT project's assets and the project open here stays as it is; leave it out to record into this project (the clip lands on its timeline). Then demonstrate with the ui_* tools (ui_press step:"…" names each step for the log) and call record_stop.
record_stop restore
Stop the recording and save it: answers the file (filename — add it with add_clip url:<filename> in the production project), its project, length, size in px, the cursor log's name (sidecar) and the steps you named. A long recording takes a moment to upload. restore:true puts the window back after set_stage.
query_project brief, tracks, trackIndex, trackId, trackName, clipId, from, to, fullText, clips
Return a fresh structured snapshot of the project. Includes tracks, clips, selection, playhead; the current 3D `camera` pose (null if no camera track); and for modifier clips (anim/lfo/expr) their `targetClipId` and which properties they `drive` — so you can see the current animation/automation on the timeline. Use this to ground answers and to refresh state after mutations. Track `flags`: `helper` = a hidden host track for a clip's attached animation, mask or MIDI (not in the timeline: never a place for clips, not a layer); `bus` = an audio bus (no clips); `fx`, `mask`, `anim`, `path`, `midi`, `synth`, `camera3d`, `light`, `scenes` = what the track holds. A clip row shows `muted: true` (and `sound: 'off'` when a video's own sound is switched off), its level (`volume`, a video's `clipVolume`), `fx` (its effect plugins in the order they draw, a switched-off one as "~id"), `grade`, `lut`, `chroma` (its chroma key), `matte` (its matte repair), `proxy` (a local video's: ready / queued / none), `audioFadeIn` / `audioFadeOut` (its sound fades, seconds) and `missingFile: true` when the cloud file it plays is gone from the project (it plays nothing — `missingFiles` counts them); each track its `trackId` — every tool that takes a trackIndex also takes trackId or trackName. A big project: `brief: true` (each track's clip count, time range, types, muted and fx counts — no clip rows), `tracks: [i…]` (only those tracks' rows) or `clips: false`. One clip, one track or one stretch of time: `clipId`, `trackName` / `trackId` / `trackIndex`, `from` / `to` (seconds: the clips that play in it) — a focused read leaves the cast, the Kit and the models out; `fullText: true` gives each text / caption its whole words (rows cut them at 80 characters).
add_track type, name, empty, midiMode, position
Add a new track to the timeline. Use 'clip' for a generic media track that holds image/video/audio clips. Use 'fx' for an adjustment-layer track that applies color/LUT/transform to tracks below it (on top by default — `position` puts it under the text tracks). 'mask' and 'anim' are inserted above the currently active content track. 'camera3d' is a singleton (one per project). 'synth' and 'midi' are for music. Returns the new track's index.
list_projects query, limit
List the person's LimoStudio projects, newest first: projectId, name, length, shape, when it changed (`query`: words of a name). open_studio projectId — or projectName — opens one (in the studio's chat: open_project).
move_track trackIndex, position, trackId, trackName
Move a whole track up or down the stack (a higher track draws over a lower one; an fx track changes every track under it): position 'top', { below: <track> } or { above: <track> } — a track by its index, trackId or name. The main track stays where it is. Answers the track's new index.
duplicate_track trackIndex, name, trackId, trackName
Copy a whole track, right above it: every clip (new ids; the same media, trims, effects and sound), the track's own effects and sound. For two takes side by side (mute / hide one to compare), or a backup before remaking a track's clips (e.g. keep the current AI shots while the shot list is made again on another model). A copied shot's clip is no shot of the shot list — the original stays it. Not for a bus, the 3D camera, the scene track or a helper track. Returns the copy's track index.
add_clip trackIndex, placement, avoidFaces, type, start, duration, text, url, name, trackId, trackName
Insert a new clip on a track at a specific time. Duration defaults to 5 seconds when not provided. Returns the new clip's id. One clip per track is drawn at a time, so a text on a picture's own track hides under it (or hides it): a text or caption without trackIndex lands on a free lane ABOVE every picture it overlaps (a 'Titles' track is made when none is free — trackCreated); with a trackIndex where a picture overlaps, the answer warns (placement:'above' moves it up).
update_clip clipId, patch
Patch whitelisted properties on a clip identified by id. A field it cannot take, or a value out of range, comes back in `rejected` with the reason (nothing applied at all = an error). Use to rename, retime, mute, change opacity/volume/text/transition, etc. `end` stretches or trims a clip — a video clip too (a generated video keeps its first slot until you do). Also the clip tabs' own settings: speed (slow motion / fast — the clip gets longer / shorter so the same footage plays; keepLength:true keeps its length), endBehavior (what plays after its file ends), audioOffset (a sound clip's in-point), crop / rotate90 / flipH / flipV / fit / background (a picture or video clip's framing — the file stays as it is), blendMode, and a static scale / rotation (no keyframe needed). query_project rows show them back. The same patch on many clips at once: update_clips.
delete_clip clipId
Remove a clip by id.
move_clip clipId, newStart, newTrackIndex, newTrackId, newTrackName
Move a clip to a new start time and/or different track. Preserves duration.
duplicate_clip clipId
Duplicate a clip; new clip is placed immediately after the original, on the same track (a copy of the engine's own: its effects, style, masks and a compound's inner clips are its own; it is no shot of the shot list). Returns the new clip id; `overlaps` names a clip it now lies over (a track plays one clip at a time).
split_clip clipId, time, times, texts
Split a clip at a time on the timeline (or at several), on any track — the studio's own Split: a video / sound plays on across the cut, a caption's words go to the half they are said in (when it has word timings), each piece keeps the style, effects and masks. `texts` sets each piece's words (a text or caption clip; one per piece, in order). Returns the pieces' ids (the first is the clip itself). A shot-list caption's pieces stay the list's (they move with their shot or line). To cut a caption by sentence use split_caption.
split_caption clipId, clipIds, shots, narratorLines, all, timing, at, dryRun
A caption that holds several sentences becomes one caption per sentence — each with its sentence, the same style, back to back — cut where each sentence starts in its line's sound (shorter, calmer captions). Name the captions by clipId / clipIds, shots (their dialogue captions), narratorLines (1-based) or all:true. timing 'auto' (default, free): the caption's own word timings, else the pause in its line's sound (the narrator line or the shot's speech) nearest the estimate, else the estimate; 'heard': the line transcribed (about 3 credits a line, asked once); 'estimate': letters and punctuation only. dryRun:true shows the pieces and times first. A shot-list caption stays the list's: its pieces move with their shot or line, and new words make it one caption again. Pieces split before (by hand too) are left as they are.
create_alias clipId, trackIndex, start, aliasMode, aliasSrcOffset, trackId, trackName
Create an ALIAS clip that re-plays an existing clip elsewhere on the timeline (a live reference — edits to the source flow through). Works for video, audio, synth, MIDI, text, 3D and compound clips. Optionally place it on another track/start time, give it a different length, and choose how it maps: crop (play 1:1, hold/cut), loop (repeat), or stretch (fit the whole source to the new length). Returns the new alias clip id.
select_clip clipId
Select a clip (loads it in the property panel and FX gizmo).
seek time
Pauses playback if it was playing, then Move the playhead to a given time in seconds.
set_track_volume trackIndex, volume, trackId, trackName
Set a track's volume (its fader). Range 0..8 (1.0 = unity; the mixer panel's 800 %).
set_track_pan trackIndex, pan, trackId, trackName
Set a track's stereo pan in -100 (full left) to +100 (full right).
set_master_volume volume
Set the project's master output volume. Range 0..1 (1.0 = unity).
enable_mastering scope, trackIndex, clipId, enabled, trackId, trackName
Toggle the mastering rack (EQ + compressor + limiter) on a target. When enabling on an empty rack, default modules are seeded automatically.
query_mixer loudness, clips, measure, measureStart, measureEnd, scope, trackIndex, clipId, trackId, trackName
Read current mixer state for a target — volume, pan, FX chain summary, mastering state. Use this before mutating to ground decisions in actual values.
apply_transition clipId, clipIds, target, type, sound, duration
Apply a transition to a clip. target 'start' / 'end': the clip's own in / out animation (seg.startAnim / endAnim — 'fade in this clip', 'slide in from the left'). target 'between': the transition that brings the clip in FROM the clip before it on its track — a dissolve / crossfade / push … between two shots (FX › Trans › Between Clips), and with `sound` the sound's crossfade too (Audio › Fades); on a sound clip `type` is the sound's (crossfade, linear, dip, dj). clipIds for many at once (every shot of a track: their ids; the first clip of a track has nothing before it — startAnim fades it in). It needs the clip before to end where this one starts (warnings say when there is a gap). 'none' / '' takes one off. query_project rows show transition / soundTransition. For frame-accurate animation, use add_keyframe instead.
update_track trackIndex, trackId, trackName, name, muted, solo, hidden
Change a track: its name (rename), muted (the whole track silent — its clips keep their levels), solo (only the soloed tracks are heard, for listening in the editor; not saved with the project) and hidden (its pictures not drawn — the eye on its header). Name it by trackIndex, trackId or trackName (that is how it is found; `name` is the new name). query_project's track flags show audio-disabled / solo / hidden.
delete_track trackIndex, trackId, trackName, withClips
Remove a track. One with clips needs withClips:true (they go with it, one undo step) — confirm with the person before deleting clips they made. The main track, the Scenes track and hidden helper tracks stay. The tracks under it move up one index (name tracks by trackId / trackName after).
attach_mask clipId, shape, box, file, invert, feather, mode, remove
Give a clip its own MASK (the Mask tab): the clip shows only inside it (invert: outside). A shape — ellipse, circle, rectangle, roundrect, triangle, pentagon, hexagon, star, arrow, heart — in `box` (fractions of the frame, default the centred half), or `file`: a picture / video whose brightness (mode luminance) or see-through (mode alpha) is the mask. feather softens its edge. Attaching again replaces the mask; remove:true takes it off. A picture, video, 3D, text, caption, compound or vector clip. update_vector edits the shape's points after (its maskClipId).
duck_audio clipId, speechClipIds, speechTracks, duckDb, ramp, dryRun
Lower MUSIC under SPEECH (ducking): the music clip is cut into pieces at the speech's edges — one cue, each piece's in-point following on — at duckDb (−9 by default) under the lines and its own level in the longer rests, with a short crossfade at each change (the dip done as a line starts). The speech: speechClipIds, or every heard clip on speechTracks, else the project's spoken lines (made voices, narrator lines, the shot list's talking shots). Heard live and in the export; dryRun:true answers the pieces only. Ducking again does not lower it twice. query_mixer loudness:true measures the result.
import_subtitles text, file, name
A subtitle file as a NEW caption track at the file's own times: `text` (the .srt / .vtt / .lrc file's words) or `file` (a project file, list_assets). Its <i> / <b> / colour marks are kept. retime_clips shift moves them all; apply_text_look styles the track. (export_project type 'subtitles' writes one.)
reverse_clip clipId, forwards
Play a video or sound clip BACKWARDS: a reversed copy of the part it plays is made and saved to the project (a video with its sound, when it has one), and the clip plays it — the original is kept; forwards:true goes back to it. Free (made in the window, about as long as the clip). A split or speed change later is of the reversed copy.
separate_stems clipId, model
Split a SOUND clip into stems (Audio Edit › Stems): v1 (the default) vocals / instrumental, v2 finer at about 11× the price — the person's yes names the amount. Each stem lands as a sound clip on its own new track at the clip's place — Vocals heard, the others on muted tracks (update_track muted:false). The clip itself is unchanged. Made before it answers (about a minute).
add_keyframe clipId, prop, time, value, ease
Add (or replace) an animation keyframe for a property of a clip. The keyframe is stored on an animation clip that targets this clip — one is created automatically (on a dedicated anim track above, time-aligned to the clip) the first time you animate it, and reused for subsequent keyframes. Common props: fxOpacity (0..1), fxX/fxY (px), fxScaleX/fxScaleY (1.0=100%), fxRotate (degrees), fxBlur, fxBrightness, fxContrast, fxHueRotate, volume, pan. Call list_animatable_props for the full list. Tip: a simple fade/slide needs two keyframes (start value + end value). fxOriginX/fxOriginY = the pivot for fxRotate and fxScale, in % of the clip's own width/height (50,50 = its centre). Beyond 0..100 the pivot is outside the clip — that is how a clip orbits a point: set the origin ONCE (a single keyframe holds for the whole clip) to fxOriginX = 50 + (pointX − clipCentreX) / clipWidth × 100 and the same for Y (design px, 1080 short side), then fxRotate 0 → 360 with ease 'linear'. The clip does not move until it rotates.
remove_keyframe clipId, prop, index
Remove a single keyframe at index from a property on the clip's animation clip (the same prop keys as add_keyframe, plugin:<id>:<param> too).
clear_keyframes clipId, prop
Clear keyframes on the clip's animation clip. Either for a single property (prop — the same keys as add_keyframe, plugin:<id>:<param> too) or for all properties (omit prop).
list_keyframes clipId, prop
Read a clip's keyframes back: every animated property (or just `prop`) with its points in time order — time in timeline seconds, value, ease. Use it after add_keyframe to check a lane (a key outside the clip lands on its edge).
add_text_animation clipId, unit, preset, each, from, blendMode, timeSpanFree, lanes
Animate a TEXT or CAPTION clip per-element, CapCut-style: ONE keyframe tween is cascaded across the clip's letters, words, or lines with a stagger delay (GreenSock-style). Easiest path: pass a `preset` (fade, fade-up, fade-down, slide-left, slide-right, rise, drop, scale-in, pop, spin, typewriter, wave-in) and pick `unit`. For full control, pass `lanes` describing ONE element's enter motion — point times `t` are the per-element enter window in SECONDS (e.g. 0→0.3s), not the whole clip. Allowed lane properties: fxOpacity (0..1), fxX/fxY (px offset), fxScaleX/fxScaleY (1=100%), fxRotate (degrees). Elements that haven't started yet hold the first keyframe value (e.g. opacity 0 = hidden); finished ones hold the last. `each` is the delay between consecutive elements; `from` is the cascade order. Creates/reuses an animation clip targeting the text clip.
list_text_looks
List the Text Looks: ready-made caption / title designs (CapCut-style caption templates) that draw a clip's words — word-by-word social captions (a yellow box / pill / colour on the spoken word, minimal white, comic, gradient, hollow outlines filling in), read-along (dim → bright, light → bold, underline, highlighter, glow), karaoke and lyric stacks, plain subtitles, typewriter, decoder, neon; title motion (reveal from behind the line, cinematic letter spread, slam, slot roll, scatter …) — with their tags (social, highlight, karaoke, lyric, subtitle, minimal, elegant, playful, tech; titles: smooth, impact, cinematic, playful, tech, loop), their parts (accent colour, font, size, speed, words per page) and the In / Out / Loop animations (with their group: fade, move, scale, turn, reveal, fun).
apply_text_look clipId, look, scope, values
Put a Text Look on a caption or text clip. On a CAPTION it goes on the clip's whole caption track by default (every caption on it — the usual case; scope 'clip' = that caption only). On a text clip it is the clip's own. Ids from list_text_looks (e.g. captions builtin:highlight-box, builtin:minimal-pop, builtin:pop-yellow, builtin:read-along, builtin:karaoke, builtin:word-stack, builtin:clean; titles builtin:reveal-lines, builtin:cinematic, builtin:title-typewriter); look null removes it. `values` sets parts at once ({ accent: '#ff3366', size: 1.2, speed: 0.8 }). Prefer this over add_text_animation for caption STYLES (the look times the words to the speech by itself). Only caption looks carry a font part (builtin:clean: color, font, size — any Google Fonts family name); a title look (cinematic, reveal-lines) has none: give a title its font with style_text.
set_text_look_value clipId, part, value
Set one part of the look a caption / text clip shows (accent colour, font, size, speed, words per page …; ids from list_text_looks). A track's look: set for every caption on it.
style_text clipId, match, wordIndexes, range, all, style, outlineWidth, shadow
Style words inside ONE text or caption clip (rich text — a colour, bold, a bigger size, a font for some words, not the whole clip). Pick the words with `match` (every place these words appear, any case), `wordIndexes` (the drawn words, from 0), `range` {from,to} (drawn characters) or all:true. `style`: bold / italic / underline / strike / code / highlight (true on, false off), color / bg / outline (hex like #ff3366; bg also with alpha, #00000080 = a half-see-through backing that keeps words readable over a bright picture), size (0.25–4 × the clip's size), font (a font family name), weight (100–900); null takes one off. A caption's word timings stay. The whole clip's look too: outlineWidth (the outline's thickness) and shadow (a drop shadow: color, blur, dx, dy, opacity) — with or without `style`. Use this instead of writing markup into update_clip's text. Fonts: any Google Fonts family name works here and in text looks (loaded on demand — Cinzel, Marcellus, Cormorant Garamond …), not only the panel's list; a title's font is set per span with `font` (title looks carry none).
mark_key_words clipId, mode, words, allCaptions
Mark the key words a look sets apart (bigger / an accent colour — e.g. FRAGILE in a lyric word stack). mode 'set': `words` (indexes from 0, or the words) become this clip's key words; 'guess': the longest real word of each page (free); 'ai': an AI reads the captions and picks (a few credits). allCaptions: every caption on the clip's track.
add_clip_cascade clipId, trackIndex, preset, each, from, blendMode, timeSpanFree, lanes, trackId, trackName
Cascade ONE keyframe tween across ALL clips on a track, staggered by their order — e.g. a row of images/cards that fly or fade in one after another. Same stagger engine as add_text_animation, but the elements are whole clips instead of glyphs. Identify the track by `clipId` (any clip on it) or `trackIndex`. Pass a `preset` (same set as add_text_animation) or explicit `lanes`. The cascade is anchored to the track's earliest clip and defaults to time-span-free so clips spread across the timeline all participate.
list_animatable_props clipId
Return animatable property keys with their min/max/default ranges, for use with add_keyframe / expressions. Pass `clipId` to get ONLY the props valid for that clip's type (e.g. camera props for the camera clip, worldX/Y/Z only for 3D, clipProp:<id> for compound/script/expression params, audio for audio-bearing clips); each prop also carries its `group`. With clipId the clip's effect plugins' number params come too (group 'Plugins', key 'plugin:<pluginId>:<param>', with `current`); an fx clip lists only what it hands the layers under it (Transform, Blend). Omit clipId for the full flat table.
apply_lut clipId, preset, intensity, mode
Apply a built-in LUT preset to a clip. Replaces any existing LUT on that clip by default. Use list_presets('lut') to see all available preset names.
apply_color_preset clipId, preset
Apply a quick color-grading preset to a clip's color FX stack (replaces previous quickfx contributions). Presets: cinematic, vintage, noir, neon, dreamy, bleach, retro, golden, cold, none.
set_grade clipId, lift, gamma, gain, wbGain, curves
Set professional color-grade parameters on a clip: 3-way Lift (shadows) / Gamma (midtones) / Gain (highlights), white-balance gain, and per-channel tone curves. lift/gamma/gain/wbGain are each {r,g,b} (lift neutral 0; gamma/gain/wbGain neutral 1). curves is {master,r,g,b}, each an array of {x,y} control points in 0..1 (master = RGB/luma). Only include fields you want to change; enables the grade automatically. This is the deeper, banding-free grade — prefer it over apply_color_preset for precise correction.
analyze_frame_color clipId
Analyze a clip's own pixels at the playhead (other tracks, background and transparent/matted areas excluded; the clip's grade is ignored) and return objective color statistics: per-channel mean RGB 0-255, std deviation, black/white points, luma and median luma 0-1, whiteBalance {confidence 0-1, suggestedGain {r,g,b}, correction in words — derived from the clip's near-neutral surfaces, 'none' when there are none}, skin {fraction of the clip, confidence, meanRGB, hueDeg, hueOffsetDeg from the natural skin line (negative = too red/magenta, positive = too yellow/green), chroma} or null, and the current grade. Use this to decide how to correct or match a clip. Moves the playhead onto the clip first.
auto_color_correct clipId, strength, parts, wbStrength
One-shot technical color correction of a clip from its own pixels: white balance from its near-neutral surfaces (left alone when there are none, e.g. a sunset), uniform levels (lift/gain) and exposure (gamma), and a mild skin-tone protection. Keeps the master curve and any 3D LUT (the look); resets the R/G/B curves. Idempotent (running it twice gives the same grade). Returns a summary of what changed. Enables the banding-free grade.
fix_skin_tone clipId, strength
Find the skin in a clip (faces, arms; cast-tolerant, ignores textured warm areas like leaves) and rotate its hue onto the natural skin-tone line using per-channel midtone gamma. White balance, exposure, curves and LUT are kept; black and white stay put. Skin already within ~2.5° of the line is left alone; rotations are capped at 25° (a stronger cast needs auto_color_correct or a white-balance fix first). Use when faces/people look too green, magenta, red or yellow. strength 0-1 (default 1). Returns a summary incl. the detected skin share.
match_clip_to_reference clipId, referenceUrl, strength
Match a clip's colors to a reference image (by URL) using statistical (Reinhard-style) color transfer baked into the grade curves. Use to match a shot to a look or to another shot. strength 0-1 (default 1).
add_fx_plugin clipId, pluginId, params, position
Add a visual FX plugin (shader effect) to a clip. Optional `params` is an object of plugin-specific overrides; missing keys use plugin defaults; unknown keys ignored. Common plugin ids: bokeh, crt, glitch, chromatic-ab, vignette, blur, film-grain (or 'grain'), aurora, divine-bloom, light-leak, lens-flare, kaleidoscope, halftone, ascii, edge-glow. For the full registry, call list_presets('plugins'). User-authored shaders (ids starting `user.`, e.g. ones just made with create_plugin) are routed automatically to the clip's 'User FX' tab; built-in effects go to 'Visual Effects'. Use this same tool for both. Effects draw in stack order: anything that glows or blurs (divine-bloom, bokeh, soft-focus) must come BEFORE cinema-bars or it spills into the bars — `position: 'first'`. The answer's `fx` is the stack in order (remove_fx_plugin / move_fx_plugin change one).
remove_fx_plugin clipId, clipIds, trackName, pluginId, pluginIndex
Take ONE effect plugin off a clip (clear_fx kind 'plugins' takes them all): by pluginId (every copy of it) or by pluginIndex — its place in query_project's `fx` list. Its keyframes go with it. Answers the stack left (`fx`).
move_fx_plugin clipId, pluginId, pluginIndex, to
Move one effect plugin in the order a clip's effects draw (a glow before cinema-bars, the bars last): by pluginId (its first copy) or pluginIndex, `to` 'first', 'last' or a place in the fx list. Answers the stack in order (`fx`).
set_fx_plugin_param clipId, pluginId, pluginIndex, param, value, enabled
Update a parameter on an existing FX plugin entry on a clip. Searches both the 'Visual Effects' and 'User FX' stacks. Identify by pluginId (uses the first matching entry), or pluginIndex if multiple of the same id are present. `enabled: false` switches the effect off (its eye) and keeps its settings; true on again — param / value may then be left out. To animate a param over time: add_keyframe prop 'plugin:<pluginId>:<param>'.
clear_fx clipId, clipIds, trackName, kind
Remove FX from a clip — or many at once (clipIds, or trackName for a whole track). kind ∈ 'lut' (LUT stack), 'color' (color/quickfx stack), 'plugins' (both Visual Effects and User FX shader stacks), 'all'. (set_project_settings letterbox:null also takes Cinema Bars off every clip.)
list_presets kind
List names of available presets/registries to ground tool calls. kind ∈ 'lut', 'color', 'plugins', 'plugin-categories'.
search_stock query, type, count
Search Pexels for stock images or videos. Use this when the user wants to find existing photos/footage. Results are shown as clickable thumbnails inline in the chat — the user can click one to confirm. Do NOT call import_stock automatically afterwards: wait for the user to pick a result before importing.
import_stock url, type, target
Import a stock image or video URL into the project's assets. Returns the saved filename (a bare name for cloud storage, or `local:<name>` when it was written into the user's linked local folder) — pass it unchanged to add_clip's `url`. Use this after the user picks a result from search_stock. `target` chooses where the file goes: 'local' = the linked local folder on the user's machine (no upload, faster for big videos; falls back to cloud when no folder is linked and says so in the result), 'cloud' = project cloud storage, 'auto' (default) = whatever the Assets panel's Local/Cloud toggle is set to. Use 'local' when the user asks for files in their local folder / on disk.
resize_video_clip clipId, sizePreset, customMaxSide, keepAudio
Re-encodes a video clip's FILE to a smaller picture size (in-browser ffmpeg: libx264, lanczos scale; free, but slow on a long video) — it does NOT change how long the clip is: for that use update_clip start / end. Maintains aspect ratio; result replaces the clip's url. Use to shrink oversized stock 4K videos for playback or video-to-video AI APIs. Slow on large videos — show the user that it may take a while.
rasterize_clip clipId, sizePreset, customMaxSide
Shrink an image clip's original source to canvas size (or a smaller preset). Bakes the texture fit (cover/contain/original) and image offsets into a new file. fxTransform, color FX, LUT, and plugin FX are preserved. Use to fix oversized source images that are slow to play back or rejected by image-to-video APIs (which often cap at ~2K).
generate_vector prompt, model, quality, aspectRatio, style, picture, addAs, seconds
Make vector art with AI — a logo, an icon, an illustration, or a project picture turned into vector shapes — and add it at the playhead: as editable vector shapes in one group clip (default) or as an SVG picture. Costs credits — only call when the user asks for vector art, an SVG, a logo or an icon to be made.
generate_image prompt, aspectRatio, model, references, clipId, place, quality
Generate a NEW image (to change an existing picture use edit_image). The person's AI Img model unless `model` names one. `references`: pictures that steer it (a person's face, a product, a style) — project filenames or @Names from the snapshot's kit / a <mentions> line; they go instead of the Kit's ticked pictures, and the prompt should say what each is for ("the woman from @Anna", "in the style of @poster"). `clipId` + place 'replace' puts it on that clip (what it showed stays in its takes); place 'new-clip' adds a picture clip at the playhead; 'asset' (the default without clipId) only saves the file — the returned filename goes to add_clip. Costs credits — only when the person asks to generate/create an image (not to find one).
text_to_video text, style, visualSource, mediaType, audioMode, imageFit, aspect, music, musicVolume, musicLoop
Build a narrated TEXT-TO-VIDEO slideshow from a block of text in ONE call. The tool splits the text into scenes, generates speech per scene (so timing is exact), and lays back-to-back narration + synced captions + a Ken-Burns image (or stock video) per scene onto new tracks. Call this ONCE with the full text — it runs the whole batch internally. Do NOT add clips yourself or call it per scene. Costs TTS credits per scene (and image credits when AI images are used). Voice follows the user's current Speech settings unless they say otherwise.
compose_story_movie story, style, shots, audioMode, continuity, makeScenes, consistency, music, aspect, imageFit
Plan a short AI FILM from a logline or script in ONE call. The tool breaks the story into shots, casts CONSISTENT characters (reusing the project's Kit characters by name, else AI-generated), and lays a Shots track (character shots on Kling O3 Reference with the cast's pictures; establishing shots use Gemini Omni 1.2) plus a Captions track with the dialogue — onto new tracks. Call this ONCE with the full story; it builds the shot list + cast + preview keyframes — the project's shot list (get_shot_list). The expensive AI-video render is a SEPARATE step: generate_shots, or the 'Generate movie shots' button (this tool does not render the videos). Character shots can speak dialogue with the cast's own voices. Costs image credits for previews; video + voice credits at render time.
make_cast cast, redo, remove, rename, views, redoViews, style, model, editModel, quality
Make the video's CAST once, BEFORE plan_shots, when the story has recurring named people, animals or places (or the person asks for characters, or attaches a photo of someone). Each becomes a Kit entry with its own picture, reused by name in every later shot and in later videos, so faces and places stay the same. About 40 credits per picture made (none for a photo; 0 on a model of the person's own ComfyUI); the person sees them in the chat and can redo one. People already in the snapshot's `cast` are reused — list only new ones (or redo / remove names). Their extra views are made with the shots (generate_shots counts them in its one approval). An OUTFIT is a copy with its own name: a row { name: 'Matti suit', copyOf: 'Matti', outfit: 'a dark blue suit' } keeps the face (its picture edited, ~60 credits; without outfit an exact copy, free) — then shots name the one they wear. A one-off scenic video needs no cast.
cast_library action, names
The person's SAVED cast — their Elements library, reusable in any project and free: each keeps its pictures, views, voice and description. list = who is saved; use = bring them into this project ("a new episode with Mia and Max"); keep = save cast members (anyone with a picture; saving again updates them).
generate_speech text, language, voice, at, clipId, replace, trackIndex, model, trackId, trackName
SPEAK words in any language — Finnish, Swedish, English … — and put them on the timeline as a sound: a voice-over, a narration, one line. Spends credits (a voice, about 0.2 credits a character). The sound lands at `at` seconds (or a clip's start, or the playhead) on a new Speech track unless trackIndex names one. For a shot list's lines use plan_shots settings.language instead: generate_shots makes them with the shots. A line made already (its words and voice: query_project `says` / `voice`, get_prompts clipId): replace:true with its clipId makes it again IN that clip with `text` — a fixed word, a new take — in the same voice and language unless voice / language are given; the old sound stays as a take.
change_voice clipId, voice, restore, model
CHANGE THE VOICE of the speech in an audio or video clip — its words, timing and lips stay, only the voice is new (speech-to-speech): a made video's Finnish in a cast member's own voice, the same voice in every shot. Spends credits (25 a started minute of the clip, plus about 25 once per project for a named voice's sample). A video clip keeps its picture: its new voice goes on a Speech track at its start and its own sound (with its background) is turned off. An audio clip plays the new voice in place; its sound before is kept as a take. restore:true brings the original voice back (free). Up to 5 minutes of a clip at a time. model 'comfyui' runs the same Chatterbox on the person's own ComfyUI (free); left out: the person's pick in the Voice tab.
make_narration text, clipId, file, script, contentType, visuals, language, voice, exact, opener, style, dryRun
NARRATION FIRST — a talked script or a voice recording becomes the spine of a video (news, a podcast, an explainer, a tutorial, an ad, a narrated story). From `text`: each line is said by ONE voice in its language and laid back to back on a Narration track (about 0.2 credits a character). From a recording (`clipId` of an audio or video clip, or `file` from list_assets): every word is heard and timed (about 1 credit a minute; with `script` the person's own words are timed by it). Asks the person once with the amount. Returns the narration's BEATS — the stretches one picture covers, each with its lines and seconds: then plan_shots with narration:true, one shot per beat. `contentType` sets the beat sizes and, with plan_shots, the designs, caption look and music.
narration_to_video text, clipId, script, contentType, visuals, style, wishes, title, language, voice, exact, music, replace, dryRun, maxCredits
The ONE-CALL narration video: from a talked script (`text`) or a recording on the timeline (`clipId`) the narration, the pictures (picked per beat by the kind), the designs (name straps, cards, titles, an opener and an end card), word-timed captions in the kind's look and music ducked under the voice are made and laid, and the AI pictures render in the background — after ONE approval with the total. Use it when the person wants it all at once; make_narration + plan_shots when they (or you) choose the pictures. dryRun:true = the price only. End your turn after it starts.
list_designs category, query, aspect, limit
The DESIGNS library (ready-made animated templates): name straps / lower thirds, title cards, news, tutorial and infographic cards, intros, outros, social cards … each with its editable slots (`variables`). Free. Filter by category or words; only the project's frame shape unless aspect 'any'.
insert_design id, values, at, trackIndex, mute, trackId, trackName
Place a design (an id from list_designs) at `at` seconds with its slots filled (`values`: variable id → words, a number or a colour). Free. It lands on track `trackIndex`, or a new track above when that one is busy there. mute:true silences its own music (a card over a voice).
plan_shots title, logline, style, aspect, cast, settings, shots, mode, narration, graphics, opener, endCard, narrator, hook, makeScenes
Be the DIRECTOR of a multi-shot video: write its shot list yourself and lay it on the timeline in ONE call — a Shots track (one clip per shot, back to back) and a Captions track for spoken lines. The list is the project's own and outlives this chat: get_shot_list reads it back in full. Every shot is an AI video (source 'ai') unless the person asks otherwise: 'stock' = a stock video or photo found by `query` (placed now), 'asset' = one of their uploaded files (`file`, from list_assets), 'still' = one AI picture with a slow camera move (far cheaper than video). Nothing is generated here — generate_shots makes the AI shots after one approval. A character shot names its people in `characters`: Kit characters by their exact names keep the same face and voice; anyone else gets a portrait when the shots are made. mode 'append' adds shots after the list; 'replace' starts over (say it explicitly when shots were already made — their clips are removed).
make_storyboard shots, redo, grid, scene, imageModel, editModel, keep, quality, all, dryRun, maxCredits
A STORYBOARD before any video — only when the person asks to see the shots first ("show me a storyboard", "kuvakäsikirjoitus ensin", "let me check the pictures"): every shot's picture is made — a picture of each character shot from the cast's pictures, each establishing shot's start picture, the stills — laid on the timeline and shown in the chat, where the person redoes any or downloads it all as one sheet. generate_shots then starts every shot from exactly its picture. One approval with the total — each picture priced as it is SENT, its quality and size (GPT Image 2.5 medium ≈ 40, an edit ≈ 39 + 15 a reference; quality picks low / medium / high); runs in the background — end your turn. A picture that did not land reads storyboard 'failed' with the reason in get_shot_list / wait_shots (it is tried once more by itself first). all:true draws EVERY shot again (with dryRun: the price of a whole redraw on another model). grid:true makes one 3×3 picture per place instead (one look per scene, ~240 credits each, cut into its shots). scene:true makes ONE storyboard sheet per scene (consecutive shots in one place, up to 6 and as long as one clip — Gemini Omni: 10 s, so plan 1.5–3 s shots) and generate_shots then makes each scene as ONE clip from its sheet — the same people, look and light across the scene, cut back into its shots (the storyboard approach: when the person asks for it, or for one consistent look over a longer clip; ~240 credits a sheet). A line spoken by the model, or fitted on after ('fit'), works in a scene; a lipsync / avatar / reference / 'voice' shot is made alone. After update_shots changes a storyboarded shot's words its picture reads 'out of date': redo:[n] draws it again (generate_shots also does it first by itself, in its own estimate).
get_shot_list brief, shots, fields, narrator, narratorLines, sections
Read the project's shot list in FULL: each shot's state (planned / generating / done / failed / missing), its words as the video model gets them (`sends`, nothing cut), seconds, model and clip ids, what its video was last asked from (`sent`: the model, the start picture and where that came from — its own picture, the previous shot's last frame …), the cast, and what the pending shots cost. A video that came back black is made again once, then on settings.fallbackModel, then fails its shot (the clip keeps what it had); a model that answered busy is asked again by itself (wait_shots `busy`). `storyboard` 'failed' (+ storyboardError): its picture did not land (the model's reason), was empty, or came back a flat grey placeholder — make_storyboard draws it again. A row's `warning` also says when a shot was made on the fallback model, still opens black, or had its voice changed because it could not be fitted. `lastRun`: what the latest batch / storyboard run did and was really charged (creditsUsed). The narrator is summed up (lines, made, the ones warned) — narrator:true lists each line. Use it to review the plan, to follow a batch, and before changing shots. The whole list is long (every shot's words): brief:true gives each shot's number, state, model, seconds, clip and what it was sent from; shots:[n] only those shots; fields:[…] only those fields. To follow a batch, wait_shots is cheaper still. The shot list is shared by the project's versions: in one version, a shot whose clip is in another reads state 'other-version' with its `version` name — pending, the storyboard and plan defaults leave it alone; switch_version to that version to make, redo or remove it.
update_shots shots, order, remove, style, verbose, settings, graphics, narrator, removeGraphics
Edit many shots of the shot list in ONE call: their words (action, dialogue, setting, characters, kind), seconds, model or way to speak (speech); a new `order`; `remove` some. Their clips and captions follow: a shot longer, shorter or removed moves only what comes after it (gaps between clips stay; a new order lays them back to back), and the shots are numbered 1…N again (the numbers you give are the list's before this call). A changed shot that was already made keeps its video until generate_shots makes it again (shots:[n]). To change a shot's source, remove it and plan_shots with mode 'append' — except source:'still' on a made AI shot: it shows its own start picture with a slow camera move (0 credits, state done, its number, narrator, sound effects and caption kept; a shot that renders black again and again) and source:'ai' lays its video back. Returns only the changed shots and the counts (get_shot_list reads the list whole). While a batch runs, shots outside it can still be edited; its own shots, a new order and the settings wait for it. A name in `characters` must be in the list's cast or the Kit (a Kit character made after the list joins its cast); an unknown name is refused. A shot whose start picture was edited by hand (edit_image on its clip) keeps that picture when its words change — videoPrompt changes only the video's words.
generate_shots shots, only, lines, redo, redoPictures, quality, keepPicture, dryRun, maxCredits, turnaround, padTo, compare
Make the shot list's AI shots in ONE batch. The person is asked ONCE, with the total ("Generate 12 shots for about 9,400 credits?"); the shots then render in the background (minutes each) and the person sees the progress — END YOUR TURN after it starts; get_shot_list later shows each shot's state. shots: 'pending' (default: not made yet, or failed), 'failed', or shot numbers (made again even when done). A made shot whose line did not reach it (its `warning`: the lipsync or the voice failed) is failed too: only its line is done again, its video kept. only:'speech' with shot numbers makes their lines again and only them — the lips moved over the kept silent video (lipsync), the line laid again (narration), the talking picture made again (avatar) — for a wrong word or a bad take, at a fraction of a new video. dryRun:true only returns the estimate — no dialog, nothing spent; use it when the person asks the price. maxCredits: refuse above it. Consecutive shots of the same people go as one storyboard (one consistent scene); a shot in the same place as the one before starts from its last frame. While a batch runs, a new call is QUEUED behind it (asked now, started by itself when the batch is over; the shots it is making are not asked for twice); when nothing is to be paid (every model on the person's own ComfyUI) no dialog opens. wait_shots follows a batch. Shots whose clip is in another project version are not made here (`skipped` names them): switch_version first. A storyboarded shot whose words changed after its picture was drawn (get_shot_list storyboard 'out of date') has its picture DRAWN AGAIN FIRST, in the same yes and estimate (`picturesRedrawn` names them) — a video from the old picture repeats what was wrong with it; redoPictures:false refuses those shots instead — and so is a picture that came back a grey placeholder (storyboard 'failed'). A corrupt render (static, BLACK, or a NaN / Inf in its sound — an LTX video that OPENS black too) is made again once with a new seed, then on settings.fallbackModel when set. A model that answers busy ("Upstream service is busy") is asked again by itself after 30 s, 60 s and 120 s, then the fallback model — never re-run busy shots yourself (wait_shots shows them); Gemini Omni 1.2 runs at most 3 at once. A 'fit' line that cannot be fitted is changed instead (speech 'convert', its cost in the yes as speech.fitFallback.upTo, `creditsCeiling`); a converted voice reads speech.voiceChanged in get_shot_list. The person's yes: one question with the total (or none within their auto-mode rules, or for a run under their per-run spending guard); an unanswered question ends after 10 minutes (code approval-timeout, nothing spent). The answer says `asked` (true: the person said yes; false: it went through unasked) and `why` — tell the person what really happened, never "the window will ask" when asked is false. The batch keeps its REAL spend within the approved amount (creditsCeiling, or maxCredits): a voice change beyon
set_ai_model kind, model, scope
SET an AI model as the person's choice — what list_ai_models shows as `picked` (scope 'pick': the panel's pick of that kind — AI Img, Image Edit, AI Vid's Video / Characters, Music …; the Director reads some of them) or as `chatDefault` (scope 'chat-default': Settings › AI Assistant › Models the assistant uses — what every tool uses when it names no model; 'auto' = the assistant chooses). Takes the label as the person says it ("FLUX.3 Klein", "LTX-2.5") or the value. A model that runs only on the person's own ComfyUI is refused while none is set up (Settings › ComfyUI, in THIS window). Saved on this device, like a pick made in the panel. Use it when the person says which model to use from now on, or wants the free ComfyUI models everywhere.
wait_shots timeoutSec, shots, brief, tail
WAIT for the shots being made — the running batch, the queued ones, storyboard pictures — and answer with their states (brief) when they are done or timeoutSec is up (default 55, at most 120: it never hangs — call it again). shots:[n] waits for those only. A batch's tail after its videos — its sound effects, the score, narrator lines made in the background — is waited for too and named in `tail` ("sound effects 12/26"): when it answers done, make_storyboard and the list's settings can change. `busy`: shots waiting on a model that answered busy — it is asked again by itself after 30 s, 60 s and 120 s (nothing charged for a busy answer): WAIT, do not re-run them. A storyboard picture that failed is named with its reason; `lastRun` says what the run did and cost. brief:true = only the counts, the failed and the warned shots (no row per shot). Far cheaper than polling get_shot_list.
time_sound clipId, videoClipId, shot, window, step, highpass, apply
TIME a sound to the picture without listening: a sound clip's loudest moment (`peakAt` — a click, a hit, a snap; highpass favours a sharp transient over a louder swell) against its video's biggest frame-to-frame change (`motionAt` — read every `step` seconds over the clip or a `window` around the sound, at most 150 frames), and `suggestStart` = the start that puts the one on the other. apply:true moves the sound clip there (a shot's own sound effect keeps its new offset in the shot list). The video: videoClipId, shot:n, the shot the sound belongs to, else the picture under it. Free; a few seconds.
set_chroma_key clipId, clipIds, enabled, color, similarity, smoothness, spill
The FREE chroma key on clips (Media › Remove BG › Chroma key): a backdrop colour turned transparent, or a green / magenta rim a cut-out kept taken off. similarity 0–0.8 (how far from the colour is keyed — raise it until a green cap on hair is gone), smoothness 0–0.5 (the soft edge), spill 0–1 (the colour's tint taken off what stays — high for a green rim), color #rrggbb (default green). Naming a value switches it on; enabled:false switches it off and keeps the values. Answers the exact values set; query_project shows `chroma` on the row. Do not key a clip whose subject has the colour (a green guitar).
remove_background clipId, clipIds, method, refineEdges, dryRun, status
REMOVE the background of video / picture clips (Media › Remove BG): `method` 'browser' (default — free, on this computer's GPU, about real time), 'rvm-local' (free, the LimoMatte Mac helper), or a paid cloud one — 'veed-fast' (~12 credits per 30 frames; refineEdges:false cheaper), 'bria' (high quality, ~140 a second), 'rvm' (budget, ~2 a second). dryRun:true quotes it (the server bills each file's own length — a trimmed clip may cost more). A paid run asks the person once with the price. A video's result is a transparent WebM the clip then plays (the old media in its takes); it runs in the background — status:true follows it; audit_matte measures the result (a re-matte is not always better).
audit_matte clipId, from, to, step, withKey, sheet
MEASURE a cut-out video's matte, free, from its frames (every `step` s between from / to, timeline seconds): `coverage` {min, median, max} of the frame the person covers and the `dips` where it falls under its rolling median (a lost leg, a flickering patch), `interiorSemiTransparent` (see-through pixels INSIDE the silhouette — share, mean alpha, bbox in 0–1 of the frame, the worst moment), `edgeFringe` (a green / magenta rim — after the clip's chroma key), `flags`, and one contact sheet of frames on a flat magenta. Use it before and after remove_background, set_chroma_key or update_clip matte to show it is better in numbers.
make_proxy clipId, clipIds, all, status, force
A smaller copy of a LOCAL video for the editor (an alpha one keeps its alpha — cache/<name>.proxy.alpha.webm in the linked folder): playback gets lighter, the export still reads the original. One at a time in the background; status:true (or studio_info.proxies) shows ready / queued / missing; query_project rows show `proxy`. A 1080p alpha clip plays as it is by default — make one when its playback stutters or mis-draws.
analyze_audio clipId, minSection
A song's TEMPO, BEATS and SECTIONS from its sound (the part of the clip that plays, timeline seconds) — `bpm`, `beats` (times), `sections` [{t0, t1, label A/B/…, level quiet/medium/loud}] where the sound changes most — so cuts and plates follow the music. Free, a few seconds. Sections are a guess from loudness and how busy it is: confirm by ear or ask the person.
add_shadow clipId, opacity, softness, width, color, blur, dx, dy
A soft CONTACT SHADOW at a cut-out person's feet: an ellipse sized from the clip's alpha (its middle frame) and its place / scale, feathered, on a new track right under the clip's — no file written. opacity (default 0.45), softness 0–1 (default 0.5), width (× the person's width, default 0.85). update_vector feather / opacity / box tunes it. On a TEXT or caption clip: a drop shadow on its letters (color, blur default 10, dx 4, dy 6, opacity 0.6 — the same as style_text shadow).
audit_shots shots, speech, cast, pictures, loudness, sheet, cols, width, frames, at, verbose, dryRun
CHECK a made shot list in ONE call, after a batch — instead of a screenshot and a transcription per shot. Per shot: its state, its time on the timeline, its first frame read for a black or static (noise) picture (`corrupt`), whether its converted / fitted voice is there (`voice`), its own sound measured from the file (`sound`: hasAudio, LUFS, true peak, level silent / quiet / present, `on` — whether the clip's sound is heard), and for a shot with a line, what is HEARD and how well it matches (`heard`; from its voice clip when it has one). The flags come first, worst first ('shot 2: static (noise) picture', 'shots 4, 5: voice not changed / fitted'); 'muted' only says a shot's own sound is off (a model's own music muted on purpose is fine); 'doubled' = its own sound heard under the voice laid for it; 'castless' = an establishing shot naming its cast (no face is drawn); 'extras' = a person in its words but no characters (an uncast, often malformed figure) — the last two are read from the words, free. `muted` counts the shots whose own sound is off. With it ONE picture: a contact sheet of every shot's first frame, numbered (after a row of the cast's own pictures, @Name), the flagged ones in red. A shot without a line is measured, never transcribed. Hearing costs about 3 credits a line (up to 8 lines a call; dryRun:true quotes it, speech:false skips it and costs nothing). Then fix what is flagged: generate_shots shots:[n] (only:'speech' for a voice), update_shots shots:[{n, model}] for a corrupt one. pictures:true audits the storyboard pictures before the videos (free). frames:true LOOKS at the made videos (free, no hearing): each shot's frames at `at` (fractions of its clip, default 0.1 / 0.5 / 0.95) in one numbered sheet, each frame with its time and the file's size — a video smaller than the list's resolution is named (12 shots a call). For faces, hands and profiles name a few shots with cols:3, width:640 (bigger tiles). The answer lists the flagged (or named) shots' rows and the others as `clean` ranges — verbose:true gives every row.
search_sfx query, maxSeconds, license, limit, page
SEARCH the Freesound sound library (free: 500k+ effects, ambiences, foley) — CC0 sounds only by default (no credit needed). Rows: id, name, seconds, licence, attribution, previewUrl (what import_sfx lays). Words that name the source and the room work best ("clay pot smash on stone", "crowd panic distant", "ram horn shofar blast"). Nothing fitting: generate_sfx makes it.
import_sfx previewUrl, id, name, seconds, bed, at, shot, offset, trackIndex, volume, fadeIn, fadeOut, trackId, trackName
LAY a library sound (search_sfx) on the timeline: it is imported into the project (storage only) and placed on the project's SFX track at `at` or at a shot's start + offset. Its own length unless `seconds` cuts it.
generate_sfx prompt, seconds, variations, loop, influence, model, at, shot, offset, trackIndex, volume, fadeIn, fadeOut, dryRun, trackId, trackName
MAKE a sound effect from words — a jar shattering, a door, footsteps on gravel, a sword drawn, a crowd gasping, a horn blast — and lay it on the project's SFX track at `at` or at a shot's start + offset. The person is asked once with the price (dryRun:true quotes it; nothing to pay on 'comfy'). variations: several takes — the first is laid, the others are in the project files (`alternatives`). Name the source, the action, the distance and the room; no music words. Every shot of a shot list can carry its own (plan_shots shots[].sfx).
generate_ambience prompt, start, seconds, volume, fadeIn, fadeOut, trackIndex, model, dryRun, trackId, trackName
MAKE an ambience bed — wind over a ridge, a fire crackling, a distant camp, rain, a market — from words: ONE seamless take (up to 30 s, Mirelo up to 60 s) repeated from `start` for `seconds` on the project's Ambience track (auto_mix_project reads it as background). Priced for the one take (dryRun:true quotes it). Under a hush with no score, a bed keeps the film from sounding dead.
foley_from_video clipId, shot, prompt, variations, volume, trackIndex, dryRun, trackId, trackName
MAKE the sound effects of a video clip FROM the video (Mirelo SFX 1.6 video-to-audio: footsteps, impacts, cloth, fire as they happen in the picture) and lay them under it on the SFX track. The clip must be in the project's cloud files. About 20 credits a second of its video (dryRun:true quotes it). The clip's own sound stays: mute it when the foley replaces it.
level_speech shots, target, dryRun
Level the shot list's spoken lines to ONE loudness as they are heard: each line (a fitted, changed or made voice on the Speech track) is measured on its own and its clip level set so that, with its track's fader, it is heard at `target` — by default the narrator's lines as heard (their median), else −20 LUFS; a shouted line (ending "!") 2 dB over. Free, one undo step. A batch does this by itself for the lines it lays (settings.levelSpeech); use it after hand edits or for lines made before. dryRun:true measures and says, nothing set. A shot that speaks with its video's own voice has no line clip — update_clip volume on its clip.
transcribe_clip clipId, shot, expect, provider, language
HEAR a clip: its sound transcribed — the words with their times on the timeline — so you can tell what is said in a video or voice clip without listening, and whether a shot's line was spoken as written: with `expect` (or `shot`, whose dialogue is the expectation) the result carries `match` (0–1) and a verdict: 'the line as written', 'roughly the line', 'not the line', or 'cut at the end' (its last word is not heard, or ends within 0.3 s of the clip's end — `cut` says which: give the shot more seconds, or shorten the line). About 1 credit a minute (AssemblyAI; 'whisper' is the other provider). Use it after a batch to check the speech of shots with lines, and a silent shot (match against '' → text should be empty). A made-up transcript — a stock phrase over music ("Transcription by…", "Thanks for watching"), one phrase repeated, every word at one moment — answers suspect:true with the reason and no text: a sung mix is not transcribable this way (analyze_audio gives its tempo and sections). The answer says about what it cost (credits).
export_status verify
Whether an export (export_project) is running, its latest step, and the last file that landed: its name, kind and where it went (a download is in the person's Downloads folder under that name; through the MCP server, studio_info.downloads has its path on their computer). Poll it after export_project instead of watching a folder. When done it also gives the file's size, what it was made as (`facts`: width, height, fps, container, codec, ProRes profile, pixel format, 10-bit — as configured) and its MEASURED loudness (`loudness`: integrated LUFS, true peak dBTP, loudness range — metered on the sound the encoder wrote, no ffmpeg needed), with `warnings` (1080p for YouTube, a true peak over −1 dBTP, a visible clip the export's end cut or left out — an end card past the project's length). verify:true (through the MCP server): ONE contact sheet of the exported FILE's own frames — the hook, the middle, every title, the end card, the last half second — read on the person's computer (`verify`): look at it before telling the person the film is done.
delete_assets unused, filenames, dryRun
Delete the project's cloud files: unused:true = every file no clip (any version), no Kit entry and no project data (the shot list's pictures, keyframes, made lines, the cast's pictures) names — the leftovers of redos (cast_edit_*.png, old sm_*.mp4) — or filenames:[…]. A file still in use is kept and said why. dryRun:true lists what would go; otherwise the person is asked once in the studio. Not undoable.
resolve_save_conflict choice
Answer the studio's 'This project was saved elsewhere' dialog (query_project / studio_info say saveConflict) with THE PERSON'S choice — ask them, never choose yourself: 'theirs' opens the save made elsewhere (this window's changes are dropped), 'mine' saves this window's version over it (the studio confirms once more), 'copy' keeps this window's version as a new project. Autosave is paused until it is answered.
update_clips clipIds, patch
The same update_clip patch on MANY clips at once (a caption style on every caption, a level on every shot): clipIds + patch. Each clip answers what applied and, with the reason, what was rejected. Sound fades on a whole track: fade_audio (one call, it can skip clips that already end quietly).
fade_audio trackIndex, clipIds, fadeIn, fadeOut, minLoudEnd, trackId, trackName
The sound fades of MANY clips in one call (one undo step): every sound / video clip of a track (trackName, trackId or trackIndex) or the clips named (clipIds). fadeIn / fadeOut in seconds (0 takes one off; each at most half its clip). A sound that stops while loud — a sound effect cut short, a music cue trimmed to an act's end — clicks or stops dead without an out-fade: e.g. trackName:"SFX", fadeIn:0.05, fadeOut:0.3. minLoudEnd (dBFS, e.g. -50): the out-fade only on clips whose end is louder than that AS HEARD (their level and the track's fader counted) — the rest keep theirs. query_project rows show audioFadeIn / audioFadeOut. Free.
duplicate_project name, open
A COPY of the open project — its timeline, shot list, Kit, versions and its own copy of every cloud file — under `name`, opened in the window (open:false leaves the original open). The original is saved first. For a second language of a film (keep every picture, video, score and sound effect; make only its narrator, spoken lines and texts again) or to try another picture model on the same plan. Answers the copy's projectId, how many files were copied and `failed` (by name — their clips then read missingFile:true in query_project; copy_from_project brings them). A version (create_version) shares the shot list and the Kit; a copy shares nothing. save_project name only RENAMES. Free.
copy_from_project fromProject, files, clips, shots, place
Bring files from ANOTHER of the person's projects into the open one, copied server-side under their own names (no URL guessing; a file of that name and size already here is used as it is): files:[names] (list_assets project:"…" lists them), clips:[ids of that project] (their media files), or shots:[n | { from, to }] — a made shot's video, its start picture and its sound effects, laid on the shot of the same number here (to: another number) and marked done; place:false copies the files only. Its words, spoken line, captions and narrator are never copied (a copy has its own language). Free.
analyze_frame time
The FACES at a moment of the film (`time`, default the playhead) and the bands of the frame free of them — in design px as update_clip x / y take them (from the frame's middle, + = right / down; the frame is 1080 on its short side): faces [{ x, y (its centre), w, h, score }], bands { top, bottom, left, right } each { from, to, size, centre }. Before placing a title or a lesson card over a close-up: put its y at bands.top.centre or bands.bottom.centre — or add_clip text avoidFaces:true, which reads the title's whole span. Free (the face finder runs in the window).
set_workspace mode
The window's View › Workspace — which panels and tabs show: all (every tab), all-columns, music (no Text / FX / Templates tabs), video (NO Audio tab), focus (Clips and the chat only). studio_info.workspace says the one on and what it hides; a control you cannot find may be on a hidden tab. A view of this window (kept in this browser, not the project): no undo step.
list_ai_models kind, search, includeOlder, sort
List the AI models the studio has for one kind of work, as the person's pickers list them: each model's value (what the tools take), its label (what the person says — "LTX-2.5", "Qwen Image 2.1 Turbo"), its group, where it runs (LS1, LS2 … or Own: the person's own ComfyUI), and the person's current pick and the chat's default for that kind. `search` narrows by words of a label; with 15 or fewer rows each says what it takes (words only, a start / end picture, reference pictures, longest seconds, sizes). Use it whenever the person names a model you do not know, or asks which models there are — never say a model cannot be found before looking here. Every model field of the other tools also takes the label as it is. A model marked ownComfyOnly runs only on the person's own ComfyUI (ready:false = none is set up). set_ai_model changes `picked` (the panel's pick) or `chatDefault`. Each row has its price: `price` (as the pickers show it) and `credits` { per: 'second' | 'image' | 'run' …, amount — at its best size } (a model on the person's own ComfyUI: 0, own:true); sort:'price' lists the cheapest first.
cancel_generation wait
STOP what is being made in the background — a shot batch (generate_shots), storyboard pictures, a narration video, Story to Movie, Text to Video or Music to Video — when the person asks to stop, cancel or quit it ("stop the render", "lopeta"), or before remaking it on other models. The same as the Cancel button on the progress card: what is rendering right now finishes and lands (it was sent and paid for), nothing new starts, and the shots never started wait again as pending. Waits up to `wait` seconds for the batch to stop (default 20): `stopped` false = shots are still finishing (`finishing`) — say so and end your turn; the shot list can change once they land. A create_clip_media batch cannot be stopped (each clip's call is sent at once). A credit question still waiting for the person is withdrawn too (`questionsWithdrawn`; nothing it asked for is spent).
comfy_cloud_to_clip jobId, url, clipId, kind, output, duration, prompt
Put a Comfy Cloud job's output on the timeline: on clipId, or a new clip at the playhead (the placement rules). The clip shows Generating with Comfy's progress while the job runs; the output is imported into the project and lands as an AI take (one undo step). Returns at once — end your turn; query_project shows it later (snapshot.comfyCloud jobs / recent). cancel_generation stops it and cancels the Comfy job. jobId: from a comfy_cloud_call generation; or url: an output URL Comfy gave. kind: what the output is (image | video | audio — audio lands as a project file to place with add_clip). output: which output (0 = the first). An outside agent with Comfy's own MCP server: a job it made there lands the same way when the studio window is connected to the same Comfy account (Settings › ComfyUI).
retime_clips clipIds, trackIndex, op, value, trackId, trackName
Retime MANY clips in ONE call ("close the gaps", "shift everything 2 s later", "make each picture 3 s", "trim the first second off these"). op close_gaps packs them from the first one's start (value = the gap to leave, default 0); shift moves them by value seconds (±); set_length makes each value seconds long; trim_start / trim_end take value seconds off each clip's start / end (negative lengthens). A video trimmed at its start keeps its picture in place (its in-point moves with it); a sound clip is cut into the same way — a music cue's head trimmed starts later IN the music (audioOffset moves), not slid. Give clipIds, or trackIndex for every clip on a track.
create_plugin spec, dryRun
Create or update a user-authored plugin and install it into the USER stack. Pass the full .lnplug.json spec object as `spec`. Supports two kinds:
  • kind:'video-shader' — GLSL fragment shader. Uniforms: u_tex (input texture), u_canvasSize (vec2), u_time (float seconds), and u_<paramKey> for each declared param. Output to gl_FragColor.
  • kind:'audio-dsp' — small JS function bodies running inside the AudioWorklet. Provide `audio.setParamsBody` (params object `p` available; store state on `this`) and `audio.processBody` (sample inputs `l`, `r`; return {l, r}). Optional `audio.constructorBody` (with `sr` sample rate) and `audio.getMeterBody` (return {gr, grBands?}). Bodies execute as STRICT-mode function bodies (declare every variable with let/const; keep state on `this`) — no fetch / DOM / globals beyond Math, Float32Array, currentTime, sampleRate.
  • kind:'midi-fx' — a synchronous MIDI event transform extending the MIDI FX chain. Provide `midi.processBody`: the body of a function (events, params, ctx) => events. `events` is an array of MIDI events ({type:'noteon'|'noteoff'|'cc'|'pitchbend', note, velocity (0..1), time (seconds), channel, ...}); return a NEW array (you may add/drop/transform events; clone with {...e} before mutating). `params` holds the declared param values; `ctx` is { bpm, offline }. params support type:'range' (min/max/step/default), 'select' (options:[{value,label}]) and 'toggle'. Pure/synchronous only — no async, fetch, DOM or timers: it runs in an isolated sandbox worker, only noteon/noteoff/cc/pitchbend (value 0..1, centre 0.5)/aftertouch/polyat events come back, and a call slower than 500 ms during playback stops the plugin. Example body: "return events.map(e => e.type==='noteon' ? {...e, velocity: Math.min(1, e.velocity*params.gain)} : e);".
ID must match /^user\.[a-z0-9._-]+$/. Validation + try-compile happens before persistence; on failure the response includes the compile log so you can iterate. Pass dryRun:true to validate without saving.
create_comfy_plugin useAttachedWorkflow, attachmentIndex, apiJson, spec, name, dryRun
Create a user-managed ComfyUI plugin from a ComfyUI workflow and install it. The plugin appears in the matching Media generation dropdown (image→Image, video→Video, audio→Song) as a 'User AI (ComfyUI)' option with an auto-generated parameter form, and runs against the user's configured ComfyUI backend (Cloud / RunPod / local).
Three ways to call:
  • If the user ATTACHED a workflow .json to the message (you'll see an <attached_comfy_workflow> summary with auto-detected params): pass `useAttachedWorkflow:true` (and `attachmentIndex` if several). You do NOT have the raw graph and must not invent it — it is injected automatically. To customize, also pass a `spec` carrying refined `params`/`name`/`comfy.category`/`comfy.output` but OMIT `comfy.workflow` (it is filled from the attachment); keep each param's `bind` exactly as shown in the summary.
  • Or pass `apiJson` = the raw ComfyUI **API-format** workflow (the 'Save (API Format)' export — a flat map of nodeId → {class_type, inputs}). It is auto-analyzed into a draft manifest (prompts, seed/steps/cfg, media inputs, output node, category). Pass `name` to title it. Refine afterward if needed.
  • Full control: pass `spec` = a complete manifest with kind:'comfy-workflow' and a `comfy` block { category:'image'|'video'|'audio', workflow:<API JSON>, output:<saveNodeId|'auto'> } plus `params[]`. Each param has { key, type, label, bind:'<nodeId>.inputs.<field>' }. Param types: text, int, number, range, select (with options:[{value,label}]), toggle, seed, image, audio, video. Only expose inputs a user should control (prompt, seed, steps, cfg, dimensions, media); leave model/VAE wiring fixed. Do NOT accept ComfyUI UI-format exports (they have top-level nodes/links) — require API format.
Pass dryRun:true to validate without saving.
create_drawing_plugin code, name, params, staticDraw, insert, spec, dryRun
Create a procedural 'scripted-drawing' clip: JavaScript that paints a 2D canvas every frame, composited like any other clip (transforms, FX, masks all apply). Use this when the user asks for a coded/generative/animated visual, a custom HUD/overlay/lower-third, a loader/progress/counter, particles, or an audio-reactive visualizer — anything better described by code than by importing media. The clip is installed into the user's library AND dropped onto the timeline immediately (unless insert:false).

Easiest call: pass `code` (the BODY of the draw function) plus optional `name` and `params`.

The draw contract is: draw(ctx, t, p, env)
  • ctx — a Canvas2D context, sized to env.width × env.height, already cleared each frame. Paint a background rect first if you want an opaque clip; leave it for transparency.
  • t — time in SECONDS since the clip start (>= 0). This is your ONLY clock.
  • p — your params object: p.<key> for each declared param. range/seed → number, toggle → boolean, color → [r,g,b] each 0..1, select → the option value.
  • env — { width, height, duration (clip length s), bpm, rng() (0..1, reseeded per clip AND frame: the same frame always gets the same numbers, the next frame new ones), audio:{ level (0..1 loudness), fft (Float32Array of ~32 frequency bands, each 0..1, low→high) } }. env.audio works live AND in export (deterministic), so it's the right way to build music visualizers — but fft may be null when no audio is present, so guard it (e.g. const f = env.audio.fft; const v = f ? f[i] : fallback).

DETERMINISM (critical for export): draw MUST be a pure function of t / p / env. Do NOT call Date.now(), performance.now(), or Math.random(). For randomness use a stable hash of an index (e.g. fract(sin(i*12.9898)*43758.5)) so positions are identical every frame and in export. env.audio may be {level:0, fft:null} when no audio is playing — guard for it.
SANDBOX: the code runs in an isolated worker — Canvas2D (ctx) and plain JS only: no DOM/document/window, no network, no storage, no timers, no images from URLs; text renders with generic fonts only (sans-serif, serif, monospace). A script that runs longer than ~1 s per frame is stopped.

params: array of { key, type, label, ... }. key matches /^[A-Za-z_][A-Za-z0-9_]*$/ and is read as p.key. Types: 'range' (min, max, default, optional step), 'select' (options:[{value,label}], default), 'toggle' (default bool), 'color' (default [r,g,b] 0..1). Declared params become live sliders the user can tweak AND animate with keyframes/LFO, so prefer exposing a few meaningful params over hard-coded constants.

Canvas2D only (no WebGL/DOM/fetch/async/timers). Keep draw fast (it runs every frame). Example call: code = "const {width:W,height:H}=env; ctx.fillStyle='#0b0b12'; ctx.fillRect(0,0,W,H); const n=Math.round(p.count); const bw=W/n; for(let i=0;i<n;i++){const h=(0.2+0.8*(0.5+0.5*Math.sin(t*p.speed+i*0.4)))*H; ctx.fillStyle='hsl('+((i/n)*300)+',80%,55%)'; ctx.fillRect(i*bw, H-h, bw*0.85, h);}", na
create_expr_plugin code, name, targetClipId, blendMode, params, insert, dryRun
Create an 'expression' (controller) clip: JavaScript that runs every frame and RETURNS a map of { property: value } which drives ANOTHER clip's animatable properties — the code-driven sibling of an LFO clip. Use this for motion/behaviour that's better expressed as a formula than as keyframes: continuous spin, audio-reactive scale/shake (pumps to the music), procedural 3D-camera moves (orbit / dolly-zoom / handheld shake), 'follow with lag', or any math relationship between properties. The clip is dropped on the timeline and bound to a target clip (unless insert:false).

Easiest call: pass `code` (the BODY of the function, ending in `return { ... }`), a `targetClipId` (the clip to drive — call query_project first to get clip ids; to drive the 3D camera, target the camera3d track's clip), plus optional `name`, `params`, `blendMode`.

The contract is: expr(t, p, env) → { [property]: number }
  • t — SECONDS since the clip start (>= 0). Your only clock.
  • p — your params: p.<key> for each declared param.
  • env — { time (global s), width, height, duration, bpm, beat (bpm-derived phase), rng() (0..1, reseeded per clip AND frame: reproducible, new numbers each frame), audio:{ level (0..1 loudness), fft (Float32Array ~32 bands 0..1, low→high) } }. env.audio works live AND in export (deterministic); fft may be null when no audio plays, so guard it.
  • RETURN an object whose keys are animatable property names and values are numbers. Valid keys: bare transform (fxX, fxY, fxScaleX, fxScaleY, fxRotate, fxRotateX, fxRotateY, fxOpacity, worldX, worldY, worldZ), 3D CAMERA (camX, camY, camZ, camRotateX, camRotateY, camRotateZ, camFov, camPerspective) — only effective when the target is the camera3d clip — or 'clipProp:<id>' for a compound/script clip's named param. Unknown/non-number values are ignored.

DETERMINISM (critical for export): expr MUST be a pure function of t / p / env. Do NOT call Date.now(), performance.now(), or Math.random(). For 'random'/shake use stable layered sines of t (e.g. Math.sin(t*61.7)*0.6 + Math.sin(t*113.1)*0.4) or env.rng(). The code runs in an isolated worker: plain JS only — no DOM, network, storage or timers. Unknown keys and non-numbers are dropped.

blendMode (default 'replace'): 'replace' sets the value, 'add' adds on top of the target's base/other animation (use for camera shake layered over an orbit), 'multiply' scales it.

params: array of { key, type:'range'|'select'|'toggle'|'color', label, min, max, default }. key matches /^[A-Za-z_][A-Za-z0-9_]*$/ and is read as p.key; declared params become live sliders the user can tweak and animate. Example: code = "return { camX: Math.sin(t*2*Math.PI*p.rate)*p.radius, camZ: Math.cos(t*2*Math.PI*p.rate)*p.radius, camRotateY: -t*p.rate*360 };", name = "Camera Orbit", targetClipId = "<camera3d clip id>", params = [{key:'radius',type:'range',label:'Radius',min:0,max:1200,default:400},{key:'rate',type:'range',label:'Rate',min:0.01,max:1,default:0.1}].
A parse/validate check runs bef
set_camera camX, camY, camZ, camRotateX, camRotateY, camRotateZ, camFov, camPerspective, camScaleX, camScaleY, camScaleZ
Set the 3D camera's base pose. Auto-creates a 3D Camera track (and its clip) if the project doesn't have one yet, so this is the one-call way to position the shared 3D camera that all 3D clips render through. Pass any subset of the pose fields; omitted fields are left unchanged. Coordinates are world units; angles are degrees; camFov is the field of view in degrees (lower = more zoomed/telephoto, higher = wider).
This sets the STATIC base pose. To ANIMATE the camera, either call add_keyframe with the returned cameraClipId and a cam* prop (e.g. prop:'camRotateY') at several times, or call create_expr_plugin targeting the camera clip (e.g. a Camera Orbit). Call query_project to read the current camera pose (the `camera` field).
add_vector shape, points, mode, trackIndex, start, duration, name, fill, stroke, strokeWidth, closed, box, feather, opacity, trackId, trackName
Add a vector (shape) clip — a resolution-independent 2D shape drawn on the canvas, composited like any other clip (transforms, FX, animation, and the expression/LFO modulators all apply). Use this when the user wants a shape, outline, geometric graphic, callout, or a custom mask. Provide EITHER a primitive `shape` name OR an explicit `points` array of normalized {x,y} (each 0..1, where 0,0 is top-left and 1,1 is bottom-right of the canvas). Set mode:'mask' to make it a mask shape (a clip's own mask is attach_mask) instead of a visible shape. Returns the new clipId; you can then animate it with add_keyframe or create_expr_plugin.
update_vector clipId, shape, points, mode, fill, stroke, strokeWidth, feather, closed, opacity
Edit an existing vector (shape) clip — replace its geometry (a new primitive `shape` or explicit `points`) and/or its style (fill, stroke, strokeWidth, closed, mode, opacity). Only the fields you pass change. Get the clipId from query_project (type:'vector').
search_music query, count
Search Jamendo for COMMERCIAL-SAFE Creative Commons background-music tracks (NonCommercial-licensed tracks are excluded server-side). Use when the user wants music for their video. Returns title, artist, duration, license and an audioUrl per result. Show the user a few options and let them pick, then call add_background_music with the chosen track's audioUrl. Only auto-add the first result if the user said something like 'just add some music'. Add the word 'instrumental' to the query when the video has narration so vocals don't clash.
add_background_music audioUrl, name, artist, licenseName, durationSeconds, start, volume, trackName
Add a background-music clip to a dedicated 'Music' track (created if missing). Pass the chosen track's audioUrl from search_music, plus its name/artist/licenseName/durationSeconds so the clip is labelled and sized to the track length. The audio is imported into the project. Volume defaults to 0.5 — pass ~0.3 if it should sit quietly under narration. After adding, remind the user to credit the artist (e.g. 'Title by Artist — CC BY') unless the license is CC0.
add_chord name, root, chordType, section, start, duration
Lay a chord or a song section onto the project's chord track (auto-created if absent). The chord track has two sub-lanes: the bottom lane holds chords (root + type), the top 'arrangement' lane holds song sections (Intro/Verse/Chorus…). The chord track drives MIDI chord-follow, the audio arranger, and music-generation prompts. For a CHORD: pass `name` (e.g. 'Cmaj7', 'Am', 'G/B') or a `root` pitch class (C=0…B=11) with optional `chordType`. For a SECTION: pass `section` (e.g. 'Verse 1', 'Chorus', or any custom label). To lay a whole PROGRESSION, prefer add_chord_progression (one call, bar-based timing) instead of many add_chord calls. The chord's `duration` is honored — if it runs past the project end the project GROWS to fit (chords are never compressed).
add_chord_progression chords, start, bpm, beatsPerChord, durationPerChord, loop, section, replace
Lay a whole chord progression onto the chord track in ONE call, with musical bar-based timing — the easy way to build harmony (use this instead of many add_chord calls). Chords play back-to-back; each lasts `beatsPerChord` beats at the project tempo. The project length GROWS to fit so nothing is ever compressed/clamped. The chord track drives MIDI chord-follow, the audio arranger, and generate_accompaniment's chord-follow mode. Example: chords:['G','D','Em','C'] in G major → four bars of G–D–Em–C. Set `loop:true` to repeat the progression across the whole song, and `section` to also mark an arrangement section (e.g. 'Verse 1') spanning it.
generate_music prompt, purpose, model, lyrics, instrumental, duration, trim, followChordTrack, target, start, trackIndex, clipId, trackId, trackName
Generate a full AI music track from a style & mood prompt (and optional lyrics), then place it as a new audio clip on a Music track at the playhead by default (`start`, `trackIndex`, `clipId` say otherwise). Long-running — the model is queued and may take 1–3 minutes. The result carries the clip's `seconds`; a SONG model chooses its own length (MiniMax Music 3: 16–40 s for 60 asked — a `warning` says so): for an exact length use purpose 'background' (Sonilo). purpose 'song' (default) = a song with vocals (MiniMax Music 3.0 writes the lyrics when you omit them); purpose 'background' = instrumental background music at EXACTLY `duration` seconds (Sonilo, up to 360 s, trained on licensed music). Set `followChordTrack: true` to compile the project's chord track into the prompt (key/tempo + time-stamped sections & chords). For an instrumental, set `instrumental: true` and omit lyrics.
set_project_settings aspectRatio, resolution, fps, length, title, letterbox
Set project-wide canvas and timeline settings. Every field is optional — only the supplied ones change. Use to configure aspect ratio, resolution, frame rate, length and/or title at the start of an AI-driven project. A length that cuts a visible clip (an end card that runs past it) answers `warnings` — fix them before exporting.
list_versions
List the project's VERSIONS — several timelines of one project that share its media (e.g. a 16:9 main video, a 9:16 short, a 1:1 square post, a 30-second teaser). Returns id, name, shape, length and which one is active. Every other tool works on the ACTIVE version only.
create_version name, aspectRatio, start, end
Make a NEW VERSION of the project from the active one and open it (the original stays as it is): a copy of its timeline, optionally in another frame shape (things keep their place in the new frame) and/or cut to [start, end] seconds (a shorter cut, moved to start at 0). Use for 'also make a vertical / TikTok version', 'a square one for Instagram', 'a 15-second teaser of this'. To change the CURRENT video's shape instead, use set_project_settings.
switch_version version
Open another version of the project (by id or name from list_versions). Later edits change that version.
export_all_versions
Export EVERY version of the project, one file each in its own frame, with the export panel's settings. Long-running: end your turn after starting it. Use only when the project has two versions or more.
list_scenes
List the video's SCENES — a longer video made in parts that play one after another (compound clips on the Scenes track, each as long as its content). Returns each scene's number, name, start / end in the whole video, which one is OPEN, and YouTube chapter lines. While a scene is open every other tool works INSIDE it (its own tracks, times from the scene's start); with none open ("all") tools work on the whole video, where the tracks above the Scenes track play over all scenes (music, narration) and the ones under it are a background shown behind every scene.
make_scenes overAll, under
Turn the timeline into Scene 1 so the video can be built in scenes (once per project; it looks and sounds the same). Tracks listed in overAll keep playing over all scenes (a song, narration, a logo); by default the music and long narration do. Tracks listed in under become a background under all scenes (shown wherever a scene draws nothing). Then add_scene / open_scene.
add_scene name, after, open
Add a new, empty scene and open it (by default after the scene the playhead is in). Then add clips to it as usual — they go inside the scene.
open_scene scene
Open a scene to edit what is in it (scene number, name or id), or "all" for the whole video (to edit what plays over all scenes). The playhead keeps its moment of the video.
edit_scene scene, action, name, to, at
Change a scene: rename it, duplicate it, move it to another place in the order, split it in two at a time inside it, or delete it (with everything in it).
export_scenes scene
Export each scene as its own video file (or only one scene), with the export panel's settings and one sound mix of the whole video. Long-running: end your turn after starting it.
get_prompts clipId
Read the AI prompt words of the project. The words an AI picture or video gets come in three levels, sent together in this order: the GLOBAL ones (the look / motion of the whole video), its SCENE's (in a video with scenes), then the clip's own (prompt = picture, videoPrompt = video). Also the words the Clip box holds with no clip selected (newClip: the next clip made at the playhead gets them). With clipId: that clip's own words, its scene number and exactly what an AI picture / video of it would send — for a spoken line (a speech clip): `speech` { text, voice, language, model } (generate_speech replace makes it again) — and `made`, what made what the clip shows now, for any AI-made clip (a picture, a storyboard picture, a shot's video, a song, a sound effect, captions …): { kind, model, prompt, sent, settings, inputs, from, by, at } — the words and model to make it again with.
set_prompt level, kind, text, scene, clipId
Set the AI prompt words of one level: global (every clip — put the overall style / look / camera feel here, ONCE, not in every clip), scene (every clip in one scene — its place, time of day, mood), clip (one clip's own subject / action) or new-clip (the next clip made at the playhead). kind image = picture words, video = motion words. Keep each level to what is special at that level: a clip's words should not repeat its scene's or the global words.
add_midi_notes clipId, replace, notes
Add notes to a MIDI clip (type 'midi') OR directly to a SYNTH clip (the notes are auto-wired to the synth via its attached MIDI clip, so it plays them). Note times are CLIP-LOCAL seconds (0 = the clip's start). Pitches accept a MIDI number (0-127) or a name like 'C4', 'F#3', 'Bb5' (C4 = middle C = 60). Velocity is 0..1. Use this to author melodies, basslines, chords (stack notes with the same start), or drum patterns. Set replace:true to overwrite the clip's existing notes rather than append.
get_midi_notes clipId, select, limit, offset
Read the notes of a MIDI clip (or a synth clip's routed notes) with array indices and a summary — inspect a part BEFORE editing it with transform_midi_notes. `select` narrows by pitch range, time window, channel or velocity. Returned indices are positions at read time and INVALIDATE after any edit — prefer criteria-based selection in transform_midi_notes, and re-read after editing.
transform_midi_notes clipId, select, op, params
Edit EXISTING notes in a MIDI clip (or a synth clip's routed notes): select notes by criteria, then apply one operation. This is how you transpose, move, stretch, re-velocity, quantize, humanize, make legato, reverse or delete part of a performance without rewriting it. Ops and their params: transpose {semitones} · move {deltaSeconds | alignToStart} · resize {scale | setDuration | deltaEnd} · set_velocity {value | scale | rampFrom+rampTo} · set_channel {channel} · quantize {gridBeats (0.25 = 1/16 at 4/4), strength 0-1, swing 0-1} · humanize {timingMs, velocityAmt} · legato {} · reverse {} · delete {}. Times are clip-local seconds. Call get_midi_notes first when unsure what the clip contains.
set_midi_fx clipId, action, fxType, index, toIndex, params, enabled
Inspect and edit a MIDI clip's MIDI-FX chain (non-destructive note processors that run on playback and export). Built-in types: transpose, quantize, velocity, chord, chord-follow, scale-filter, arpeggiator, channel-router, delay (echo), humanize, cc-map, note-length (gate/legato), auto-lfo (LFO→CC, export-only), probability, mirror (invert/retrograde), note-to-cc, micro-tune. Start with action:'list' to see the current chain and pass fxType to get that FX's exact param schema before adding/updating.
create_instrument_part name, sound, gmProgram, isDrums, category, start, duration, trackName, notes
One call to add a playable synth instrument: creates a synth track + synth clip, applies a sound, wires up a routed MIDI clip, and (optionally) writes an initial melody. Use this to quickly lay down an instrument the user can hear — e.g. 'add a warm pad playing Cmaj7' or 'add a bass line'. Give the sound via `sound` (a preset name — call list_synth_presets for the catalog) OR `gmProgram` (a General-MIDI program 0-127; set isDrums for a kit). An unknown `sound` name never fails the call: the closest sound of the same family is applied and reported in `soundNote`, so keep building and only fix it if the note says something you did not want. Then optionally `notes` (clip-local seconds, same format as add_midi_notes). Returns the synth clip id so you can keep editing it with edit_synth_params / add_midi_notes / apply_synth_preset.
create_compound clipIds, trackIndex, start, name, trackId, trackName
Group clips into a nested compound clip (like a Flash movie clip / CapCut compound), OR create an empty one. GROUP: pass `clipIds` (2+ clips on the SAME track) — they move into the compound's inner timeline (re-based to local time) and are replaced on the outer track by the single compound. CREATE EMPTY: omit `clipIds` — an empty 5s compound is made at `start` (default playhead) on the active or `trackIndex` track. Compounds can then be entered/edited in the UI and get their own FX stack.
generate_accompaniment style, complexity, key, tempo, structure, progression, mode, fillToSeconds, matchProject
Generate a simple GM-voiced backing arrangement (intro / verse / chorus / outro) as one self-contained compound clip — drums / bass / keys (+ lead), picked per style. Use this when the user wants a quick backing track, instrumental bed, or accompaniment in a given style/key/tempo. If a chord track already exists, the backing automatically EXTENDS to span it (so it doesn't stop partway) — and you should set mode:'chord-follow' so the grooves actually follow the user's chords/sections across the whole song (literal mode bakes its OWN progression and may not match). With no chord track, 'literal' (default) writes the real chord notes and plays a complete song on its own. Use `complexity` to dial how human/band-like it sounds. The user can double-click the compound to edit individual channels.
export_project type, preset, resolution, format, quality, scale, maxBytes, youtube, bitDepth, proresProfile
Start exporting the project, reusing the export panel's current settings (scope, transparency, format/codec). Long-running and fire-and-forget — the editor shows progress; this returns as soon as the export begins (with the file's name pattern). export_status then says whether it is still running, and the file's exact name and where it landed when done (a download goes to the person's Downloads folder). Confirm with the user before exporting if the intent is ambiguous. `type` sets the output kind (the panel's container and codec follow it): 'video' (WebM / VP9), 'mp4', 'mp4-hevc', 'mp4-av1' (smallest files, software-encoded), 'mov', 'mov-hevc', 'mov-prores', 'audio', or 'image' (the frame at the playhead — made at once and answered done with its pixel size and bytes: at the project's size unless resolution / scale say otherwise, png unless `format`; a YouTube thumbnail = format 'jpeg', resolution '1080', maxBytes 2000000). Omit to use whatever the panel is set to. A video export always covers the whole project. resolution (the short side), bitDepth and proresProfile set the panel the same way; preset 'youtube' = a 10-bit VP9 WebM at 1440p (a 1080p upload opens at 240p on YouTube's Auto; a 10-bit render keeps dark gradients smooth — a type given beside it wins), 'master' = ProRes 422 HQ 10-bit, 'web' = MP4 1080p 8-bit. 10-bit reaches VP9 (video), ProRes (mov-prores) and HEVC (mp4-hevc / mov-hevc) where the LimoMatte Mac helper runs (VideoToolbox); H.264 is 8-bit, and so is HEVC / AV1 without an encoder for it (`warnings` says so). The answer has what was applied.
set_color_palette colors, replace
Set the project's Kit color palette (up to 12 colors). These are referenceable in ANY AI generation prompt as [color1]…[colorN], so a coherent palette steers every downstream image/video generation toward a consistent look. Use when the user describes a mood/brand/scheme ("make it warm and autumnal", "use our brand blue and white").
find_replace_text find, replace, caseSensitive, type, dryRun
Batch find-and-replace text across all text and caption clips (recursing into compound clips). Use for "fix the spelling of … everywhere", "change every 'colour' to 'color'", "replace the old product name in the captions". Set dryRun:true to count matches without changing anything; replace:'' deletes the matched text.
set_light clipId, color, props
Set properties on a 3D light clip (type 'light'): type, position, color, intensity, radius, softness, spotlight cone, shadows, etc. Use for "make the light warmer", "move the light to the top-left", "turn on shadows", "make it a spotlight". To ANIMATE a light over time, use add_keyframe on its light properties instead.
apply_synth_preset clipId, preset, category
Load a sound into a synth clip (overwrites its patch), resolving the name across the BUILT-IN INSTRUMENT CATALOG (pianos, organs, bowed strings, mallets, guitars, winds & brass, drums, SFX, and VA/FM synth presets — e.g. 'Rhodes E.Piano', 'Concert Grand', 'Supersaw', 'TB-303'), plus project-saved and cloud presets (imported Virus/Vital/SF2 sounds the user saved). Call list_synth_presets first if unsure. A name that is not in any catalog resolves to the CLOSEST sound of the same family (or a General MIDI voice) and comes back with a `note` saying what was applied — it never fails, so a long build keeps going. Use for "make this a Rhodes", "load the supersaw", "turn it into an organ", "use my saved bass".
list_synth_presets
List every synth preset that can be applied with apply_synth_preset: the BUILT-IN instrument catalog (grouped by category — pianos, organs, strings, mallets, guitars, winds, drums, SFX, VA/FM synths), plus this project's saved presets and the user's cloud presets (imported sounds they saved). Call this before applying when the user asks for a specific instrument or a saved sound by name.
get_synth_sound clipId
Read a synth clip's current sound as a compact JSON snapshot — its operators (waveform/level/tuning), filters, LFOs, ADSR envelopes, macros and master levels — plus the list of editable parameter paths. Call this before edit_synth_params so you tweak the RIGHT parameters ("make it brighter", "more attack", "detune the second oscillator"). Targets the given clipId, else the open/first synth clip.
edit_synth_params clipId, edits, patch
Surgically change a synth clip's sound. Pass `edits` as [{path, value}] using the path grammar from get_synth_sound: op:<i>:<amplitude|pan|coarseTune|fineTune|pulseWidth|shape|unisonDetune|unisonMix|unisonSpread|waveform|modType|unisonCount|supersawMode|phaseMode>, filter:<i>:<cutoff|resonance>, lfo:<i>:<rate|depth>, adsr:<i>:<attackTime|decayTime|sustainLevel|releaseTime>, master:<gain|oscGain>, macro:<i>:value. supersawMode=true on a SAW op with unisonCount 7 = authentic JP-8000 Super Saw (also set phaseMode "random"). Continuous op/master tweaks apply live without cutting the note; waveform/filter/adsr/lfo/macro changes rebuild the voice. For bigger structural changes you may also pass a partial `patch` object that is deep-merged over the sound. ALWAYS read get_synth_sound first to use valid indices and current values. Use for "make it brighter" (raise filter cutoff), "softer attack", "quieter", "detune osc 2".
set_expression clipId, enabled, depths, addSlot, removeSlot
Inspect/adjust a synth clip's EXPRESSION MAP — the smart MIDI-keyboard defaults that make the sound expressive: on a B3 the mod wheel drives the Leslie rotor speed (and no pitch vibrato), on a cello it deepens the modeled bow vibrato, on an e-piano the tremolo, on a synth lead it opens the filter; on winds velocity sets the breath. get_synth_sound reports the current map (expression.slots with ids). Use `enabled` to toggle the whole map, `depths` {slotId: 0..2} to rescale a mapping ('make the mod-wheel vibrato subtler' → 0.5), `addSlot` to map a source (velocity|modwheel|aftertouch|pressure|slide|ccA|ccB) to any Mod-Matrix path (filter:0:cutoff, voice:0:pitch, op:0:windBreath, lfo:0:depth…), `removeSlot` to delete one. Changes persist on the clip and apply live.
save_synth_preset name, clipId, scope, type
Save a synth clip's current sound as a reusable preset — to this project (default) or the user's cloud library (available across projects). Pair with design_synth or match_sound to keep a sound the user likes ("save this as 'Night Pad'").
add_audio_fx clipId, type, params, enabled
Add an audio effect to a clip's audio FX chain (feeds the per-clip mastering rack). Use for "add reverb to this clip", "EQ out the boominess", "compress the vocal", "add a gentle delay". Pass `params` to set the effect's controls; omit them for sensible defaults.
cut_to_angle angle, time
Multicam: cut the program output to content-track angle N (1-based, top to bottom) at a time, on the control track (auto-created). Use for "cut to camera 2 at 5 seconds", "switch to the wide shot here". Call it once per cut to build a switching sequence.
generate_captions clipId, provider
Transcribe a clip's audio into a new caption track (speech-to-text). Use for "caption this", "transcribe the voiceover", "add subtitles from the audio". Long-running — the provider is queued and bills credits. The clip must have audio (an audio clip, or a video with sound).
auto_mix scope, trackIndex, clipId, target, targetLufs, measure, measureStart, measureEnd, trackId, trackName
AI loudness-balance: analyzes audio and nudges clip/track/master volumes toward a LUFS target (the 'Balance Volumes' engine), then applies the safe adjustments. Use for "balance the levels", "make the music and voice sit right", "even out the volumes". Scope 'all' balances the whole mix; 'track' / 'clip' target one (pass trackIndex / clipId). Pick a `target` preset or an explicit `targetLufs`.
auto_master profile, amount, preset, targetLufs, curve, loudness, iterate, measure, measureStart, measureEnd
AI mastering (Master Mix): masters the final mix for a delivery PROFILE with the planner of the Master page and the LimoMaster plugin — corrective EQ, glue compression and a true-peak Maximizer (or Limiter), then a check render that corrects the level once. It replaces the mastering devices of the master chain (other effects there are kept in front) and un-bypasses it. Use for "master the track", "make it loud and polished for Spotify", "radio-ready master". Long-running (offline renders). Only pass what the user asked for — absent args keep the Master Mix panel's settings (default profile: Streaming — loud, -10 LUFS). `profile` picks the intent; `preset`, `curve` and `loudness` override the profile's target, tone and push.
auto_mix_project clipBaseline, trackFx, detectStems, replaceChain, reverb, reverbAmount, trackTargets, master, masterProfile, masterPreset, masterCurve, masterTargetLufs, leadTracks, backgroundTracks, measure, measureStart, measureEnd
AI mix the WHOLE project in one call (the full chain). Use for "mix my project", "auto-mix everything", "make the whole song sound balanced and finished", "do a full AI mix and master". Runs, in order: (1) normalize every clip to a common LUFS floor, (2) install + tune per-track stem FX (vocal/bass/drums/etc. — uses each track's profile or auto-detects), (3) optionally add a shared vocal reverb send bus, (4) gain-stage track faders to role targets, (5) master. Long-running (renders each track offline). Defaults are smart; only pass args the user explicitly asked for. For a quick level pass without FX/mastering use auto_mix; to only master use auto_master.
import_asset_from_url url
Import a remote media file (image, video, audio, or 3D .glb) from a public URL straight into the project's cloud assets. Streams server-side (no CSP issues) and charges upload credits like a normal upload. Returns the stored `filename` — pass it to add_clip(url:…) / add_background_music. Use for "add this image: https://…", "import that video from the link".
list_assets type, source, project, shot, latest, limit
List the project's media files — its cloud files and, when a folder is linked, the folder's (images, video, audio, and 3D .glb models) so you can reference real files by name. Returns each asset's `url` — pass it as given to add_clip / add_background_music ('local:<name>' for a folder file) — and `where` (cloud / local), its `filename`, its `type`, and `inUse` (whether it's already on the timeline). Use this BEFORE add_clip when the user says "add my logo", "use that video I uploaded", "put the 3D model on screen", etc. — find the matching filename instead of guessing. Filter by `type` to narrow results.
director_auto_cut syncMode, videoType, cutStyle, cutProfile, minClipLength, maxClipLength
Re-cut the active track's timeline into clips with the AI Director's cuts (REPLACES every clip on the active track; new clips keep the old text at their middle, no prompts). 'captions' syncs cuts to caption/text-clip timings and 'beats' syncs to the audio beat grid — both are DETERMINISTIC (no AI call, no credits). 'ai' asks the model for a rhythmic cut plan (queued, bills credits). Not at All of a project with scenes (open a scene). Needs the project to already have media/duration; for 'captions' it needs caption or text clips, for 'beats' a project BPM or audio track. Good for "auto-cut this to the beat" or "chop the slideshow into even scenes".
write_clip_prompts kind, style, videoType, focus, wishes, clipIds
Write the AI words of MANY clips at once — every clip on the active track (at All of a project with scenes: every scene's clips and each scene's words), or the clipIds given — from a style, the clips' own text / lyrics and the video's type, in ONE model call (bills a small chat charge). kind 'image' writes each clip's picture words (and the global words when there are none); 'video' writes each clip's motion words from its picture words. Replaces those clips' words. For ONE clip use set_prompt. Then create_clip_media makes their pictures or videos.
create_clip_media kind, clipIds, model, dryRun
Make the pictures (kind 'image', the person's AI Img model) or the videos (kind 'video', the AI Vid model; each from its clip's picture) of MANY clips at once — every clip on the active track that takes AI words (at All of a project with scenes: every scene's), or the clipIds given — from their words. Asks the person ONCE with the count and about the total (bills credits per clip); dryRun gives the price without asking. Returns at once: they are made in the background, so end your turn. Caption, text and empty clips become picture clips. Write the words first (write_clip_prompts) — a clip without any is made generic. One clip: generate_image / generate_clip_video.
generate_clip_video clipId, prompt, model, references, resolution, keepSpeed, turnaround
Generate an AI video for an existing clip (image-to-video from the clip's image, or prompt-only for text-to-video models). The prompt may contain '---' on its own line to split it into a MULTI-SHOT STORYBOARD — Kling O3 models render up to 6 shots as ONE consistent scene (same characters, lighting, set across the cuts). Name Kit characters with @Name in the prompt: their pictures, views, voice and turnaround go with the run (as the model takes them). Slow (queued, 1–5 min) and bills credits — tell the user before long runs. Several calls on DIFFERENT clips may be sent together: they run at once (each priced and kept to the spending guard on its own). A run that times out or fails answers ok:false (code 'timeout' says a late result may still land) — never the clip's old file.
edit_video_clip clipId, instruction, model, tier, references, keyframes, resolution
Re-render an existing VIDEO clip per a natural-language instruction with temporal consistency: "make it snow", "turn the jacket red", "remove the people in the background". The whole clip is re-rendered and swapped in place. model: kling4 = Kling 4.0 Edit (default; 3–30 s, keeps the sound), omni = Gemini Omni 1.2 Edit (the budget edit, 3–10 s, words only, keeps the sound), seedance25 / seedance25-turbo (Seedance 2.5, 2–15 s), seedance-mini / seedance-mini-turbo (Seedance 2.0 Mini: the cheapest Seedance, 4–15 s), wan3 / wan3-prime (Wan 3.0 / Prime, 2–15 s), kling-o3-std / kling-o3-pro (3–10 s), kling-o3-4k (native 4K, 3–10 s), kling-o1-fast (6–20 s), aleph2 = Runway Aleph 2 (2–30 s sources under 16 MB; its `references` are KEYFRAMES, each the WHOLE frame as it should look at a moment given in `keyframes` — never a bare poster or logo, which would fill the frame. To put a given picture INTO moving footage (a poster on a wall, a product in a hand): first edit_image the video clip (its first frame, place asset) with the picture as a reference, then aleph2 with that edited frame and keyframes ["first"]. Keeps the clip's own sound, returns 1080p; also the pick for a multi-shot clip that must stay consistent; dearer: 370 credits a second). Slow (queued, ~2–5 min) and bills credits.
look_at what, clipId, filename, time, size, compare
SEE a picture: the preview as it is now (what), a clip's picture or a frame of its video (clip), or a project file (file) — a small picture comes back for you to look at. Use it to check a result you made or edited before saying it is done, when the person asks what something looks like, or to describe a file or clip they name. Free (no credits) but each look adds to the message's size: look once, not at every step; at most 3 in one round.
get_start_picture shot, clipId, maxSide
LOOK at the picture a shot's NEXT video starts from — its clip's start picture (one edit_image place:'replace' made), else its storyboard picture — as one picture, with `source` ('edited', 'storyboard', 'storyboard (out of date)' …). Free; no clip is laid. Use it after edit_image on a shot's clip, before generate_shots shots:[n].
edit_image clipId, filename, picture, instruction, model, references, place, resolution, quality
Edit an existing PICTURE by words with an AI image-edit model — "make it night", "remove the sign", "turn her coat red", "put @Anna in this scene", "make it look like @poster". The picture: an image clip (clipId), a video clip's START picture (clipId of a video clip — its next AI video starts from the edit; the footage itself is edit_video_clip's; on a shot's clip the shot list keeps the edited picture — storyboard 'edited' — and generate_shots shots:[n] makes the new video from it, update_shots videoPrompt changes only the video's words; get_start_picture shows it), a project file (filename), or a picture attached to this chat (picture: its number). The edited picture is always Image 1; `references` add more (faces, objects, a style) — name them in the instruction by their @Name, never [imageN]. place: replace (default with clipId — the clip shows the edit, its picture before stays in its takes: Use again / undo bring it back), new-clip (a picture clip at the playhead), asset (the file only, its name returned). Bills credits: about 27 on the default Seedream 5.0 Flash Edit; Nano Banana Pro, GPT Image and 2K / 4K cost more. One edit per call — several changes go in one instruction.
extend_video_clip clipId, prompt, model, seconds, replace, resolution
Continue an existing VIDEO clip from its last frame with the same characters and scene (video-extend, native audio). The continuation is inserted as a NEW clip right after the source; only the new seconds are billed. Slow (queued) and bills credits.
upscale_video_clip clipId, model
Make an existing VIDEO clip sharper and bigger with an AI upscaler (Runway Upscale V1: up to 4K — cleaner edges, fewer compression marks; the picture, length and sound stay the same). No words: the clip alone goes, and the result is swapped in place (the clip before stays in its takes). 3–60 s clips. Slow (queued, a few minutes) and bills credits: 22 a second of the clip.
motion_transfer clipId, drivingVideo, prompt, tier
Transfer the motion of a driving/performance video onto a still character image (Kling motion control): real dance moves, drumming, gestures applied to the clip's image while keeping its scene. Needs an IMAGE clip and a driving video filename from the project assets — call list_assets to find it. Slow (queued) and bills credits.
generate_character_views views, redo, character, sheet, turnaround, videoModel, seconds, fromTurnaround, editModel, quality
AI-generate extra reference views (full body front, back, side profile, three-quarter) for a Kit character from its main image — fills the empty reference slots (only the angles it lacks) and keeps its look noticeably steadier. ~60 credits per view; sheet:true instead makes ONE character sheet (four full-body views in one picture, ~140 credits, one consistent look) and cuts it into the views. turnaround:'body' | 'head' | 'both' makes a TURNAROUND VIDEO instead (image-to-video from its picture, the same picture as the last frame: it turns once on a grey backdrop, ~500 credits for 6 s on Kling O3 Std) — a 3D look that goes beside the pictures to the video models that take reference videos; fromTurnaround:true cuts free views (front, back, side, three-quarter) from its turnaround for every other model.
set_character_voice character, voice, clip, likeness
Give a Kit character THE voice they speak with in every clip (kept the same from video to video): a voice that speaks any language — Finnish too — by name (Alice, Sarah, Lily, Matilda, Jessica (women), George, Brian, Daniel, Eric, Chris (men)); a Kling preset ('UK Gentleman', 'Chatty Female', 'Grandma', 'Cute Toddler' … — Kling's videos speak with it, other lines are cloned from its sample, any language); or their OWN voice from a sound in the project (`clip`: 5–30 s of one person speaking, cloned with every line). Free; the Director then makes their lines with it, fitted onto the video model's speech (or the lips follow it).
design_synth clipId, name, operators, amp, filter, filters, filterRouting, lfo, lfos, modMatrix, macros, arp, sub, analog, glide, polyphony, gain
Design a synthesizer SOUND and apply it to a synth clip (the patch — oscillators, FM, unison, filters, envelope, LFOs, a mod matrix, macros, sub, arp). Targets `clipId` if given, else the synth clip open in the editor, else the first synth clip; create one first with add_track type:'synth' or add_clip type:'synth'. Think in musical terms. Key tools: UNISON (`unison`/`detune`/`spread` per op) for fat supersaw/Reese leads & wide pads — THE EDM sound; an additive `harmonics` array for custom spectra; up to 4 `filters` (series/parallel); up to 4 `lfos` each with multiple `targets`; a `modMatrix` routing velocity/macro/env/keytrack/modwheel/aftertouch to cutoff/pitch/pan/etc. (the source of movement & playability); 4 assignable `macros`. For FM, mark an operator role:'fm' and point it at another with `target`+`amount`. Replaces the sound but keeps the clip's notes. For reverb/delay/chorus use add_audio_fx on the clip after. Examples: supersaw lead = one saw op with supersaw:true (authentic JP-8000 7-voice mode), detune ~0.35, spread 0.85 + lowpass + a little reverb; Reese bass = two detuned saws (unison:4, detune ~0.15-0.2) → lowpass with an LFO on cutoff; lush pad = saws with unison 3-5, detune 0.10-0.22, slow amp attack + an env2→cutoff sweep in modMatrix.
match_sound sourceClipId, clipId
Make a synth clip SOUND LIKE an existing audio clip. Analyzes the source audio's timbre and evolves a synth patch (oscillators + filter + amp envelope) that approximates it, then writes it into the target synth clip — the app's own "reverse-engineer this sound" matcher. Use when the user says things like "make a synth that sounds like this sample", "recreate this sound", or "match that bass". Takes ~10-15 seconds. `sourceClipId` is the audio clip to imitate; `clipId` is the synth clip to write into (omit to use the open/first synth clip — create one with add_track type:'synth' first). Keeps the synth clip's notes. It's an approximation (subtractive/FM), best for leads/basses/pads; for an exact recording use the audio clip itself.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Install facts

LicenseMIT
Needsnode >=20
Sourcenot stated
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-e/jrNffxSwm/rRA3wulxVMOvW0YacH+RojhEnWDsMOdCcyrQYR0cYLFoN1slHoQAgqRs82uHtmBlz4RWasfpNQ==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/limostudio-mcp.svg)](https://bragproof.smaverk.com/r/limostudio-mcp)

New version out? Ask for a fresh report.