Clueso

Reviewed Jan 1, 2000.

• tools: 49 tools scanned
• metadata: scanned

No findings.

Tools (49)

• get_design_guide

  Clueso's house style for composing video clips — how to think about concept, typography, color, composition, motion, and pacing. Read it before composing or editing a clip's visuals when you're NOT following a clueprint, or to fill gaps a clueprint leaves silent. General craft, not clueprint-specific.

• create_project

  Create a new blank Clueso project. Returns the projectId and initialClipId — the project starts with one blank clip already at index 0 (default short duration). Use update_clips to resize/retitle clip 0, add_clips(kind='blank') to append more clips, add_elements to place content, and add_audio to attach a project-level music track. Optionally place the project inside a folder (use find(type='folders') to find folder IDs, or create_folder to make one) and set a description at creation time.

• update_project

  Update a project's metadata: rename, change description, move to a different folder, or change aspect ratio. Only fields you provide are changed. To move a project to the workspace root, pass folder_id="" (empty string). Aspect ratio: pass any "W:H" (positive integers). The canvas is fit inside 1920×1080 keeping the ratio, so element pixel coordinates use the resulting canvas. Common values: - "16:9" → 1920×1080 (landscape, YouTube/web — default) - "9:16" → 608×1080 (portrait — TikTok/Reels/Shorts) - "1:1" → 1080×1080 (square — Instagram feed) - "3:4" → 810×1080 (portrait card) - "4:5" → 864×1080 (portrait — Instagram feed) Element coordinates are stored as fractions of the canvas, so existing elements reflow to the new canvas automatically — no element coordinates are rewritten. Concurrency: whole-project mutation (conflict domain: the entire project) — serialize. Do not run it in parallel with ANY other mutation on the same project_id, including element/voiceover edits; run

• duplicate_project

  Clone an entire project — every clip, voiceover, asset, and metadata field — into a fresh project. The copy has its own S3 namespace, so changes or deletions to the source never affect the duplicate. Defaults: - new_title omitted → "{source title} (copy)" when no folder_id is given (or it's empty) and the source stays in the same org; pass an explicit non-empty folder_id and the title is preserved. - folder_id omitted → copy lives in the same folder as the source. Returns the new project's id and title. Concurrency: whole-project read+create — serialize against other mutations on the same source_project_id; do not run them in parallel.

• export_project

  Kick off a video export of the project. Returns immediately with an export_id; the export renders in the background and takes ~5 min. Call get_export(export_id, wait_seconds=55) until status is completed — it then returns download_url (or, for destination="embed", embed_url). The export also appears in the Exports tab in the editor. destination: • "download" (default) — an mp4 file; get_export returns a time-limited download_url. • "embed" — publish the project as an embeddable video player (the same embed the editor's Share → Embed creates). The embed URL is permanent: re-publishing after edits updates the video behind the SAME URL, so pages and LMS lessons that embed it update in place. Use get_embed(project_id) to read the URL and iframe code of an already-published project without re-rendering. Defaults: 1080p / 30fps / no captions / English. Pass overrides only when needed. `captions` burns subtitles into a download; an embed instead carries captions the view

• get_export

  Check on a project's video export, waiting for it to finish. Pass exactly one of `export_id` (the one export_project returned) or `project_id` (that project's most recently REQUESTED export, which may still be in progress). Returns { export_id, project_id, status, progress, requested_at, finished_at? }. `status` is queued, waitlisted or pending (not started yet), inprogress (`progress` is 0-100), completed, failed, or stalled (stuck for hours; start a new export). The call holds open until the export completes, fails or stalls, or `wait_seconds` runs out — then it returns the current status and you call again with the returned export_id. An export takes ~5 min, so expect several calls. With project_id, a project that has never been exported returns status `not_exported` straight away (nothing to wait on): call export_project(project_id), then get_export. Once completed, the reply carries `download_url`: a direct, time-limited link (1 hour, see `expires_at`) that downloads the file n

• get_recording_activity

  Status of this workspace's auto-recordings, and how many recording generations this billing cycle has used. The same view as the Recordings page in the Clueso app. Returns { usage, rows, total, truncated }. `usage` is { cycle_start, cycle_end, generations_used, generations_limit (null: no cap), active_recordings, active_recordings_limit }. Each row is one project with its latest recording's `state` (pending: waiting for a free recording slot and starts by itself; in_progress, done or failed), the `recorders` used on it (Code-record, Browser-record), this cycle's `generations` for it, `last_activity_at` and `created_by`. A row with `kind: "run"` is a Browser-record session that has not been composed into a project yet, so it has no project_id. Rows in progress come first, then the most recent. Partial results: a source that could not be read is listed in `errors` ({ source, code, message }) and its part is null or missing; the rest is still accurate. This is a snapshot. A recording c

• get_embed

  Get a project's embeddable video player: `embed_url` (permanent) and `embed_code` (a ready-to-paste <iframe>, the same snippet the editor's Share → Embed copies). Use it to put a Clueso video in a website, help center or LMS lesson. Returns { project_id, published, embed_url?, embed_code?, latest_publish? }. • published=false — the project has never been published as an embed. Call export_project(project_id, destination="embed"), then get_export(export_id) until completed. • published=true — the URL is live. After editing the project, re-publish with export_project(destination="embed"): the video behind the SAME URL is replaced, so every page embedding it updates without changing the embed code. • latest_publish — the most recent embed publish { export_id, status, progress, requested_at, finished_at }. While it is queued/inprogress, embed_url still serves the previous version.

• create_folder

  Create a folder in the workspace, optionally inside another folder, to organize projects. Returns { folder_id, name, parent_folder_id, already_existed }. If a folder with the same name (case-insensitive) already exists in that parent, it is returned with already_existed=true instead of creating a duplicate — so it is safe to call to "ensure" a folder exists. Put projects in it with create_project(folder_id=...) or update_project(project_id, folder_id=...). List existing folders with find(type='folders').

• find

  Find any resource in Clueso by type, optionally filtered by name or exact id. One tool for listing and searching across the workspace. type: • projects | folders | clueprints | workspaces • backgrounds | voices | fonts | image_gen_style_packs | element_components (voices carry `gender`, `tags`, `accent`, `preview_url` and — where one has been written — a free-text `description` of tone and pace, which is the field actually worth choosing on. `tags` is a small closed vocabulary, so it groups voices rather than telling them apart. Choose deliberately: voiceover is the film's clock, and regenerating speech later rescales the clip and every element time and keyframe with it.) • images | videos | music | sfx — media; each result carries a `source` ('org' = your saved-media library, 'stock' = a stock/curated provider). Scope with `source`, pick the library with `provider` (see below). Stock results are a short described shortlist — pick the best fit and use its `src`. Stock video re

• switch_workspace

  Switch the active workspace. The choice sticks for this client until you change it again — including across reconnects — so every later call operates in the new workspace. Use find(type='workspaces') to see available options.

• get_project

  Get a summary of a project: canvas dimensions, per-clip summary (ids, indices, durations, element counts, voiceover_volume), and `audio_tracks` — every music/SFX entry on the project flattened to the same wire shape `add_audio` accepts (id, src, name, source_duration, guide_start_time/end_time, music_start_time/end_time, volume, loop, fade_in, fade_out). To copy an audio track to another project: read it from `audio_tracks` here and feed the same fields to `add_audio` on the target project. Call this to understand what's in the project before making changes.

• get_clip

  Read one clip: its elements (positions/sizes in canvas pixels), voiceover (text, voice, duration, voiceover_volume), background and transition. Pass `render` to also get a PNG of the frame. ASK FOR WHAT YOU NEED. A full read is large — on a dense clip the per-word voiceover array and the element type_data blobs dominate it, and repeated full reads are the main way a long session runs out of context. `select` returns exactly the parts you name: select: ['elements.x','elements.y','elements.width','elements.height'] → geometry only, to fix a layout select: ['elements.name','elements.start_time','elements.end_time'] → a timing pass select: ['voiceover_words'] → word timings only, to sync visuals to narration select: ['elements.textdata','voiceover_words'] → rewrite copy against the VO select: ['elements'] → whole element rows, no words select: ['gro

• update_clips

  Update one or more clips in a single call — background, transition, duration, title, visibility, position, and (video clips) the footage transform via video_styling. Always batch. Each entry: { clip_index, duration?, title?, background_color? | background?, transition?, hidden?, position?, voiceover_volume?, video_styling? } - voiceover_volume: 0-100. This is how you make a clip SILENT — set 0 to mute the narration while keeping the text and its word timings. get_clip and get_project report the current value, so read it before muting to restore it later. There is no "delete voiceover" tool; muting is the supported way. - background_color: hex (keeps the existing pattern/image, changes color). background: full object from find(type='backgrounds') — replaces the whole background. - transition: { type, duration, direction?, color? }, or null to remove. Set on the OUTGOING clip — the transition plays at the END of clip_index, into the next clip. Types: circleWipe, rainbowWipe, cornerWipe,

• remove_clip

  Remove a clip from the project by index. Cannot remove the last remaining clip. After removal, all clips with index > clip_index shift down by 1. When removing multiple clips by index, remove from highest index to lowest (or capture clip_ids first and re-derive indices between calls). Concurrency: whole-project mutation (conflict domain: the entire project) — serialize. Do not run it in parallel with ANY other mutation on the same project_id, including element/voiceover edits; run them one at a time. (Mutations to different projects run in parallel freely.)

• split_clip

  Split a video clip into two clips at the given timestamp. The left clip keeps the original clip ID; the right clip gets a new ID and is inserted immediately after. Elements spanning the split point are duplicated into both clips with adjusted timing. Voiceover transcript and transcribed words are split proportionally. Concurrency: whole-project mutation (conflict domain: the entire project) — serialize. Do not run it in parallel with ANY other mutation on the same project_id, including element/voiceover edits; run them one at a time. (Mutations to different projects run in parallel freely.)

• captions

  Read and edit a clip's CAPTIONS (subtitles) — what they say, where one caption ends and the next begins, when each shows, captions not tied to the voiceover, and translation. Captions are built from the clip's voiceover words: each caption is a run of words, addressed by its `start_word_index`. Start with action="list" on the clip — it returns `blocks` (voiceover captions: start_word_index, end_word_index, start/end in clip seconds, text, transcript_text, words, edited, retimed, mergeable), `manual_captions` ({caption_id, start, end, text}), `active_language` and `translated_languages`. Then: - edit (start_word_index, text) — change what ONE caption says on screen. The voiceover audio, its words and timing are untouched; to change what is SPOKEN use voiceover_batch. reset (start_word_index) restores the transcript text. - split (start_word_index, split_word_index) — cut a caption in two; split_word_index is the word that STARTS the second caption (block word i = start_word_index + i;

• duplicate_clip

  Clone one clip — within the same project, or **from another project** — into a target project. - Same project: pass `target_project_id` and `source_clip_id` (omit `source_project_id`). - Cross-project: pass `target_project_id`, `source_project_id`, `source_clip_id`. The source clip's S3 assets (voiceover audio, original video footage, generated video, etc.) are re-hosted into the target guide's S3 namespace, so the new clip is independent of the source — deleting the source project later won't break it. Insertion: pass `after_clip_id` to place immediately after a specific clip in the target. Omit to append at end. Returns the new clip_id and its final index. Concurrency: whole-project mutation (conflict domain: the entire target project) — serialize; do not run in parallel with any other mutation on the same target_project_id.

• add_clips

  Create new clips on a project. One tool, three sources: - kind="blank": empty slide clips you'll populate with add_elements / generate_media. Pass `clips: [{title?, duration?}, ...]`. Note: create_project already creates clip 0; calling with N blank entries gives N+1 clips total. - kind="pptx": extract slides from an uploaded .ppt/.pptx. Pass `mcp_upload_id` (from upload_file), optional `slide_indices`. Each slide becomes a slide_clip with native text/image/shape elements pre-populated. - kind="video": cut clips from an uploaded video/audio. Pass `mcp_upload_id` and optionally `mime_type` (default video/mp4), `title`, `voiceover_text`, `cuts: [{start_seconds, end_seconds, heading?}]`, `auto_elements`. Without `cuts` the whole upload becomes one clip. Pipeline (download → transcribe → insert) runs in the background; subsequent calls on the same upload hit a 24h cache and return synchronously. (To overlay a video ONTO an existing clip — picture-in-picture, b-roll, background loop — rath

• get_element_schema

  Return the schema for an element type's type_data, as TypeScript declarations. Call this before add_elements / update_elements when you don't already know the field shape for the element_type you're placing. Pass element_type='group' for the GROUP surface instead — what a group is, how its pivot works, and the nine properties it can animate.

• add_elements

  Add many elements across one or more clips in a single tool call. Replaces the per-element tool — always batch. SEND LESS. Most batches repeat themselves — the same clip_index, element_type, font_setting, alignment or gradientSetting on every item. Hoist those into `defaults` and send them once; each item then carries only what differs, and overrides any key it sets (type_data merges one level). On a 20-30 element batch this typically cuts the call by a quarter to a half. `returning` shapes the response the way `select` shapes a get_clip read. defaults: { clip_index: 2, element_type: 'text', type_data: { font_setting: { font: 'Inter', weight: '600' }, alignment: 'center' } } elements: [ { name: 'headline', x: 960, y: 400, type_data: { text: 'Hello', fontSize: 120 } }, ... ] Use after calling get_element_schema to confirm the type_data shape per element_type. Items within one call are applied in order; returns one result entry per input item so partial success is fine. Reuse ins

• update_elements

  Update many elements across one or more clips in a single tool call. Replaces the per-element tool — always batch. SEND LESS, GET BACK LESS. `defaults` carries what every item shares (clip_index, element_type, and type_data entries like font_setting or alignment) so you send it once instead of per item; each item overrides any key it sets. `returning` declares what comes back, the way `select` shapes a get_clip read — omit it for a sensible default, or pass [] for just the counts. defaults: { clip_index: 1, element_type: 'text', type_data: { font_setting: {...} } } returning: [] → { total, succeeded, failed } only returning: ['layout'] → + the measured text fit per element returning: ['qa.codes'] → + the clip audit with prose stripped from non-errors (any returning value → error findings regardless; only warnings are opt-in) Each item can update position/timing fields alone, or type-specific fields via type_data (use get_element_schema in 'update' mode to se

• remove_elements

  Remove many elements across one or more clips in a single tool call. One entry per element ({clip_index, element_id}). Concurrency: parallel-safe (conflict domain: the individual element) — same as update_elements. Each removal is a granular element_remove patch scoped to that element id, and the whole batch lands in ONE save. Fan out across subagents as long as they touch DIFFERENT element ids. Two concurrent edits to the SAME element id do not last-write-win — the later one is REJECTED and nothing is written; re-read and re-apply. Do NOT run concurrently with whole-clip/whole-project mutations on the same guide (update_clips on that clip, structural clip ops, add_audio, update_project). To remove an audio track (not an element), use remove_from_project(target='audio').

• reorder_elements

  Reorder the elements inside a clip. List position IS the z-index — later entries in `ordered_element_ids` render on top of earlier ones. You MUST pass the full set of element IDs currently in the clip. The handler rejects partial lists so a reorder can never silently drop an element. Get the current list via get_clip — the order it returns is exactly the order this takes. Works on grouped clips. Elements keep their group; moving a group's members together moves the whole group relative to everything else. The one thing a group cannot do is render in two pieces, so an order that puts a non-member BETWEEN two members of the same group is rejected and names the group — put the group's elements next to each other, or take the element out of the group first with update_elements(group).

• update_groups

  Transform, keyframe, rename, nest or lock GROUPS. A group moves, scales, rotates and fades as ONE unit, without touching any child's stored position — which is how you get a camera push instead of building the target layout twice and crossfading it. Address by `group_id`, never by name. Ids come from get_clip, or from the `group_id` that add_elements/update_elements hands back when you pass `group`. An unknown id is an error, never a silent create. There is no add_groups: a group is CREATED by putting elements in one — `add_elements(group: "hero-card")` — which also returns its id. That is not a shortcut; a group's pivot comes from its children's bounding box, so an empty group has no geometry to transform. The shortest path, in one script: const clip = get_clip({ project_id, clip_index: 2, select: ["groups"] }); const byName = new Map(clip.groups.map(g => [g.name, g.id])); update_groups({ project_id, items: [{ clip_index: 2, group_id: byName.get("hero-card"), anchor_

• remove_from_project

  Remove an element, a group or an audio track from a project. - target="element": removes an element (requires element_id, or element_ids for several). clip_index is optional — the element is located by id; pass it only as a hint - target="group": removes a GROUP node (requires clip_index + group_id). By default its children survive — they rise to the removed group's own parent, which for a top-level group is the clip root. Pass keep_children=false to delete the whole subtree instead, every nested group and every element inside it. - target="audio": removes a music/SFX track (requires music_id — returned by add_audio) Concurrency: target='element' is element-scoped (conflict domain: the individual element) — parallel-safe with other element edits on different elements, same as remove_elements. target='audio' is a whole-project mutation — serialize it against any other mutation on the same project_id. (Mutations to different projects run in parallel freely.)

• add_audio

  Add a music track or sound effect that plays as a project-level audio layer over all clips. Does NOT consume a clip slot. Use this for background music or a soundtrack that should play under the existing timeline. (For inserting an audio file as its own sequential clip with auto-transcription, use add_clips(kind='video') with an audio mime_type instead.) - type="music": requires src, name, source_duration. `src` is either the `src` from a find(type='music') result, or an mcp_upload_id (prefixed `mup_`) from upload_file — upload ids resolve to a presigned URL server-side. For a Freesound result the `src` is an opaque handle; pass it through unchanged and Clueso downloads + hosts the original server-side (do not try to fetch it yourself). Get `source_duration` from the find result, or from analyze_audio mode='features' (data.duration_ms / 1000). Optional: guide_start_time, guide_end_time, music_start_time, music_end_time (trim the source track), volume, loop, fade_in, fade_out. - type="

• update_audio

  Mutate fields on an existing music/SFX track by id. Read existing tracks via `get_project.audio_tracks` — the per-entry shape there matches this tool's args, so you can flip a knob (volume, fades, timing, loop) and write it back without losing the track's id. Only fields you pass are changed; omitted fields are preserved. To delete a track entirely, use `remove_from_project(target='audio')` instead.

• voiceover_batch

  Set voiceover text and/or trigger speech generation for any number of clips in a single call. Each entry chooses its own action: - "set_text" — set transcript for a clip (clip_index + text) - "generate_speech" — async TTS for a clip (returns immediately) - "set_and_generate" — set text and kick off TTS in one entry (+ text) Address a clip the same way as everywhere else: `clip_index`. Pass `clip_id` instead if you already have it — it survives clips being inserted or reordered mid-build — but you never need both; whichever you omit is looked up once for the whole call. Entries within one call are applied in order. Returns one result object per input entry. All text-set actions land in ONE save; the TTS for generate/set_and_generate runs async per clip after. Sync points: if get_clip's `voiceover_text` for the clip contains `<SYNC_MARKER N>` tokens (a screen recording's on-screen actions), your new text must carry every one of them, each exactly once and in order, placed

• auto_sync

  Run the agentic auto-sync pipeline against a clip with a source recording. Detects natural sync points (UI state changes, narrated steps) and inserts sync-marker nodes into the clip's transcript. Async: returns immediately with a status enum from the pre-flight; sync-marker nodes appear in the transcript a few seconds later. Poll get_clip if you need to verify. Capacity: capped at 3 concurrent runs platform-wide. Returning status='success' means the job was accepted, not that it finished. Sync points are required input for voiceover TTS on video clips — without them, the TTS has no per-step pacing reference. (See resource clueso://docs/sync-points for the full model.)

• add_sync_point

  Insert one sync marker on a clip's transcript. Use this when: - The user is explicit about WHERE the camera should pause / cut (e.g. "sync the word 'submit' to 4.2s of the demo"). - `auto_sync` ran but missed a step you care about. How matching works: - `word`: case-insensitive, punctuation-stripped. The first match in the transcript is used unless `occurrence > 1`. - `occurrence`: 1-indexed — pass 2 to target the SECOND time that word appears, 3 for the third, etc. Required when the word repeats. - `timestamp_seconds`: clip-relative seconds. When the clip has run TTS already (`generated_timestamps` present), the server inverse-maps this to original-recording seconds automatically. Constraints: the clip MUST be a video clip with a source recording (otherwise the frame thumbnail can't be extracted). The transcript must already contain the word — if not, you'll get `word_not_found` with a 200-char excerpt of the transcript to help you retry.

• upload_file

  Upload one or more files to Clueso. Pick a mode by client + where the file lives: 0. **files** — ChatGPT only: files the user attached in the conversation. ChatGPT fills each entry (download_url + file_id) itself; pass the attachments here rather than asking the user to re-upload. Returns one mcp_upload_id per file. 1. **file_name** — HOSTED upload, the default for any non-UI / programmatic upload (Claude Code, Cursor, Claude Desktop, scripts). Returns an upload URL on Clueso's OWN base domain + a ready-to-run curl that streams a single local file to it; Clueso relays the bytes to storage server-side. The PUT targets the base domain — NOT cloud storage directly — so it works on desktop/agent clients that can't reach or are blocked from S3. Requirement: the client must be able to PUT bytes to the Clueso base domain (run the returned curl, or any HTTP PUT). The agent (or the user at a shell prompt) runs the curl. Prefer this whenever there's no human at a browser. 2. **file_url**: Pass

• check_uploads

  Fetch all files the user uploaded via the hosted upload page. Returns one mcp_upload_id per file — pass each to the appropriate tool (add_clips, add_article_media, etc.). Call this once after the user confirms they are done uploading; the token covers all files they dropped on the page.

• generate_media

  Generate an AI image or canvas-code-based animation directly into a clip. - kind="image": text-to-image. Pass `prompt`. Optional: `animation_setting` (entry/exit — set it HERE, see below), `style_id` (from find type='image_gen_style_packs'), `reference_image_url` or `mcp_upload_id` for image-to-image grounding. - kind="animation": canvas-code animation rendered from a prompt. Pass `prompt`. Optional: `voiceover_text` (drives timing), `base_component_id` (reuse a saved animation as the starting point), `reference_image_url` or `mcp_upload_id` for visual grounding. Generation is asynchronous: the element is created immediately with a stable `element_id` and rendered in the background. Poll `get_clip(select:['busy'])` — an EMPTY `busy` means the render has landed. (This previously said to watch the `phantom` flag; `phantom` has never been a key get_clip returns, so there was nothing to poll.) Set presentation up front. `animation_setting` is applied to the element as it is created, so

• estimate_duration

  Estimate voiceover duration for one or many clips at once (~150 words/minute). Pass an array of voiceover texts — one per clip. Returns durations in the same order, ready for add_clips.

• analyze_audio

  Analyze an audio file. Modes: - transcript: Speech-to-text with word-level timestamps — returns `{language, full_text, words}` where each word is `{word, start_ms, end_ms, punctuated_word}`. ⚠ MILLISECONDS here; get_clip's `voiceover_words` gives the same words in SECONDS as `{word, start, end}`. Use for caption timing, script editing, or word-level visual sync. Works on narration and on sung lyrics: the provider is picked from the content, and if it returns nothing the other one is tried automatically. So an empty `words` means the audio genuinely has no intelligible speech, not that the wrong engine ran. - silences: returns `{silences, total_silence_ms}`, each span `{start_ms, end_ms, peak_db}`. Use for auto-trim, smart-split, or pause-aware editing. - beats: returns `{tempo_bpm, beats_ms}` — beats_ms is an array of MILLISECOND positions. Empty for non-music. Use to align animations/zooms to a beat. - features: returns `{duration_ms, peak_db, rms_db, lufs, has_music, has_speech}` — l

• get_article

  Get the article content as markdown. Screenshots appear as <SCREENSHOT {id}> placeholders. Returns the markdown text and a list of screenshot IDs.

• update_article

  Update article text content from markdown. Use <SCREENSHOT {id}> placeholders to position screenshots. Screenshots in the markdown are kept. Screenshots removed from markdown are deleted. Order in markdown defines final order. Get the current article first with get_article, modify the markdown, then call this.

• add_article_media

  Add a screenshot or GIF to the article. Returns a screenshot_id to place in the article via update_article using `<SCREENSHOT screenshot_id>`. - kind="image": pass `timestamp` to capture a frame from the project's base video, OR pass `mcp_upload_id` (from the upload tool) to attach an uploaded image. One of the two is required. - kind="gif": pass `timestamp` (start) and `duration` (seconds). Captures a short GIF clip from the base video. Requires the project to have a video clip.

• update_article_media

  Update an article image/GIF (screenshot), or inspect its current state. - Provide one or more of `zoom_factor`, `crop`, `shapes` to change metadata. - Pass `render=true` (with no other updates) to fetch the current details without mutating. To DELETE an article image/GIF: call `update_article` with markdown that omits the `<SCREENSHOT id>` reference. Unreferenced media is pruned server-side on save. There is no separate delete tool — the markdown IS the source of truth for what's present.

• create_clueprint

  Create a new clueprint (reusable video template). A clueprint is a structured file directory with design notes, composition rules, and screenshots that can be used to generate videos. Use human-readable folder categories: design/ (colors, typography, backgrounds, animation), rules/ (composition, voiceover, editing), screenshots/ (rendered clip previews). See the "Creating Clueprints" section in the system instructions for the full structure. If source_guide_ids are provided, guide data is automatically extracted clip-by-clip into the clueprint as reference material.

• get_clueprint

  Fetch clueprint data. Use `include` to control how much you pull back: - include="metadata": just the clueprint's name/description/tags/visibility/thumbnail. - include="tree": metadata + the full file tree (path, mime_type, and size per entry). Call this first when exploring an unfamiliar clueprint. - include="files": the contents of the files listed in `file_paths` (no metadata — call include='tree' first if you also need metadata). Text inline, binary as presigned GET URLs. - include="all": metadata + the file tree + the contents of every file in the clueprint (use sparingly on large clueprints). Calling this also logs the clueprint as "used" (fire-and-forget) so the workspace's recents list stays accurate — no follow-up use_clueprint call needed.

• update_clueprint

  Update a clueprint's metadata and/or file contents in one call. Metadata fields (`name`, `description`, `tags`, `visibility`, `thumbnail_path`) are applied as a patch — only the fields you pass change. Pass at least one to update metadata. `files` is a list of file mutations: - Write text: `{ path, content }` - Write binary: `{ path, content, encoding: "base64" }` - Write from URL: `{ path, source_url }` (presigned URL, e.g. from get_clip with save=true) - Delete: `{ path, content: null }` You can mix writes and deletes in a single call. Existing files at the same path are overwritten.

• set_voice

  Set the voiceover voice for every clip in a project, or only for the clips in `clip_ids`. Use this to apply a clueprint's voice (read `voiceover.voice.name` and `voiceover.voice.engine` from the clueprint source data), or to switch all clips to a specific voice in one call. When the user names specific clips, pass their ids in `clip_ids` so the other clips keep their voice. The voice is looked up by name + engine; lookup is case-insensitive on the name. Common engines: 'eleven' (ElevenLabs), 'cartesia', 'google'. ElevenLabs voices use the latest voice generation unless `voice_version` says otherwise. Leave it unset; pass "legacy" ONLY when the user explicitly asks for the legacy/older voice generation.

• add_comment

  Post a review comment on a project, attributed to "Clueso AI". Use this to leave feedback, suggestions, or notes — either at the project level (no clip_id) or pinned to a specific clip with an optional timestamp inside that clip. Pass `parent_comment_id` to REPLY to an existing comment rather than open a new thread. Read what is already there with `get_comments` first: answering a reviewer in their own thread is what makes the note resolvable, where a fresh top-level comment just adds noise.

• get_comments

  Read the review comments on a project — the other half of `add_comment`, which could post but never read. Comments are how a human reviewer tells you what is wrong with a video: a note pinned to a clip and a moment inside it. Read them before an editing pass so you act on what was actually asked for, and read them again after a build if a reviewer has seen it. Threads come back nested: each top-level comment carries its `replies`. Reply into a thread with add_comment(parent_comment_id=...) rather than posting a new top-level note — a reviewer reading their own thread is how they see that their point was handled. Resolved threads are hidden by default, so a plain read is "what still needs attention".

• record_screen

  Records the product on a mock (Code record) as a screen-recording clip in a project. Creates blank placeholder clips, registers job entities, and sends the job to AVS. The blank clips this tool creates are placeholders; they become video clips when processing completes, so removing one loses that scene. Article placeholders are also inserted automatically into plainDoc. Check how the recording is going with get_recording_activity(project_id). A recording can take hours, so check once rather than polling in a loop. Requires the Auto-Recording add-on and per-workspace sign-in credentials for the product being recorded. Workspaces without it get back the manual path instead (upload_file, then add_clips(kind='video')) rather than a failure.

• run_script

  Write a JavaScript program that calls this server's other tools. You have the whole language: loops, arithmetic, functions, conditionals, and values carried from one call into the next — all running next to the tools instead of across the conversation. Use it whenever code says the thing more directly than a sequence of separate calls would, which is often. COMPUTE, don't hand-write. Anything you would otherwise work out in your head and type as literals is better computed here — eased keyframe tracks, staggered start times, grid coordinates, derived palettes, positions from measured text widths. This is usually what makes motion look right: sample a curve at ten points and emit the values, rather than guessing four. DON'T COMMENT THE SCRIPT. Nobody reads it — it runs once and is gone. Comments, blank lines and explanatory names are pure cost here. Write it dense. The one thing to remember: inside a script you see only what you `return` or log, so a tool's own rich output (layout me

• get_script_job

  Fetch the outcome of a run_script that did not finish inline. Waits for it rather than returning immediately, so one call is usually enough — set `wait_seconds` to how long you are willing to hold. Returns { job_id, status, result?, error? }. `status` is processing, completed or failed; `result` carries the same { ok, result, stdout, ops } the inline reply would have. The script runs to completion whether or not you poll.