Frameo

Generate a new one-shot sound effect in a Frameo project. Uses the user's Frameo credits. 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. A wait_task timeout leaves the work running and the ids valid. The sound is saved in the Frameo project.

generate_sound_effect

Start a video generation in a Frameo project. Uses the user's Frameo credits. Text-to-video by default. first_frame_url makes the clip open on that image; reference_image_urls instead carry a character, product or look into a new shot. On Seedance models (the default among them) a first frame is run as the lead reference image: the clip opens on it but renders at the requested aspect_ratio, the frame and references can be passed together, and the frame counts as one of the model's reference images. On every other model the clip takes the first frame's own shape, and a call carrying both a frame and references is 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 when it is ready. On Seedance models, reference images (and a first frame) are prepared before the video starts, and an image's first use can add a short wait. references_registering means that preparation 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; the finished result's 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. Returns generation ids once the work is queued; wait_task returns the audio and its duration_seconds when it is ready. A wait_task timeout leaves the work running and the ids valid. The voiceover is saved in the Frameo project.

generate_speech

Start an image generation in a Frameo project. Uses the user's Frameo credits. 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. Returns generation ids once the work is queued; wait_task returns the images when they are ready. 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

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), what the user gets, and the names of its reference files, readable with get_skill_file.

get_skill

One reference file of a skill (a prompt pattern, a shot-list template, a caption style), named in get_skill's `files`. Free.

get_skill_file

Copy an image, video or audio file from a public web link into Frameo and a project's Library. Free. Frameo fetches the file from the site itself, so this works where the client cannot send files. Returns frameo_url (accepted anywhere a Frameo link is), kind, bytes, name and open_in_frameo. Each account can import 10 links a minute, and one import takes at most about 50 seconds. A refusal carries error and a hint. Two cases: source_refused means the site serves the file only to a signed-in user or a browser, and the file can be added in the Frameo app, or sent through create_upload_url by a client that can send files; a refusal that still carries frameo_url means the file 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. Lipsync is priced per second of video 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. 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 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 their modules, each with an open_in_frameo link to that module's canvas in the Frameo web app. Later matches carry only project_id and name.

list_projects

Step-by-step Frameo skills for videos, UGC ads, photoshoots and more. Free. Two kinds: `workflow` (several tools, minutes to an hour: a script into a video, a UGC review, a product photoshoot) and `recipe` (one generation with a proven prompt pattern: a hero shot, a product spin). kind filters to one of them. Each entry has an id, a one-sentence summary, what the user must bring (`needs`), a rough credit range and time. get_skill returns a skill's full instructions.

list_skills

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. 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, by the app's agent, or with save_character) and those the app's agent 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 the app's agent has only voiced, which has no images until save_character adds it to the Library. At most 30 characters.

list_characters

The image or video models Frameo 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, how many reference images it accepts, and the price in credits per second at each resolution (silent and with sound). For image: max_source_images, and the price in credits per image at each resolution the model supports (text-to-image, 9:16), plus the shared aspect_ratios. Some image models add credits per source image. The default video model is Seedance 2.5; the default image model is the cheapest sensible choice.

list_models

Make a public Frameo share page for one finished image, video or audio file, for the Share button on a result card. Free. Returns share_url, a content.frameo.ai page that plays the file and links to frameo.ai. A file outside Frameo's production storage has no share page: share_page is false and share_url is the file's own link.

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. reference_count: the number of source images the generate call will pass -- image_urls for kind="image" (0 for text-to-image), reference_image_urls for kind="video". Some models charge per source or reference image, so the quote is bound to that count. first_frame: for kind="video", whether the generate call will pass a first_frame_url. It does not change the price; it lets the quote refuse up front what the generate call would (on Seedance the frame is one more reference image, so with a frame the most is one fewer). count: images per call, which is 1. kind: "image", "video", "lipsync", "upscale", "speech", "music" or "sound_effect". Pass the same settings and project you will generate with; a changed request needs a new quote. resolution, generate_audio and model apply to video only; resolution omitted is the model's lowest tier. duration (seconds) applies to video, lipsync, upscale, music and sound_effect. For lipsync it is the length of the source video, which is what it is priced by. text applies to speech, music and sound_effect: the words to speak, or the music / sound prompt. All three are priced by the length of that text, so the generate call's text has to cost the same. voice_id applies to speech only. Returns the credits the generation will cost, and a quote_id the matching generate tool redeems. 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 plans_url links Frameo's plans page; the quote is still issued, and a generate call the balance cannot cover is refused with out_of_credits, uncharged. A quote is single-use, valid for 15 minutes, and bound to the settings it priced. The generate tool redeems it alongside confirmed_by_user, which records that the user has seen those credits and agreed to them. settings lists what was priced. project_id / module_id: the project and module, from list_projects. project_id is required; module_id is optional when the project has a single module. items: several generations priced in one call, up to 10, in place of kind and the settings above. Each item takes those same settings, priced exactly as a single call prices them; an item without project_id uses the project_id and module_id given alongside 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 plans_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

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. 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 had not been added yet (for example from another connection), with their media links; they appear on the canvas the next time the project is opened.

read_project

The Frameo balance card's check. Free. Returns immediately. Chat apps that show Frameo cards hide it from the model; elsewhere it is the same as show_credits, read past Frameo's short balance cache so a purchase shows at once.

poll_credits

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

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. The clip is recorded in the project's Frameo chat 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, media analysis) go one at a time: while one is in progress, another started in the same module is refused with chat_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.

render_motion_graphics

Send a report to the Frameo team about Frameo: something that went wrong, works badly or is missing. Free. Problems with these tools are a common case: a tool error, a wrong result, a stuck task or a misleading tool description. A report can come from the user, who asked for it, or from the assistant on its own when it meets a problem; trigger records which. A refusal whose hint explains it, such as an empty wallet, an expired quote or an argument the tool rejected, is Frameo working as intended rather than a problem. The team receives the title, description and type with the account, workspace, assistant app, project and module, and this connection's tool errors from the last hour. Nothing else from the conversation is sent. Returns report_id, which the Frameo team can look the report up by.

report_problem

Run an ffmpeg command 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. The command line is the caller's own (argv), run against a private workspace holding the inputs and sidecars; the declared outputs come back as Frameo links. The job runs in a sandbox: no network, workspace files only, a time limit. Returns run_ids at once; wait_task and get_task read the result, which also lands in the project's Frameo chat, and on its canvas once the project is open. An .ass sidecar with the `ass` filter renders text captions more reliably than drawtext. In one module these runs (ffmpeg, motion graphics, media analysis) go one at a time: while one is in progress, another started in the same module is refused with chat_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run. A run takes at most 10 inputs and 4 outputs. Each user has 30 runs per hour across run_ffmpeg, render_motion_graphics and analyze_media.

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. The sound is saved to the project's Library.

add_sound_to_library

Search Frameo's library of ready-made sound effects. Free. A library sound is instant and free, where generate_sound_effect costs credits and takes time. Each result has an `id` to pass as sound_id to add_sound_to_library, and an `audio_url`, the sound file itself, which plays in a browser. An empty result means the library has nothing matching.

search_sound_effects

Find voices for generate_speech in the user's Frameo voice library. Free. The filters (gender, age, language, accent) are exact matches, so a guessed value returns nothing rather than a near miss. Returns up to `limit` voices (max 20), best first, each with a voice_id for generate_speech and, when Frameo holds a recording of the voice, a sample_url that plays it in a browser. Voices cloned in the workspace are included, marked cloned: true, with yours: true on the user's own clones and false on other members'. The user's own clones rank ahead of other voices when there is no query or the query matches them.

search_voices

Show generations to the user as an interactive card in the chat, where the chat app supports MCP Apps, by their ids. Free. Returns immediately. A generation takes seconds to a few minutes, and a whole job tens of minutes. The card is shown as soon as the work starts: the user watches each generation's progress live and every result as it lands. It is for the user only; wait_task is how the assistant gets updates and results. Called before wait_task, the card shows progress while wait_task waits. A card covers one wave of work: every generation or run started before the next wait_task, shown once with all their ids before that wait. The same ids appear again only as the finished result (final true). A single quick call needs no card. One card covers the generations running at the same time, up to 24 ids from any generate or run calls, in one call. A single id makes a complete card when it is the only generation running. Each call adds a new card, so generations running together but shown one call at a time stack separate cards in the chat. Without MCP Apps support, only the result below comes back. The result is get_task's snapshot of those ids, without image previews. With final, the card offers Download and Share on each finished item.

show_generations

Move this connection to another workspace the user belongs to, by its id from whoami's workspaces. Free. From the next call on, every tool works in that workspace: its projects, Library, voices and characters, and its credits are the ones spent. Quotes from estimate_cost that were not yet redeemed are discarded, since they priced work against the previous workspace. Runs started before the switch belong to the workspace that started them: get_task and wait_task report run_not_found for them, and their results are recorded in that project's chat only once the connection is switched back, within 7 days of the run starting. Returns the workspace now active and its credits.

switch_workspace

Open a card where the user picks files from their device to upload to Frameo. Free. In chat apps that display Frameo cards, the card sends each picked file straight to Frameo storage through create_upload_url, files it in the project's Library through add_upload_to_library when a project is given, and then posts the files' frameo_url links into the conversation as a message from the user. Those links are accepted anywhere a Frameo link is taken. Where cards are not displayed, nothing is uploaded and only the result below comes back. Returns accepts, the file extensions taken with each one's kind and size limit in MB, and the project_id and module_id the files go to, if any.

show_upload

Make a video sharper and higher resolution. Uses the user's Frameo credits. Upscaling is priced per second of video, and is normally the last step, applied to finished clips. Returns generation ids once the work is queued; wait_task returns the result when it is ready. 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.

upscale_video

Wait for generations and runs to finish, then return the result. Free. Blocks for up to timeout_seconds (max 50), polling internally, and returns the same shape as get_task. Work longer than that window returns with status 'running': it is unaffected, and the same ids can be waited on again until it reports 'finished'. In chat apps that show cards, the user sees this work only on a show_generations card: without one on these ids, they see nothing while it runs, and a whole job (a batch of clips, a cut) takes tens of minutes across many wait_task calls.

wait_task