MCP
Bring your own agent.
Tonta ships a Model Context Protocol server so a customer's own agent — Claude, ChatGPT, Cursor, or anything else that speaks MCP — can plan, see, change, price and run real work from inside a conversation, with every creative system the web app has.
Who this is for
Anyone who already lives inside an agent and would rather ask for a reel than open a web app. A connected workspace works from Claude Code, Claude Desktop, ChatGPT, Cursor, VS Code, or any MCP client that supports Streamable HTTP — no code required on your side.
What your agent can do
Every system, chosen from the goal
Video, pictures, audio, motion design, Recast and app walkthroughs are all reachable. create reads the brief and works out which systems the piece needs, combines them in one plan and prices each system on its own line, so your agent can take one off and see what that saves.
createdescribe_capabilitieschange_piece_systems
It sees the work
The storyboard, your references and finished shots arrive as small captioned pictures next to the facts, so an agent that can look at images reviews the actual frames rather than a list of ids. Pictures are previews of your own material and never carry a link.
get_storyboardlist_referencesget_job_activity
Change the storyboard in words or exactly
Ask for a change in plain words and review the proposal before applying it, or make precise edits in one batch: move, lock or retime a shot, swap a model, choose a narrator or a character's voice. Each batch is one new version with its price change, and earlier versions can be compared or restored.
propose_storyboard_changesapply_storyboard_changesedit_storyboardcompare_plan_revisions
Cheaper and better options that fit the plan
Alternatives are only models that can do what the shot needs, with what each one costs and what it changes. Applying one is a new version, never a silent swap.
list_plan_alternativesapply_plan_alternative
27 interactive apps inside the conversation
In clients that show interactive apps, results open as views: the storyboard as a board you can rearrange, lock, retime and ask to change, voices with samples to play, models to choose from, an itemised quote, the job monitor, your library, a question card, the calendar and more. They can look and make changes that spend nothing, but none can start or spend: starting stays a step you take in the conversation or on the web.
get_storyboardlist_voicessearch_modelsget_quoteget_production_stepslist_library
Live updates and readable resources
Jobs, storyboards, shots, versions, references and a project's cast and bible are readable resources. Clients that support subscriptions are told when a storyboard or a run changes; the others wait with wait_for_job, which holds the call open, reports progress while the work runs and says what to do next the moment it finishes.
wait_for_jobget_plan_runlist_plan_revisions
It looks at and listens to your files
Your agent can inspect any file in the library: a picture as an image, a video as frames with their times, its length and whether it has sound, a recording as its length and transcript, a document as its text. Looking spends nothing.
inspect_assetlist_library
It knows what is new
Tonta keeps adding tools and features. whats_new lists what shipped recently, from the same changelog you read on this site, so a connected agent learns about a feature the day it arrives.
whats_newsearch_tools
Schedules and publishing, with a person in charge
An agent can draft a schedule, add topics, check its runway and schedule a post. Approving a schedule, approving what goes out to your accounts and recording consent stay with a signed-in person.
list_automationsadd_schedule_topicsget_schedule_runwayschedule_post
Free-form motion, written by your agent
When a block cannot say it, your agent writes the motion as a short program. It runs once in a sealed sandbox and becomes data we check, price and render like our own work, with exact errors and low-resolution previews on the way.
get_motion_skeletonlookup_motion_patternvalidate_motionpreview_motion_framesestimate_motionattach_motion_composition
Stills before clips
Ask to review the stills and the run stops after them. Your agent sees each shot's candidates as pictures, picks one per shot and lets the run carry on; making a still again is quoted first.
get_storyboardpick_stillestimate_frame_regeneration
Frame sets: frames now, video later
Ask for the frames of a video without the video. Your agent can reorder, replace or take out frames, export them with a timeline file, and later price a video from them or open them on the timeline.
list_frame_setsget_frame_setreorder_frame_setreplace_frameexport_frame_setestimate_frame_set_videoopen_frame_set_as_composition
Edit a finished piece on its timeline
Read a piece's tracks and clips and change them in batches of edits that spend nothing: trims, freezes, reverses, masks, keyframed motion, overlays and a clip's own sound. Your agent sees the frames exactly as the render draws them, corrects what is off, and can pick up or discard an unfinished edit later. Rendering costs nothing up to a daily allowance once the workspace has paid; anything an edit generates is quoted first.
get_compositionedit_compositionget_composition_frameslist_clip_actionslist_compositions_in_progressdiscard_composition_editslist_composition_revisions
Parts, one or many
Make the things a video is made of rather than a finished piece: a clip, pictures, a voiceover, music, a sound effect or a 3D model, or N variations as one job. The quote has one line per item, and an item that does not finish is not charged.
generate_partgenerate_parts_batchget_partlist_parts
Edit a file you already have
Upscale a picture or a clip, remove a background, extend a picture, reframe a clip or change a voice. Your agent sees what can be done to the file and with which models, and gets a quote before anything runs.
list_asset_operationsestimate_asset_operationget_asset_operation
What this connection can never do
Not policy on a page — the server has no code path for the things below. An agent connected here is bounded structurally, not by a setting someone could forget.
Workspace comes from the token, never an argument
No tool takes a workspace id. A tool that accepted one would be one prompt injection away from cross-tenant access — so that argument simply doesn't exist on this surface.
Spending always goes through a quote
There is no tool that takes a brief and a budget. create — the tool your agent reaches for first — classifies the brief, fills in the settings and returns a single-use, five-minute quote the same way estimate_job does; submit_job requires it. Unpriced spending isn't guarded — it's unrepresentable.
No agent's claim of approval is ever accepted
There is no confirmed: true parameter, because a parameter an agent can set is a parameter an agent will set. Above your confirmation threshold, Tonta never asks inside the assistant's conversation: the job is parked and the assistant gets a web approval link. You open it, sign in and approve it yourself, and only then does it run.
Money writes and impersonation are absent from the surface
Buying credits, changing a plan, deleting a workspace or a member, reading another workspace's anything, and any staff operation are not permission-checked here — they simply aren't reachable from this server.
Every call is audited
Actor, connection, tool, arguments, quote, cost and result are recorded on every call — the same trail a human console action leaves.
Bounded by a cap you set, independent of your plan
Each connection carries its own per-job and daily spend cap, editable from Settings. A confused or compromised agent is bounded by a number you chose, not the whole workspace's plan. An owner may pre-approve an API key up to an amount per job and per day; that is a person's standing yes, set while signed in, and never something an agent can grant itself.
Consent and publishing approval stay with a person
Recording consent for a voice or a likeness, approving a schedule and approving what goes out to your social accounts are not tools. An agent can prepare all of it; a signed-in person says yes.
Pictures and briefs are content, not instructions
Text in a brief, a caption or inside a picture is treated as material to work with. Every app shows it as plain text, none can call a tool that spends, and the server refuses to load an app that ever could.
Free-form motion
Write the motion yourself. We run it safely.
When a block cannot say it, your agent can write the composition as a short JavaScript program against our motion runtime. It runs once, in a sealed sandbox, and becomes plain data we check, price and render like our own work.
Write it free-form for
- Kinetic type timed to the beat or to the words of a voice-over
- A logo sting or brand animation no block expresses
- A data reveal with your own numbers
- A product shown on a turning 3D plane, or a simple 3D scene
- Shader backgrounds and particle fields in your brand colours
- A walkthrough choreographed over your own screenshots
- A Lottie you already have (an icon, a sticker), played frame-exact
- A reusable template: swap the words, colour and logo without touching the program
Let blocks do
- Standard titles, lower thirds, captions and end cards
- Anything that needs a generated picture or clip inside it
- Video footage inside the composition (free-form shows stills)
- Pieces longer than 60 seconds, or at 60 fps
The loop
- 1
get_motion_skeletonA composition that already builds: scenes on the beat or on the voice lines, the safe area, your references, and the runtime reference. - 2
lookup_motion_patternFifteen vetted worked examples to adapt: kinetic type, logo sting, lower third, charts, product in 3D, map route, split screen, countdown, quote card, UI walkthrough and more. - 3
measure_textYour brand fonts' real metrics: the width and line breaks of your words, or the largest size that fits a box. - 4
get_beat_and_word_timingThe beat grid and the voice-over word timings a draft composes against, each saying whether it is measured or estimated. - 5
validate_motionRuns the program and checks the result. Exact errors, each with a code, the line, the element and a fix. - 6
preview_motion_framesUp to four low-resolution stills at the times you choose, through the same renderer as the final render. No charge. - 7
estimate_motionThe render's price per stage and per second of output, its effects class, and the render-time cap. - 8
attach_motion_compositionPuts it on a draft. Then resume_draft for the quote and start_job to run it. Nothing is spent before that.
Your program never reaches the page
It runs once, before rendering, and returns data. Our compiler turns that data into the page, with every word escaped, so nothing you write is ever executed where the video is drawn.
A sealed sandbox
No network, no files, no clock, no eval, no modules. A fresh interpreter for every build, with a hard time, memory and stack budget, and nothing shared between builds.
The same rules as our own work
Our own motion author goes through the identical sandbox, checks, caps and quote. An agent's program gets no path ours does not.
Priced before it runs
The quote binds to the exact program and result that were checked. If anything changes, it is checked and quoted again.
In time with the sound
On the beat
Beats and bars are re-timed at render to the music the piece really has, measured from the track. Every beat-timed moment lands within one frame of it.
On the voice
Lines follow the measured read of the voice-over, each line starting on a real pause; the words inside a line are spread by length. Word-by-word timing is estimated within each line.
Sounds on the cut
Sound effects you place move with the timing, so an impact still lands on its cut.
The price does not move
The quote is for your program, not for the seconds it lands on. If the music has no steady pulse, or there is no voice-over, the timing you checked is the timing that renders.
Bring a Lottie and it plays frame-exact, through a player with no expression engine. Expressions are refused because they are code: bake them into keyframes before exporting. Pictures inside a Lottie must be your own references; font files and 3D or audio layers are refused.
Hard limits
- Length and frame
- 1–60 seconds · up to 1080p · 24 or 30 fps · every aspect ratio
- Program
- 64 KiB · builds in 2 seconds and 48 MiB
- Elements
- 160 elements · 1,200 particles · one 3D scene of 24 objects · 2 shader layers
- Pictures
- Up to 12 of your own stills, by id — never a URL
- Render
- The priced render may not exceed 7 minutes of rendering
- Preview
- Up to 4 frames at 360 px, 20 an hour, no charge
- Lottie
- 2 per composition · 200,000 characters · 3,600 frames · 120 layers · no expressions
- Sound and templates
- 16 sound cues from the piece's own effects · 16 template parameters
- Sync
- Beats, bars and voice lines re-timed to the measured audio, within one frame
Free-form renders are priced like every motion piece: by the seconds of output and the effects they use. Standard motion, detailed effects (particles, a Lottie, very busy pages) and 3D effects (a 3D scene, a shader layer or a shader transition) cost progressively more to render, and the estimate says which applies and why.
Authentication
OAuth 2.1 with PKCE, in the browser. You authorise Tonta for one workspace the first time a client connects; access tokens are short-lived and refresh tokens rotate, and reusing a rotated token revokes the whole family. A client Tonta has never seen can still connect through Dynamic Client Registration (RFC 7591), so nobody registers it by hand. For a client that cannot run a browser sign-in, the same server also accepts a workspace API key as a bearer token, with that key's scopes and daily spend limit.
Connect a client
Claude Code
One command.
claude mcp add --transport http tonta https://tonta.media/api/mcpClaude Desktop / Cursor
Paste into claude_desktop_config.json (or .cursor/mcp.json), then restart.
{
"mcpServers": {
"tonta": { "type": "http", "url": "https://tonta.media/api/mcp" }
}
}ChatGPT / anything else
Settings → Connectors → Add connector → paste the URL.
https://tonta.media/api/mcpServer URL: https://tonta.media/api/mcp — the same one every client above uses.
What it looks like
You
Using Tonta, what would a 30-second faceless reel about home espresso cost, before you make anything?
Your agent
I'll estimate that with Tonta first. Three shots, cinematic preset, 9:16 — the quote comes back at $2.14 and is good for five minutes. Want me to submit it?
You
Yes, go ahead.
Your agent
Submitted. I'll watch it — plan is done, shots are generating now. I'll show you the cut here as soon as it's ready to review.
Not only reels
Review and change a storyboard
“Show me the storyboard. Move the logo shot to the end, keep the oven shot as it is, and give the narrator a warmer voice.”
The agent shows the frames, then sends the three changes as one edit: a move, a lock and a voice. That makes one new version with its price change, and resume_draft returns the fresh quote for you to approve.
get_storyboardlist_voicesedit_storyboardresume_draftOne piece, several systems
“Introduce our app to new users: use this screen recording and our logo, pull the facts from our site, and add animated titles.”
create works out that the piece needs an app walkthrough, motion design and a voiceover, combines them in one plan and prices each one. Drop a system with change_piece_systems and the agent tells you what that saves.
request_uploadconfirm_uploadcreatechange_piece_systemsA 3D model
“Make a 3D model of a ceramic espresso cup from this product photo.”
The agent uploads the photo, calls create with service model3d_generation and the photo as sourceAssetId, and shows you the quote. After you approve it, submit_job runs it and you get a 3D preview to look at before anything else happens.
request_uploadconfirm_uploadcreatesubmit_jobNarration and audio
“Record this script as a warm, unhurried voiceover and give me a matching music bed.”
The agent reads the voices you can choose from, calls create with your script, and shows the quote. Narration is priced from the script's length, so the price comes after the text exists. submit_job runs the quote you approve.
list_voicescreatesubmit_jobA transcript from a recording
“Transcribe this interview.”
The agent uploads the recording, calls create with it as sourceAssetId, and waits with wait_for_job. When the job finishes, the transcript is its result.
request_uploadconfirm_uploadcreatewait_for_job
Every tool your agent can call
Read straight from the same contract the server is generated from — 305 tools today. No schemas dumped here; your MCP client reads those directly from the server on connect.
Read (158)
Act (147)
Connect a client
Sign in, open Settings → Integrations, pick your client and paste one line. You authorise Tonta for your workspace in the browser the first time it connects, so no secret goes in a config file.
Connect in Settings