Frameo

Pull still images out of a video, and optionally cut a range of it into a clip. Returns Frameo links. Free: no credits are charged. The common use is the LAST frame of a clip, which becomes a generate_videos item's first_frame_url so the next shot continues from exactly where this one ended. With start_ms and end_ms (for example one shot's bounds, copied verbatim from an analyze_media run with detect_shots), the range is also cut into its own clip, returned as clip.url (a link only: it is not added to the module's Library or canvas), and every moment in at_seconds lies inside the range. One call covers one range; several shots take one call each, and they can run in parallel. Answers within about 50 seconds. The result also carries small JPEG previews of up to 4 of the frames (at most 384 px) as image content next to the same JSON; previews lists the frame links they show, in the same order as the images.

extract_frames

The Frameo home, opened by the user from ChatGPT's sidebar or a conversation tab: the workspace and its credits, the newest projects with their latest images and videos, and the kinds of work Frameo has a skill for. Free. Hidden from the model. The user writes what to make on the home, picks a project or a starting point, and the home posts it into the chat as the user's message; it spends nothing and starts no work. Returns workspace_name, credits (null when Frameo does not report them), app_url (the Frameo web app) and projects: the newest few, each with project_id, name, module_count, its first module with an open_in_frameo link, and recent, that module's latest images and videos with kind, url, still, prompt and created_at. list_skills and list_models list the skills and models the card offers.

open_frameo

Start a background-music track in a Frameo project. Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Returns generation ids once the work is queued; wait_task returns the track when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The track is saved in the Frameo project. How to describe it: get_skill("audio-prompting").

generate_music

Generate a new one-shot sound effect in a Frameo project. Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. This makes a new sound. search_sound_effects searches a library of ready-made sounds, which are free and instant. Returns generation ids once the work is queued; wait_task returns the sound when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The sound is saved in the Frameo project. How to describe it: get_skill("audio-prompting").

generate_sound_effect

Start a video generation in a Frameo project. Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Text-to-video by default. first_frame_url opens the clip on that image, and last_frame_url ends it on that one; reference_image_urls instead carry a character, product or look into a new shot, and reference_audio_urls guide its sound; reference_video_url continues or edits an existing clip. On Seedance models frames guide the clip rather than pin it: it opens on the first and moves toward the last, renders at the requested aspect_ratio, combines frames, reference images and reference audio, and counts each frame as one reference image. On every other model the clip takes the first frame's own shape, and frames with reference images or audio are refused. A request that breaks a model's rules is refused before anything is charged. Returns generation ids once the work is queued. The video takes one to a few minutes, and wait_task returns it. Where the chat app shows cards, show_generations with these ids shows the work to the user. On Seedance, reference images and frames are prepared before the video starts, and an image's first use can add a short wait. references_registering means that outlasted this call: nothing was charged, the quote is unused, and the same call continues it. reference_image_rejected names an image that was refused, and reference_registration_incomplete one that could not be prepared; nothing was charged for either. The result is saved in the Frameo project; its open_in_frameo link opens it there.

generate_video

Start a voiceover (text to speech) in a Frameo project. Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Returns generation ids once the work is queued; wait_task returns the audio and its duration_seconds when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The voiceover is saved in the Frameo project. When a person on screen has to say this exact audio, generate_lipsync then makes their mouth match it. Choosing and keeping a voice, and directing the delivery: get_skill("audio-prompting").

generate_speech

Start an image generation in a Frameo project. Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Text-to-image, or from image_urls: source images that either EDIT an image or hold a character, product or style steady in a new scene. The prompt says what to keep and what to change ("same woman, now on a beach at sunset"). Supported resolutions and source-image counts vary by model; list_models reports each. How to write the prompt and pick the model: get_skill("image-prompting"). Returns generation ids once the work is queued; wait_task returns the images when they are ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The result is saved in the Frameo project; the finished result's open_in_frameo link opens it there.

generate_image

Start one or more independent images together in one call. Uses the user's Frameo credits. This starts one or several at once, such as the keyframes of a sequence that do not depend on each other's results. Each item has an index of your choosing (such as the shot number) that its result carries. An image made from another's result waits for that one to finish, in a later call. Each item is text-to-image, or from image_urls: source images that either EDIT an image or hold a character, product or style steady in a new scene, with the prompt saying what to keep and what to change. Supported resolutions and source-image counts vary by model; list_models reports each. How to write the prompt and pick the model: get_skill("image-prompting"). Paid: estimate_cost(items=...) quotes them in one call and returns one quote_id per item, single-use, valid 15 minutes and bound to that item's settings. Each item passes its own, and confirmed_by_user records that the user agreed to them. An item without its quote, or with other settings, is refused uncharged, and the other items still start. Returns items, one entry per item with its index and its result: its generation_ids and credits_charged once started, or its own error. generation_ids and credits_charged at the top add up the items that started. Where the chat app shows cards, show_generations with all of generation_ids, once, shows the work to the user before the first wait_task; wait_task returns the images. A wait_task timeout leaves the work running and the ids valid. When the outcome is unclear, send the same call again: items that started return their work, marked replayed, and charge nothing. Never take new quotes to recover a call; a new quote starts new work.

generate_images

Start one or more independent videos together in one call. Uses the user's Frameo credits. This starts one or several at once, such as the shots of a sequence that do not depend on each other's results. Each item has an index of your choosing (such as the shot number) that its result carries. A shot that continues from another's last frame waits for that one to finish, in a later call. Each item is text-to-video by default, or opens on, passes through or ends on its frames, carries reference images or audio into a new shot, or continues reference_video_url. On Seedance frames guide the clip rather than pin it and count as reference images; on other models the clip takes the first frame's shape, and frames with reference images or audio are refused. An item that breaks a model's rules is refused uncharged. Paid: estimate_cost(items=...) quotes them in one call and returns one quote_id per item, single-use, valid 15 minutes and bound to that item's settings. Each item passes its own, and confirmed_by_user records that the user agreed to them. An item without its quote, or with other settings, is refused uncharged, and the other items still start. Returns items, one entry per item with its index and its result: its generation_ids and credits_charged once started, or its own error. generation_ids and credits_charged at the top add up the items that started. Where the chat app shows cards, show_generations with all of generation_ids, once, shows the work to the user before the first wait_task; wait_task returns the videos. When the outcome is unclear, send the same call again: items that started return their work, marked replayed, and charge nothing. Never take new quotes to recover a call; a new quote starts new work.

generate_videos

The prompt text of up to 10 presets, for an image or video prompt. Free. Each preset has its prompt (used as written, then tied to the scene), when to use it, notes, and any reference images, videos or audio to pass along with it. Ids that are not found are listed in missing; when none is found, the call returns unknown_preset.

get_presets

Read one file of a Frameo skill, such as a shot-list template or a caption style. Free. A skill's text names a file at the step that needs it, as get_skill_file(skill_id=..., path=...): call it then, with exactly that skill_id and path. A text can point at another skill's file; that skill does not need loading first. Returns the file's text and `uses`: the other skills, their files, and the presets and preset categories this file calls.

get_skill_file

Step-by-step instructions for one Frameo skill, such as a video from a script. Free. Returns the skill text: when it applies, what to ask the user first, the tool calls in order (every paid step is quoted with estimate_cost before it runs) and what the user gets. `files` lists the skill's own files, readable with get_skill_file; `uses` lists the other skills, their files, and the presets and preset categories the text calls. Load each when its step comes.

get_skill

Import images, videos or audio the user attached in the chat into Frameo and a project's Library. Free. In chat apps that pass attached files to apps (ChatGPT), each entry in files is the file object the app provides for an attachment in the user's message, with its download_url and file_id. Where attachments do not arrive here, show_upload takes files from the user's device and import_media_url takes web links. Takes PNG, JPEG or WebP (up to 20 MB), MP4, M4V or MOV (up to 200 MB), MP3, WAV or M4A (up to 50 MB). The files are imported together, and each one is named after its file name in the Library. An entry that is text rather than an attached file (a file name, a description, a placeholder such as "uploaded image", or a link) is refused on its own, and the others are still imported. Returns files, one entry per file in the order given: index, and frameo_url (accepted anywhere a Frameo link is), kind, bytes and name, or that file's own error and hint. Also open_in_frameo. When no file could be imported, the call fails and files still gives each one's error. The same call sent again returns the files it already imported instead of copying them twice. Each account can import 10 files a minute, links included, and one call takes at most about 50 seconds. A refused file that still carries frameo_url is stored, or is still being copied there, and add_upload_to_library can file it later.

import_attachments

Copy images, videos or audio from public web links into Frameo and a project's Library. Free. Frameo fetches each file from its site itself, so this works where the client cannot send files. The links are imported together. Returns files, one entry per link in the order given: index, and frameo_url (accepted anywhere a Frameo link is), kind, bytes and name, or that link's own error and hint. Also open_in_frameo. When no link could be imported, the call fails and files still gives each one's error. The same call sent again returns the files it already imported instead of copying them twice. Each account can import 10 files a minute, attachments included, and one call takes at most about 50 seconds. source_refused means the site serves the file only to a signed-in user or a browser, or the link has expired, so the same link fails again: show_upload takes the file from the user's device, import_attachments takes it attached in the chat (ChatGPT), and the Frameo app takes any file. A refused file that still carries frameo_url is stored, or is still being copied there, and add_upload_to_library can file it later.

import_media_url

Make the person in a video speak an audio clip (lipsync). Uses the user's Frameo credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. For a person on screen who has to say exact words in a chosen voice, generate_speech makes the voiceover and this matches the mouth to it. Frameo measures both files. The result runs as long as the voiceover (the video plays back and forth when the voiceover is longer), is priced per second of that result, and is among the more expensive tools here. Returns generation ids once the work is queued; wait_task returns the result when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The result is saved in the Frameo project; the finished result's open_in_frameo link opens it there.

generate_lipsync

Find presets: short, tested prompts for camera moves, lighting, framing, product shots, effects and more, to use in an image or video prompt. Free. Before writing an image or video prompt from scratch, look here: there is often a tested preset for the shot, the camera move, the light or the effect, and it gives steadier results than an improvised prompt. Most presets are a piece of a prompt; some categories hold a whole image, a whole clip, a caption style or a line delivery, and each preset's when and notes say where it goes. Called with no arguments, it returns the categories, each with its sub-categories and counts. With query it searches, best match first, leaving out presets that match only a small part of the query; with category or sub_category it browses. Either way at most 30 presets come back, with total, the number that matched. Each entry has preset_id, title, category, sub_category, description and when to use it; get_presets returns the prompt text. A search with no match returns no presets and the categories: the library has nothing for that need. A camera move, a framing or a lighting look adds to another prompt; a product shot or an ad layout is a whole image on its own; an effect is a whole clip made from one still.

list_presets

Find the user's Frameo projects, newest first, optionally by name. Free. A project_id and module_id from here are where the generate tools put results; module_id is optional when the project has a single module. The first five matches list up to 20 modules each, with module_count and an open_in_frameo link to each module's canvas in the Frameo web app; modules_truncated is true when a project has more, and list_projects with that project_id lists them all. Later matches carry only project_id and name.

list_projects

Step-by-step Frameo skills for almost any job: films, UGC ads, photoshoots and edits. Free. There is a skill for most requests: script-to-video turns a script into a film with a consistent cast and spoken dialogue, faceless-story-video makes a narrated explainer, story or kids' song, ugc-video makes creator-style product ads, product-photoshoot makes store and ad stills, thumbnail-set makes thumbnails and covers, review-shots checks a set of shots and the finished cut, and others cover presenters, character sheets, ad remakes and re-cutting footage the user already has. Check this list before planning a multi-step job yourself: a skill sets the models, prompts, checks and order that work. Each entry has a skill_id, a title, a one-sentence summary of what it makes, when to use it, and a version. get_skill returns a skill's full instructions. The prompting guides are listed first: the rules and prompt format of each video model (video-prompting), image prompts and edits (image-prompting), voices, music and sound effects (audio-prompting) and ffmpeg commands (ffmpeg-recipes).

list_skills

List the notes a module keeps (scenes, beats, cast, assets) under a path. Free. Each module keeps a JSON tree of notes addressed by unix-style paths, such as /scenes/1/beat or /characters/lucy/voice_id. The Frameo app reads and writes the same tree, so notes kept on either side are visible to the other. Returns entries [{name, kind ("dir" or "leaf"), bytes, updated_at (top-level keys only)}], at most 200, with truncated and total when there are more. Paths start with "/" and have no empty, "." or ".." segments.

list_notes

List the media in a Frameo project's Library, newest first. Free. The Library holds everything captured for a module, whether or not it was ever placed on the canvas: every generation (from the Frameo app's agent and quick actions, from this server, from ffmpeg runs) and every uploaded or imported file. read_project differs: it reports only what sits on the last saved canvas, by shot. Each item has kind and url (a Frameo link the other tools accept), and where recorded its name, origin, tool, model, prompt (cut to 500 characters) and created_at. Each image, video and audio item has a media_id, which show_generations and show_choices take to show it on a card. counts gives the number of matching items of each kind. At most 60 items are returned per call; when more matched, truncated is true and next_cursor, passed as cursor, returns the next page. Items added after the first page do not shift later pages. open_in_frameo links to the project.

list_library

List the recurring cast of a Frameo project: each character's name, images and voice. Free. The cast is the project's saved characters: those in its Reference Library (made in the Frameo app or with save_character) and those the app keeps for the module. Each character has name, images (up to 6 Frameo image links, which image_urls and reference_image_urls accept), voice_id (a voice generate_speech takes, or null when none is set) and in_library: false for a character kept only in the module's notes under /characters (by the app or save_note), which has no images until save_character adds it to the Library. At most 30 characters.

list_characters

The image or video models this Frameo workspace offers, with each one's limits and price. Free. The answer settles which model a named request needs, what a higher-quality option costs, and which rule a refused request broke. For video: the clip lengths, aspect ratios, whether the model starts from an image, whether it takes a source clip to continue or edit (from_video) and that clip's limits (from_video_limits), which frames it takes (first, last), how many reference images and reference audio clips it accepts, and the price in credits per second at each resolution (silent and with sound). For image: aspect_ratios, max_source_images, and the price in credits per image at each resolution the model supports (text-to-image, 9:16). Some image models add credits per source image. default is the video model generate_videos and estimate_cost use when no model is given. default_resolution, when set, is the resolution they use with it when none is given. The default image model is a tested, general-purpose choice. prompting_guide is the call that reads a model's prompting guide: its limits and prompt format, read before writing a prompt for it.

list_models

Make a public Frameo share page for one finished image or video, for the Share button on a result card. Free. Returns share_url, a frameo.ai page that plays the file, shows the title, the prompt, the sharer's first name, the model, the size and the input images, and links to Frameo. Audio, a file outside Frameo's storage, and a call without generation_id have no share page: share_page is false and share_url is the file's own link. A file whose links expire after about an hour is the exception: it always gets a share page, audio and calls without generation_id included. A generation id this user did not start in this workspace in the last 7 days returns unknown_generations.

create_share_link

Show generations as options for the user to pick one, by their ids. Free. Returns immediately. In chat apps that display Frameo cards, the card shows each generation as in show_generations, with question as its heading and a "Use this" button on every finished one. Pressing it posts the user's pick into the conversation as their own message, naming the chosen link. The card uses no credits. Where cards are not displayed, only the result below comes back. The result is get_task's snapshot of those ids, without image previews.

show_choices

Make a one-time link that opens a page of the Frameo web app signed in as this connection's user and in its workspace, for the Open in Frameo button on a result card. Free. Returns url, a Frameo link that signs in once and within 60 seconds; after that it still opens the destination, without signing in. Each connection makes up to 10 a minute.

create_handoff

Quote the Frameo credits a generation will cost. Free. Required before any generate tool. Returns the credits the generation will cost, a quote_id the matching generate tool redeems, and settings, what was priced. A quote is single-use, valid for 15 minutes, and bound to the settings and project it priced. The generate tool redeems it alongside confirmed_by_user, which records that the user has seen those credits and agreed to them. A generate call whose settings differ from the quote, or with confirmed_by_user false, is refused uncharged and leaves the quote valid. The same generate call sent again returns the work it started, marked replayed, at no charge; the quote sent with other arguments is refused with quote_used, which names that work. Never take a new quote to recover a call whose outcome is unclear. prompting_guide, when present, is the call that reads the prompting guide for what was priced, read before writing its prompt. Several generations can be priced at once with items. credits_available is the workspace's balance at the time of the quote (the member's own limit where the workspace sets one), when Frameo reports it. When the quote costs more, short_by is the difference and account_url links where credits are managed; the quote is still issued, and a generate call the balance cannot cover is refused with out_of_credits, uncharged, and its quote is used; a retry takes a new quote. With items, the result has one entry per item in quotes, in order, each with its index and either its own quote_id and credits or its own error. total_credits adds up the items that were quoted, and credits_available, short_by and account_url compare the balance with that total. Each quote_id is redeemed on its own, so any of the items can be generated and the rest left to expire.

estimate_cost

Read the note at one path of a module's notes, such as a scene, beat or cast entry. Free. Each module keeps a JSON tree of notes addressed by unix-style paths, such as /scenes/1/beat or /characters/lucy/voice_id, shared with the Frameo app. Returns value, the JSON at path. A value over 50 KB is refused with value_too_large, except a string, which comes back cut to 50 KB with truncated: true. A string like "$state:/assets/<id>/url" points to another path in these notes: read that path for the value. Other tools take the value itself (such as a Frameo link), not the pointer. Paths start with "/" and have no empty, "." or ".." segments.

read_note

List what is already on a Frameo project's canvas: images, videos and audio, by shot. Free. This is what existing work looks like before something is built on it, as in "animate the second shot" or "add a voiceover to that clip". Every item carries a url: the direct link to its image, video or audio file, which opens or plays in a browser and which the other tools accept as input, and a media_id, which show_generations and show_choices take to show it on a card. The result's open_in_frameo link opens the whole canvas in the Frameo web app. At most 60 items are listed; truncated is true when there are more, and counts covers them all. It reports the last SAVED canvas. The app saves as the user works, so a result produced moments ago is missing until the user has opened the project and it has been placed. recorded_just_now lists up to three of the user's earlier results for this project that are not on the saved canvas yet (for example from another connection), with their media links; they appear there the next time the project is opened.

read_project

Get working links again for Frameo media whose links have stopped opening. Free. Media links from Frameo tools open for about an hour after they are returned; a result that holds them says until when in links_expire_at. This returns a working link for each one given, in the same order, and links_expire_at for the new ones. A link that does not expire comes back unchanged. An expired link still works as input to every Frameo tool, so a fresh one is only needed to open the file or hand its link to someone. A link that lasts comes from the Share button on a show_generations card, in chat apps that show cards.

refresh_media_links

The Frameo home card's refresh of the newest projects. Free. Returns immediately. Chat apps that show Frameo cards hide it from the model; elsewhere it returns projects as open_frameo does: the newest first, each with project_id, name, module_count, its first module with an open_in_frameo link, and recent, that module's latest images and videos (for the newest six only; later projects carry an empty recent).

poll_home

The balance widget's check. Free. Returns immediately. Chat apps that show widgets hide it from the model; elsewhere it is the same as show_balance, but read fresh, so a change in the balance shows at once.

poll_balance

The Frameo gallery card's progress check. Free. Returns immediately. Chat apps that show Frameo cards hide it from the model; elsewhere it is the same as get_task without image previews. Takes the same generation_ids and kind as get_task.

poll_generation

Rename a module in a Frameo project. Free. Only the name changes: the module's canvas, Library, notes and module_number stay as they are. Returns the project_id, module_id, the new name and previous_name.

rename_module

Rename a Frameo project. Free. Only the name changes: the project's modules, canvases, Library and settings stay as they are. Frameo allows it to the project's owner and managers; another role is refused with not_permitted. Returns the project_id, the new name and previous_name.

rename_project

Render a short motion-graphics clip from one of Frameo's templates: a title card, a lower third, caption lines, an end card, a countdown, or kinetic text. Free. The text is rendered by a browser, so it is exact; Frameo writes the whole page from the template — no HTML is accepted. Returns a run id for wait_task. Where the chat app shows cards, show_generations with these run_ids shows the work to the user. The clip is recorded in the module in Frameo and placed on the canvas: live when the project is open, otherwise the next time it is opened. In one module these runs (ffmpeg, motion graphics, HTML scenes, media analysis) go one at a time: while one is in progress, another started in the same module is refused with module_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.

render_motion_graphics

Render HTML pages you write into videos, GIFs or stills: animated titles, kinetic type, lower thirds, captions, stat cards, layouts with exact text, transparent overlays. Free. It works only in workspaces where it is turned on. Each page must: 1. Load GSAP in <head>: <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>. The only other script files allowed are gsap@3.14.2/dist/SplitText.min.js and lottie-web@5.13.0/build/player/lottie.min.js from the same CDN. Put all other code inline. 2. Have one root element with data-composition-id="main", data-width, data-height, data-start="0" and data-duration, and size body and root to width x height px. 3. Give each timed element class="clip", data-start, data-duration and data-track-index (higher is on top). 4. Drive all motion from one paused timeline: const tl = gsap.timeline({paused: true}); then window.__timelines = window.__timelines || {}; window.__timelines["main"] = tl; CSS animations, timers and anything off the timeline do not render. Use tl.set for instant changes. 5. Be deterministic: no Date.now(), Math.random() or fetches. Images, video and audio come only from Frameo links. The page reaches no other site. A video layer is a muted <video>. Installed fonts: Inter, Poppins, Montserrat, Oswald, Jost, Archivo, Space Grotesk, Playfair Display, Bebas Neue, Anton, Outfit, Ubuntu and Noto (with the Indic scripts). Load other Google Fonts with their fonts.googleapis.com <link>. The root shows only a flat background-color. Put a gradient on a child. Independent scenes (the parts of a long video) start together in one call: run_ids holds one id per scene, in order. A scene that needs another's output goes in a later call. wait_task returns each file as a Frameo link. Where the chat app shows cards, show_generations with these run_ids shows the work to the user. mp4, gif and stills are also placed on the module's canvas; a webm overlay is not. In one module one call's runs are in progress at a time, and module_busy is retryable.

render_html_scene

Run ffmpeg commands on Frameo media in a project: trim, join, resize, crop or pad, change speed, adjust brightness, contrast or colour (eq), overlay, mix in a voiceover or music, burn captions, extract audio. Free. Each job is the caller's own command line (argv), run against a private workspace holding its inputs and sidecars; its declared outputs come back as Frameo links. A job runs in a sandbox: no network, workspace files only, a time limit, at most 10 inputs and 4 outputs. An .ass sidecar with the `ass` filter renders text captions more reliably than drawtext. jobs holds 1 to 5 independent jobs, started together and run side by side. Returns run_ids at once, one per job in the order given; wait_task and get_task read each job's result, which is also recorded in the module, and placed on its canvas once the project is open. Where the chat app shows cards, show_generations with these run_ids shows the work to the user. A job that needs another's output goes in a later call, once that one has finished. Tested commands, the rules every job follows and what each failure means: get_skill("ffmpeg-recipes"). In one module one call's runs are in progress at a time: while they run, another run started in the same module (ffmpeg, motion graphics, HTML scenes, media analysis) is refused with module_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.

run_ffmpeg

Save a character to a Frameo project's cast, so later work reuses its look and voice. Free. The character is added to the project's Reference Library as the Frameo app adds one, and shows in the app's character panel. A name already in the cast is not added again: its voice is set when given, its images are left as they are, and the result says so (saved false).

save_character

Save a sound from search_sound_effects into a project's Library. Free: nothing is generated. Finishes at once and returns the sound's name, its audio_url and open_in_frameo, the project's link in Frameo.

add_sound_to_library

Save a top-level note in a module (scenes, cast, a shot list). Free. Each module keeps a JSON tree of notes, shared with the Frameo app (list_notes and read_note read it). Only the module's own notes are written; the project-level notes and other modules are read-only. Each entry under /characters is also listed by list_characters as a character of the project, named by its name field or its key, with no images until save_character adds it. A key that exists is refused with top_level_key_exists, except an object onto an object, which merges; overwrite_existing replaces the whole value. /assets holds Frameo's own records and cannot be saved over. The result has path, bytes (the size of the top-level value afterwards) and created (true when a new top-level key was made, which can mean a mistyped path); corrections lists any input Frameo repaired, such as a list stored as keyed objects. Writes in one module apply one at a time; while an ffmpeg, HTML-scene, motion-graphics or media-analysis run is in progress there, a save is refused with module_busy, which is retryable. A save not finished within about 20 seconds returns status running with run_ids, and wait_task reads its result.

save_note