Reference
MCP tools
The 86 tools your AI app gets when it connects, grouped as the server groups them. This page is built from the server itself, so it always matches the version you download.
Your AI does not need this page: it calls start_here first, which explains the flow,
every field and every closed list in small sections. This page is for you, and for apps that let you turn tool
groups on and off.
Tools by group
Start
| Tool | What it does |
|---|---|
ping | Is the app there, and is anything waiting for me? |
start_here | CALL THIS FIRST. |
get_rules | The engine's plan rules (id + what it means) for a recording or a documentary video -- the plan is changed or sent back when it breaks one. |
list_videos | The user's videos, newest first: id, topic, status, stage, and whether a Director brief is waiting. |
get_status | Where the video is: status, stage, why it waits, and which Director brief is ready to answer. |
wait_for_change | Wait (up to ~50 s, on the app's side) until the video's status or stage changes from the ones you pass (from your last get_status), then return the new status. |
New video (idea / script)
| Tool | What it does |
|---|---|
create_video | Start a new video that YOU direct (it pauses for your asks, then for your plan). |
draft_status | A draft you made with create_video: waits (up to wait_seconds, max 300) until the creator presses Start in the app -> {draft_id, started, id (the video id once started)}. |
list_channels | The creator's channels (each a brand kit, look, caption style, voice, style for a series of videos): id, name and what it sets. |
list_templates | The creator's saved channel styles (a look: fonts, colours, captions, transitions) and templates (a video's shape: slots over its running time) -- ids for create_video(style_pack= / template=) and apply_template. |
apply_template | Put a saved channel style (style_pack) and / or template on this video; redirect=true plans it again from DIRECT with them (the review stays before the render). |
save_template | Save this edited video's shape as a template AND its look as a channel style, for the next videos of a series. |
Recording
| Tool | What it does |
|---|---|
plan_shoot | BEFORE the creator records: the app's recording director plans the shoot -- the lines (written in `language` from the idea, or the creator's own `script` kept word for word), one numbered shot per line (size, camera… |
submit_shoot_plan | YOUR shoot plan for the creator's recording (you write the lines and the direction; the app checks every choice against the same closed lists as its own recording director, numbers the files and sets the pauses). |
get_shoot_plans | The saved shoot plans (newest first), or one plan with its teleprompter when plan_id is given. |
create_video_from_recording | Mode B: a video around the creator's own recording (a video file on this computer) that YOU direct. |
look_at_recording | See the creator's recording BEFORE you plan (Mode B): the keyframes INGEST took at its change points (cuts, a new place, start / middle / end), each with its time, and the card — the room, the light, the framing, what… |
get_space_map | READ BEFORE PLACING on a recording: per beat the speaker's `face` box, the `headroom` above the head, where a big word goes (`big_word`: behind = above the head / chest = in front across the `chest` box / none), and… |
Asks and files (fast lane)
| Tool | What it does |
|---|---|
get_director_brief | The Director's brief for a pass ("asks" or "plan"): the exact prompt the app's model would get, the beats with their words, the assets (id, kind, what each shows) and every closed list. |
submit_asks | Your asks pass: [{kind: cutout|plate|series|video|web_image|web_clip, scene_id, beat, shows, use, subject?, view?, direction?, factor?, steps?, prompt, search_query, youtube_query?}]. |
get_asset_prompts | The numbered asset slots the creator fills (after your asks): each slot's EXACT generation prompt, its reference note (series: made from the previous step), the clip's motion prompt, and its status (missing / uploaded… |
get_unfilled | The asset slots still waiting for the creator (missing or rejected): number, asset id, kind, what it must show (the prompt / search words) and why a rejected one failed. |
fill_slot | Fill one slot, the fast lane's one tool: a file on this computer (`file`) or a video link (`url`, optionally start-end, at most 8 s; checked=true when the creator looked at that moment -- no AI watch). |
upload_asset | Put a file the creator made into its slot: `slot` is the number (e.g. |
link_clip | Fill a clip slot from a video link (plan 23 K2/K3). |
find_pictures | The video is short of real pictures / clips for these beats ("s10/0", up to 24): the app searches the web and the library for them and re-plans ONLY those beats; every other beat stays. |
search_pictures | One more search round for the story's parts that are short of pictures (UNDERSTAND), then the video goes on. |
search_assets | Find a better picture yourself: the built-in library (source="library"), or the web (source="web", pictures only, when the creator allows web sourcing). |
add_asset | Put a candidate from search_assets into the video. |
view_asset | See pictures or clips from the brief before you place them (a clip: its first frame) — by id or the brief's alias, up to 8 at once. |
Plan
| Tool | What it does |
|---|---|
get_stage_health | Where this video lost quality, per stage: warnings and errors counted with their most common lines, what it got less of (in plain words), and how often each plan rule changed it. |
list_motion_templates | The motionmaxxing moments (film-grade motion on its own runtime): for each id what it is, when it fits (purposes and needs), its params and a filled sample. |
get_sources | What research found for this video: sources kept of found, by kind (wire services, national outlets, analysis houses, academic, official bodies, reference, video), the strongest sites, what the trust filter left out… |
submit_plan | Your plan pass, in the brief's JSON shape: {thesis, beats: [{scene_id, beat, staging, assets, canvas, camera, transition, composition, type_style, depth, backdrop, sound, music_cue, params, why}], video: {...}}. |
check_plan | Dry-run a plan without saving or starting it: exactly what DIRECT would change (`check.issues` block a run, `check.changed` are softened choices, `check.coverage` the share of beats showing a real picture). |
patch_beats | Change only some beats of your last plan: each item {scene_id, beat, ...the fields to change}; every other beat stays as it was. |
get_plan | The plan saved for this video now (yours, or the app's own when you have not planned), in the exact shape submit_plan / check_plan take (short keys) -- edit it and send it back; never read the app's files for it. |
get_beats | Every beat of the video: its id {sc, b} exactly as plans take it, function, words, start / end seconds, and your plan's staging and pictures on it; plus how many DISTINCT real pictures the gate needs (`pictures`). |
storyboard | One frame per beat of the laid-out video (mid-beat), each labelled with its beat and words -- the whole plan at a glance before you approve the render (a submitted plan is laid out by the app; then call this). |
design_language | How to write a NEW animated graphic yourself: the elements (labels, counters, equations, shapes, paths, arrows, nodes, axes, graphs, bars) and the timeline (create, write, grow, morph, move along a path, count, timed… |
try_scene | Try a graphic scene YOU coded before placing it: kind = spec (a designed beat's spec, design_language) | program (def draw(c, t, w, h)) | html (one self-contained page, seeked per frame). |
view_fonts | The video's fonts, seen like pictures: with no families, the type moods and every face's card (what it looks like, what it is best for), optionally for one mood; with families (up to 8), each face's rendered preview (a… |
Review and render
| Tool | What it does |
|---|---|
look_at_frames | See the laid-out video: `count` frames spread from `start` to `end` seconds (end 0 = the end of the video). |
look_at_scene | See one scene closely after a fix: `count` frames spread across it (its words are listed first). |
get_quality | The measured checks of the video: the acceptance gate before render (`gate_before_render`: every check but loudness, on the laid-out video; approve_render is refused while it fails) and after it (`gate`), the Leaf 80… |
review_project | Look at one part of a video before it renders (plan 31 I4: the same read tools as the app's review Director). |
edit_layer | Fix part of a beat instantly, with no re-plan: give one layer (ids from look_at_scene) another picture or clip from the brief (`asset_id`, id or alias), new times, or remove it. |
preview_scene | A quick small render of one scene (or start..end, up to 20 s) of the current layout with the narration, in seconds -- to check motion, timing and keyframes after edit_timeline. |
get_timeline | The laid-out video as one JSON document (absolute_control videos can edit it): every layer's layer_id, kind, recipe, start_ts / end_ts, z_order, transform {x, y, scale, rotation}, params and keyframes; each scene's… |
edit_timeline | Exact edits that land as written (director_rules absolute_control). |
revoice_scene | New spoken words for one scene, then the narration spoken again (unchanged scenes keep their takes; voice: any voice id the app lists, "" keeps the video's). |
approve_render | Render the video as it is laid out now — your decision as the Director, after look_at_frames and get_quality. |
get_render | The finished video: the file on this computer and its size, length, loudness, title and title options, chapters, thumbnails. |
get_logs | A stage's log (newest last) -- why a stage did what it did; no stage: which stages have logs. |
read_job_file | Read one of the video's text / JSON files (read-only; e.g. |
get_changes | Everything the app changed by itself in this video, in plain words: pieces ordered and trimmed, bad takes and hesitation sounds cut, loan-words rewritten, which of the creator's pictures were used (and why not),… |
rerun_video | Run the video again from a stage (INGEST | RESEARCH | ASSETS | ACQUIRE | UNDERSTAND | DIRECT | VOICE | MANIFEST | SOUND_DIRECTOR | PREVIEW_QA | RENDER): everything from that stage on is redone, finished work before it… |
resume_video | Continue a stopped or interrupted video from where it stopped (finished stages are kept). |
cancel_video | Stop a video that is running or queued (it stops at its next safe point; finished work is kept and the user can resume it in the app). |
Captions
| Tool | What it does |
|---|---|
get_captions | The captions exactly as the video draws them: the caption style settings and, per scene, every word with its index `i` and times, the caption lane box and the pauses. |
set_caption_words | Correct misheard caption words in one scene: edits = [{"i": word index from get_captions, "word": "Amazon"}]. |
set_caption_style | Change the caption look for the whole video: style = the caption settings to change (e.g. |
list_caption_styles | Every caption style a video may use (plan 34 C2): the built-in ones by group, and "Yours" -- the creator's own from the Caption Studio (style id "user:<id>", each with its language versions). |
Dub
| Tool | What it does |
|---|---|
list_dub_voices | The voices a dub (or a new video) can speak with, for a language when given: id + name. |
dub_video | The same video in another language, by name (e.g. |
create_dub | Plan 33 (the Dub page over MCP): the creator's own video file on this computer, in any language, dubbed into `language` (by name, e.g. |
look_at_dub | Read a dub before it renders: every turn -- who speaks (speaker), when (start / end on the source), the source line, its translation, where the new line sits and its speed. |
set_dub_options | Change a dub before it renders. |
dub_status | Where a dub stands: its stage and progress, the new language, speakers and lines re-voiced, what was cloned, seconds added in "longer" mode, and the error if it stopped. |
Topics
| Tool | What it does |
|---|---|
find_viral_angles | Find a proven angle before a video (plan 23 V1): public YouTube videos ranked by how far each beat its OWN channel's median (>= 4 videos per channel; views per day when dated; Shorts and long apart; a 5,000-view… |
watch_winners | Read the top winners BEFORE choosing an angle (after find_viral_angles): for each video (at most 5) its title, thumbnail and the first 30 seconds of what it says -- no download -- then why it wins: the hook line and… |
make_my_version | The creator picked one winner (owner 2026-10-31: a video is watched only when picked): the app watches that YouTube video and writes its style card (pace, cuts, hook shape, look) -> {id: "sc_..."}; poll… |
make_from_angle | Turn an angle from find_viral_angles into a DRAFT the creator finishes in the app's New-video wizard (the creator picks the rest; never started from here): the working title as the topic, its why as a note, and the… |
get_topic_asks | The Topics research questions waiting for you (Settings -> AI per stage -> Topics is yours): plan the YouTube searches for a niche, keep the channels that ARE the niche, read the winners into angles. |
answer_topic_ask | Answer one Topics research question with the JSON its instruction asks for (e.g. |
Shorts and publishing
| Tool | What it does |
|---|---|
make_shorts | Make the chosen clips (ids from list_clips) as 9:16 Shorts. |
shorts_status | Whether the Shorts are made yet, and their download links when they are. |
list_clips | The moments of a finished video worth posting as Shorts: whole-sentence windows of 15-60 s, scored (hook, complete idea, length, energy), each with its id, times and title. |
publish_bundle | Once the video is rendered: ONE folder (and a zip) with everything to upload -- the video and its light copy, captions as SRT and VTT, chapters, titles, description, three thumbnails, credits. |
More tools
| Tool | What it does |
|---|---|
answer_review_ask | Answer one review ask: {"say": "...", "findings": [{"what", "source"}], "actions": [{"action", "payload", "why"}]}. |
answer_studio_ask | Answer one studio ask with the JSON its instruction asks for ({"say", "patch" | "camera_keys", "save_as"}; an ask about several layers, a whole scene or the whole video: {"say", "changes": [{"layer_id", "patch"}]}). |
get_review_asks | What the creator asked the Director before the render, waiting for you ("Review chat" is yours in Settings -> AI per stage). |
get_stage_turn | The AI stage this video waits on you for (plan 23 M4: RESEARCH, UNDERSTAND, ... |
get_studio_asks | The changes the creator asked for in the studio's ask box, waiting for you ("Studio chat" is yours in Settings -> AI per stage). |
set_stage_owners | Who decides each AI stage of this video (plan 23 M1): {"RESEARCH"|"ASSETS"|"UNDERSTAND"|"DIRECT"|"PREVIEW_QA": "app" | "mcp" | "mcp:<client>"}. |
submit_stage_turn | Answer an AI stage you own, in the shape its brief names -- RESEARCH: {"report": markdown, "sources": [urls]}; UNDERSTAND: {"verdicts": [{"id", "keep": true/false, "why", "description"?}]} (view_asset first: judge what… |