Local video studio for your coding agent: scenes, voice, music and captions, on your machine.
io.github.FavioVazquez/showtime (MCP) Server
This MCP server provides a local video studio for a coding agent. It supports creating scenes along with voice, music, and captions, all running on your machine. The server is described as focused on video production components needed for agent workflows.
🛠️ Key Features
Local video studio functionality
Scene creation support
Voice, music, and captions included
🚀 Use Cases
Producing agent-generated videos on the local machine
Adding spoken voice, background music, and captions to scenes
The 0.4.1 showreel: 55 seconds, rendered by showtime 0.4.1 in 2 min 23 s on a 64-core CPU with no GPU; seven real showtime films, then the features behind them (about the film). Download the showreel (full quality, 107 MB). Music: “Supernova” by Scott Buckley, CC BY 4.0. Footage: NASA (public domain); photo: “Godafoss 3” by Tord Dellsen, CC0 (credits).
A local video studio for your coding agent. Describe a video. Your agent directs. Your machine renders.
Motion graphics, voice-over, music, sound design, captions, footage editing and platform exports,
with no cloud AI services, no API keys and no uploads. Works in Claude Code, Codex, Cursor, Devin,
OpenCode and any agent that supports Agent Skills.
New here? Make your first video: a 5-second test that checks the install and shows
every step a bigger video goes through.
1. Install the two prerequisites (details in Requirements):
uv and Node.js 24 or 22 LTS (20 or newer works).
Restart your coding agent afterwards so it sees them.
Using Codex, Cursor, Devin, OpenCode or another agent? Works with has the exact
install for each, and npx skills add FavioVazquez/showtime covers any agent that supports Agent Skills.
3. Ask for a video:
text
Make a 20-second launch video for this repo, with a voice-over and upbeat music.
The first time, your agent checks what is missing, tells you the download size and time (about
0.5 to 0.75 GB to download and 1.4 to 1.8 GB in ~/.showtime once installed, depending on your system,
usually 2 to 6 minutes; outside that folder only uv's and npm's download caches change) and runs setup once
you say yes. If your agent's sandbox blocks the download, run setup once in a terminal
(Troubleshooting). Bigger pieces (the
transcription model, Manim, music tracks) come the first time a video needs them, announced with their size. After
that, a request in Claude Code looks like this:
An illustration of a session in Claude Code; other agents show the same steps in their own style. The card's figures are example 01's; render time depends on your machine.
Your agent states its assumptions in one line (it asks only when a request is genuinely open), shows you a
first look (stills or a fast draft) before the full-quality render, then checks the result with
showtime qa. Every request gets its own folder, showtime-out/<name>-<timestamp>/, with final.mp4,
poster.jpg, share.txt, exports/ and work/. Nothing is ever overwritten. Questions about cost, GPUs, disk,
languages or what leaves your machine: the FAQ. Something went wrong:
Troubleshooting. A word you don't know: the glossary.
TIP
Two separate settings. Quick or studio decides how much your agent asks before building: quick (the
default) states its assumptions and starts; studio (say "show me options first") shows a concept, a look, a
music bed and a storyboard on a local board first. Quality or lean decides how much it checks afterwards:
quality (the default) has a critic review every finished video; lean skips the critic unless the video is going
to be published. Say "no crew" to keep the whole job in one session.
What's new in 0.4.6 (the list is below, and What's new has a short
paragraph for each):
check reads the text a page draws on its own canvas. Text outside the phone's safe box, text too small to read
and text over other text are found between its samples and on any canvas, not only the film API's.
X-ray on a phone and in sync. At 9:16 the sound strip and the part labels sit where a phone shows them, a new
16:9 project passes its own check, and with "xray".offset_frames the strip and the piano, drums and guitar follow
the recording's clock.
Fixes.export html --interactive packs a page's own fonts, xray verify reads the marker on a draft render,
installed files match the repository byte for byte, and setup --home brings its own ffmpeg.
What's new in 0.4.5 (the list is below, and What's new has a short
paragraph for each):
X-ray from data and from a recording.showtime xray import turns event times measured in a data stream into a
film; xray analyze takes a WAV with no picture.
A live page that says what it knows. How the events were measured, your own steps, and what sharing the page
shares.
A shorter skill router. Six families instead of one row per feature, with a routing eval for contributors.
Safer and smoother.footage trim -o writes the file you name, the embed takes only safe addresses, and living
diagrams type properly on a phone.
What's new in 0.4.4 (the list is below, and What's new has a short
paragraph for each):
X-ray. Film a real thing doing its thing and showtime draws its inside on the frames its own sound says; a score,
a guitar tab or a drum sheet from the sound; a receipt that reads the finished film back.
A live page you play. Pads that play the real clip with its sound, your keyboard typing on the typewriter, drag to
scrub, #hit4 links, the request that made it, and an embed.
Living diagrams you touch. Type on a typewriter, follow a key press to the screen, drag the heat pump's weather.
What's new in 0.4.3 (the list is below, and What's new has a short
paragraph for each):
Living diagrams.showtime new diagram explains a system over time as an isometric figure that builds
itself: parts arrive in the order that explains them, and flows, packets and labels move through them.
Live figures.showtime export html <project> --interactive turns the same scene into one offline page
people poke: hover a part, pick a step, turn a knob, and the numbers answer
(try one).
A recap of your agent's session.showtime recap --latest turns a Claude Code session into a 30-60 s
narrated film of what the agent did, built only from allow-listed facts, never the transcript's text.
A failing test as a bug-report video.showtime repro turns a Playwright trace into a narrated film of the
steps and the failure, with a Markdown summary for the issue; typed values are never shown.
Steadier renders, quieter cuts. Every render worker now captures from a page set up like the first one; recap
and repro pick their music per session or test, and generated videos no longer put a sound on every cut.
On the behaviour scoreboard, 14 one-sentence requests were run 3 times each (42 runs). The
same model did the right thing 35 times with showtime and 25 times without. The cases check that it starts on
video requests and stays out of others, that it is honest about missing inputs and unsupported claims, and that it
keeps to the plan and the delivery card. Anyone can rerun it.
X-ray
Film a real thing doing its thing, a typewriter typing or a music box playing, and showtime draws its inside moving
on the exact frames the clip's own sound says: on the object as the camera moves, or beside it, as a dark radiograph
or a light blueprint. Instruments get their music written out from the sound too (a score, a guitar tab, a drum
sheet), and every film ends with a receipt that proves it.
An Underwood 315 typing, seen through. Clip: Erik Pålsson / Sounds of Changes, CC BY 3.0.
Say "X-ray this clip of my typewriter" to your agent, or run the three steps yourself:
text
showtime xray analyze clip.mp4 --job xray-typewriter # every event in the sound, with its frame
showtime new xray xray-typewriter/project --mechanism typewriter --theme dark
showtime xray verify xray-typewriter # after the render: reads the film back
text
19 of 19 events on their frame · audio 0.0 ms from the original
The mechanisms come from a library that grows with every verified X-ray, and anyone can add one. The
X-ray gallery plays every verified film with its receipt and the
commands that made it, and shows how to post yours; the X-ray guide walks through filming,
mechanisms, music and drums, and what the receipt checks.
Works with
showtime is a skill, a command line and an MCP server, so it runs in any coding agent that reads
Agent Skills and can run shell commands. MCP adds typed tools on top, and
the ten crew agents are an optional speed-up for hosts that have custom sub-agents.
Tested with. A real run passed: the agent installed showtime from this repository and made a
5-second test video ("make a 5-second test video that says hello", empty folder), ending in a final.mp4
whose showtime qa verdict had no FAIL.
Should work with any agent that supports Agent Skills: GitHub Copilot
(CLI and VS Code), Gemini CLI, Antigravity, Cline, Kilo Code, Kiro, Zed, Goose, Amp, Factory Droid and Qwen
Code. The files each one reads are packaged and were checked with the agent's own tools where possible, but
no real video has been made in them yet. If you try one, an issue
with what happened helps everyone. Exact steps for every agent, and what the tests covered:
docs/agents.md.
Everything is included: the skill, the ten crew agents, the MCP server and the plugin settings (/config).
Any agent that supports Agent Skills
bash
npx skills add FavioVazquez/showtime
This installs the skill for the agents you pick. Then run setup once from the installed skill folder
(<skills folder>/showtime/bin/showtime setup), and add the MCP server if you want it (below).
Other agents
Agents often run in a sandbox that blocks a large download, so run setup yourself once, in a normal terminal
(it prints the size first and resumes if interrupted):
bash
git clone --depth 1 https://github.com/FavioVazquez/showtime ~/showtime
~/showtime/skills/showtime/bin/showtime setup # Windows: ~\showtime\skills\showtime\bin\showtime.cmd setup
~/showtime/skills/showtime/bin/showtime doctor # every line PASS (SKIP is fine)
Setup also writes the stable command ~/.showtime/bin/showtime (Windows: showtime.cmd), which keeps working
when a plugin update moves the skill folder. In the commands below, showtime means that command.
showtime install --agent <name> links the skill where the agent looks, writes the ten crew agents in the
agent's own format and adds a showtime MCP server entry; it merges config files (one backup, never a
replacement), and --print, --project and --uninstall are there too.
Codex reads the root plugin.json and mcp.json; the skill appears as showtime:showtime. In its default
sandbox, allow network access and write access to ~/.showtime (the exact config.toml lines are in
docs/agents.md). Headless: codex exec --skip-git-repo-check "make a 5-second test video that says hello".
Cursor · tested
bash
git clone --depth 1 https://github.com/FavioVazquez/showtime ~/.cursor/plugins/local/showtime # then restart Cursor
agent --plugin-dir ~/.cursor/plugins/local/showtime # the CLI
Cursor reads .claude-plugin/plugin.json: the skill, the crew and the MCP server all load. Without the
plugin: showtime install --agent cursor.
Devin · tested
bash
devin plugins install FavioVazquez/showtime # add --local to keep it off your Devin Cloud plugins
devin plugins info showtime # skill, 10 agents, MCP server "showtime"
Devin reads .claude-plugin/. The crew works in the CLI and Devin Desktop, not in Devin Cloud.
OpenCode · tested
bash
showtime install --agent opencode
The skill goes to ~/.agents/skills/showtime, the crew to ~/.config/opencode/agents and the MCP server to
~/.config/opencode/opencode.json. Check with opencode agent list and opencode mcp list.
VS Code: run Chat: Install Plugin From Source with https://github.com/FavioVazquez/showtime. Without the
plugin: showtime install --agent copilot.
Gemini CLI · should work
bash
showtime install --agent gemini
Adds the skill, the crew in Gemini's format and the MCP server. The repository is also a Gemini extension
(gemini extensions install https://github.com/FavioVazquez/showtime), which brings the skill and the MCP
server without the crew.
Antigravity · should work
bash
git clone --depth 1 https://github.com/FavioVazquez/showtime ~/showtime
agy plugin install ~/showtime # skill, crew and MCP server
Or, without the plugin: showtime install --agent antigravity.
Cline, Kilo Code, Kiro, Zed, Goose, Amp, Qwen Code · should work
bash
showtime install --agent cline # skill + MCP server (no crew: Cline's sub-agents cannot use MCP)
showtime install --agent kilo # skill; add the MCP server in Kilo's settings with the command it prints
showtime install --agent kiro # skill, crew and MCP server
showtime install --agent zed # skill; it prints the context_servers entry to paste into settings.json
showtime install --agent goose # skill; it prints the extension block for config.yaml
showtime install --agent amp # or: amp mcp add showtime -- ~/.showtime/bin/showtime mcp
showtime install --agent qwen # Qwen reads skills only from ~/.qwen/skills
In the Cline VS Code extension, add the MCP server under MCP Servers > Configure MCP Servers (the command
prints the entry), or let Cline follow llms-install.md.
(Use the full path to that file in your home folder; on Windows it is showtime.cmd in %USERPROFILE%\.showtime\bin, written out in full.) Two more routes need no clone at all:
is the same server from npm (@faviovazquez/showtime-mcp,
also listed in the MCP Registry
as io.github.FavioVazquez/showtime and on Smithery), and
showtime-0.4.6.mcpb from
the v0.4.6 release opens in Claude Desktop with a double click. Setup still runs once on your machine: the
models and tools never travel inside a package. Long tools answer with a task id after about 20 seconds when a
client stops calls early; the status tool reports progress and the result. Besides the tools that mirror the commands,
guide reads a reference by the piece and receipt writes a job's receipt (tokens and cost are "not reported by this
agent" through MCP). Ten core tools are listed by default (doctor, status, guide, new_project, render,
check, qa, export_html, deliver_exports, receipt), which keeps the list short. Add
"env": { "SHOWTIME_MCP_TOOLS": "all" } to the server entry to list the voice, music, sound-effect, transcription,
stills and studio-board tools too; the .mcpb sets it for you. Some features have no MCP tool yet and run from the
command line: adopt, footage cutout, edit cards, edit moments, edit clips, pr-video, review open and
review notes, and export html's link-preview flags (showtime.json "share" works through export_html).
Every example was made by an agent acting as a user, and ships with its project sources and a README
that tells the story: the request, the assumptions, the commands, what the critic found and what
changed. Click a preview to open the example. Each one has a card with its prompt and links in
examples/. Previews are silent; the videos have sound.
Data and reports
Data story · 30 s 146 years of NASA temperature from a CSV. Every number on screen comes from the data.
Energy report · 60 s, narrated How the US power mix changed, from EIA data. Also an HTML video.
PDF to summary · 75 s, English + Spanish A two-page USGS PDF on Kīlauea 2018, with the agency's own footage, stabilized.
A Wikipedia article, explained · 60 s, English + French The honey bee waggle dance, with real research footage. Also as HTML videos. (CC BY-SA, like its source.)
Launch video · 20 s A (fictional) notes app: hook cards, its landing page, a scripted recording of the real app.
showtime's own launch video · 30 s + square cut Real renders, real terminal output, narration made on the rendering machine.
Product promo, 1:1 · 20 s + 6 s bumper A museum's CC0 photos of a Christopher Dresser teapot, only facts from the record. Also an HTML video.
Brand motion pack · sting, lower thirds, stingers A 3D logo sting in three layouts, lower thirds with alpha for an editor, made in studio mode. Also as HTML.
Claude Design to MP4 · 12 s + a 20 s loop Two exported designs adopted as they are, sharp at 1080p, each on a music bed that ends on a phrase.
Footage and audio
Interview, tightened · 72 s, 9:16 + 16:9 A public-domain NASA interview cut by transcript, face-tracked to vertical, graded and captioned.
Podcast audiogram · 45 s, 9:16 A NASA podcast clip for Reels, TikTok and Shorts, with speaker names and captions.
Talking head, dressed · 55 s, 16:9 + 9:16 Cards that appear as the words are said: name tag, list, data callout, side panel, pull-quote, caption emphasis.
A long panel, its best moments · 3 clips, 9:16 A 58-minute NASA panel ranked by edit moments; three vertical clips with captions, each through qa.
Tutorials
Recorded tutorial · 50 s Recorded from a running app; each click lands on the word that names it.
Twelve looks, one project · 24 s loop One dom project in all twelve look signatures, the look changing every 2 s.
Seven looks, no GPU · 18 s demo The seven WebGL looks, one scene each, drawn in showtime's own WebGL on the CPU.
Shutter blur on fast moves · 7.5 s demo data-st-blur on the word that moves: smeared while it is fast, sharp when it lands.
For developers
Open-source release video · 35 s, no voice What changes in people's code with Black 26.1.0's 2026 stable style: real before-and-after diffs, the install line and the changelog. Point showtime at a repo, a pull request or a changelog and it makes the same kind of video. (An unofficial summary, made as an example.)
A pull request becomes a video · 40 s, one command showtime pr-video 7 on showtime's own pull request: the PR's title and words, the files it changed with their +/- counts, a real hunk and its URL, secrets masked, a copy under GitHub's 10 MB attachment limit and the Markdown to paste.
A recap of an agent's session · 37 s, narrated showtime recap on showtime's test session: 17 minutes of an agent fixing a parser test as the numbers, a minute-by-minute timeline, the edit, the tests red to green and the commit, built from allow-listed facts only.
A failing test as a bug-report video · 34 s, narrated showtime repro on a Playwright trace: each step on the trace's screenshots, the failure slowed down with expected and received, the typed values covered, and repro.md for the issue.
Two more kinds of developer video have a workflow but no example in this gallery yet: a repo explainer (what the
code does, a map of it, one request traced through real files and lines, every claim tied to a file and a commit) and
a paper explainer (claims tied to pages, figures shown only when their license allows, Manim for the math). Say
"explain this repo" or give your agent a paper's PDF or arXiv link. For a pull request, showtime pr-video <N> reads
it (with gh, or from GitHub's API for a public one) and renders a video under 10 MB to drag into its description
(example 29). For release notes and pull requests with no agent at all,
showtime release-video and the GitHub Action make a short film in CI.
All 22 examples, with their projects and full-quality videos, live in showtime-examples.
NOTE
The HTML videos are single files you can open in any browser, offline: the same frames as the
MP4, a player with chapters, keyboard shortcuts, links to a moment or to a part that loops, questions
that pause the video until the viewer answers, and no network requests. Make one from any project with
showtime export html. On GitHub, download the file to play it. A living diagram also exports as a live figure
(--interactive): no player, a board people hover, step through and tune, in one offline file.
The 35 prompts behind the examples: copy one into your agent
Make a 20-second square product promo from these museum photos of Christopher Dresser's teapot: sleek, but only facts from the museum record. Plus a 6-second bumper.
Make a 30-second cinematic book trailer for The War of the Worlds using public-domain illustrations and lines from the novel, plus a vertical 15-second teaser.
Make a 45-second travel slideshow of an Iceland ring-road trip from these CC0 photos, cut to the music, with a little map showing where each place is. Also a vertical version for Reels.
Using our brand, give me a motion pack: a 3D logo sting in wide, square and vertical, four lower thirds my editor can drop into Premiere, and a couple of branded transitions. Show me concepts first.
Record a 75-second narrated tutorial showing how to use the showtime studio board: open it, compare concepts, react, pick one, and send feedback. And a vertical cut for Shorts.
Dress up this NASA interview with Sarah Jones about the GOLD mission: name tag, a data callout, a pull-quote, a list or chapter, a side panel and captions with emphasis; a 16:9 and a 9:16 cut.
Physics 2026 explainer for nobel-2026-lab: a telescope made of ice, ~2 min, three stop-and-ask questions, interactive export, 60 s vertical cut; publish today
Full Chemistry 2026 explainer (~2:10, 16:9) for the nobel-2026-lab: Frank's recipe, Kagan's bend, Soai's copier, the 2003 staircase, the coin flip, our mirror-race toy, caveats, medicines. NOT socratic: no questions to the viewer. American voice (af_bella; not the British female). Paperback lab-notebook look, CC0 bed, showtime credited (corner mark, end card, closing line). Must look great; post soon.
Turn this failing Playwright test into a video I can attach to the bug report.
How it works
Motion graphics are written as HTML, CSS and canvas and rendered frame-exactly in headless Chrome: every
frame is a pure function of time, so a render, its preview and its HTML video show the same picture.
Math scenes use Manim, and real footage is cut by transcript with ffmpeg.
What runs where
What runs where. In your coding agent, your agent is the director: it reads your request and sources, states assumptions, writes the script, picks templates, scenes and sound, shows a first look, briefs the crew and checks the result. On your machine, in ~/.showtime, is the studio: headless Chrome, ffmpeg, Kokoro, Piper and Supertonic voices, local transcripts, a composer with 18 styles and 56 effect types, 1,334 sounds and 297 music tracks, Manim, and showtime qa. The web only when you ask: archive search and site capture fetch pages; nothing of yours is sent. No cloud AI service, no API keys, no uploads.
showtime adds no cloud service of its own: no API keys, no accounts, nothing you make is uploaded.
Every model and tool is downloaded once into ~/.showtime, the small ones at setup and the bigger ones the
first time a video needs them. After that it goes online only when you ask for something from the web: public-archive media search (Openverse, Wikimedia Commons, NASA) and website
capture fetch pages and files, and send nothing of yours.
Quiet, checked and on the record
Every job follows the same order: check the project, render once, then fix only the seconds that changed. Output
stays short and images stay out of your agent's context, so a video costs fewer tokens without skipping a check.
Here is how (most of it came in 0.3.0, after the 0.2.0 benchmark showed where an agent's budget went):
Check first, then one render.showtime check (with the phone check and the look-repeat warning) runs before
the full render, and a fix re-renders only the seconds that changed (render --from S --to S).
Faster fixes (0.4.1). The encoder runs while the frames are captured and an unchanged soundtrack is reused: on a
busy 6-core Intel Mac a 1 s fix spliced into a 15-30 s video went from 31-54 s to 13-21 s, and whole renders from
54-115 s to 56-81 s (best of 2, other jobs running).
One picture per look.showtime look makes a single 1280 px composite of the key frames plus a brief for a
disposable reviewer that answers in text; your agent never has to open the image itself. About 12 images per job
is the budget (looking guide).
Short output. Without a terminal, check, qa, doctor and render print the verdict, the findings with
their fixes and the paths; the full report is in a file. --verbose prints everything.
References by the piece. Every guide opens with its rules, and showtime guide <topic> [section] prints just
that part.
A receipt. Each job ends with receipt.md and receipt.json: the request as typed, assumptions, review rounds,
full and partial renders, images made for looking, wall time, and tokens and cost when your agent's session log is
named. Anything unknown says "not reported by this agent"; nothing is estimated. Claude Code costs are labelled
API-equivalent, since a plan does not pay per video (format).
Every finished video gets the full review by default (quality mode: looks, qa and a critic round before delivery).
Say "lean" (or run showtime config mode lean) for a cheaper draft pass without the critic, and "show me options
first" for the full studio.
Benchmark
A small benchmark: one-sentence video tasks, one run each, scored by automatic checks, an AI judge that must prove it
looked at every frame, and a blind vote by me. Round 4 compared showtime 0.3.0 in lean mode (the lighter review
setting, which was the default when the round ran) with 0.2.0 in its default mode, plain Claude Code on Opus 5.5 and,
for the launch video, an open-source tool built only for launch videos.
In my blind vote, 0.3.0 was preferred to 0.2.0 on 4 of 6 tasks and to plain Claude Code on 7 of 8, and its launch
video beat the launch-only tool for the first time in four rounds. The AI judge preferred 0.2.0's polish on most
tasks; that is why 0.3.0 ships with the full review (a critic round on every video) as the default, and that default
was not part of the round. I'm showtime's author, so treat these as anecdotes, not a result. Every number, limit and
loss is in the benchmark report, with each earlier version a
click away; the method and the code to rerun it are in benchmarks/.
Behaviour scoreboard
A cheaper check anyone can rerun with one command: 14 one-sentence requests run through claude plugin eval, each
with showtime and with no plugin at all (same model). Does the skill fire on video requests and stay out of
unrelated ones, does it report a missing file or an unsupported claim instead of inventing around it, and does it
keep its contract? Regex and tool-call checks first, a model grader only where a pattern cannot decide; tokens and
cost per run, and every failure in plain words, are in SCOREBOARD.md.
Behaviour
Cases
With showtime
Without (same model, no plugin)
Skill fires on a video request
12
36/36 (100%)
-
Stays out of unrelated requests
2
6/6 (100%)
6/6 (100%)
Honest about inputs and limits
7
18/21 (86%)
10/21 (48%)
Keeps the contract (questions, card, plan shape)
7
16/21 (76%)
11/21 (52%)
All cases
14
35/42 (83%)
25/42 (60%)
claude plugin eval, 2026-10-05, showtime 0.4.0, agent claude-opus-5-5, judge sonnet, 3 runs per case per arm; median tokens per run 65.3k with showtime, 34.7k without; the whole run cost $36.00 at list price. Every case, every failure and how to rerun it: SCOREBOARD.md.
Meet the crew
Your agent is the director. It can hand parts of the job to ten specialist sub-agents that ship with
the plugin. Every finished video gets a critic by default (quality mode); say "lean" to skip it (a video you
will publish still gets one). A researcher joins when the video states facts or you will publish it, a sound designer when you will
publish it and it has music or effects, and scene builders when it is long. The rest come with studio mode, or when you say "full crew". Each member gets a written brief, works only in its own folder, never asks you anything,
never uploads, and reports back with a short status.
The crew as a cast of ten illustrated cards, all optional: creative director (pitches three concepts and a wildcard, then signs off the storyboard); brand designer (pulls a brand kit from your repo or site, or proposes one); scriptwriter (every word, each fact tied to a source); storyboard artist (turns the concept into shots, timings and an animatic); motion designer (one scene in its own sandbox, several in parallel); sound designer (bed, effects, sound logo, a metered mix); voice director (picks the voice, fixes pronunciation, adds languages); editor (cuts real footage by transcript); researcher (checks every claim and every asset's license); critic (watches the draft like a stranger).
Who hands what to whom
How the crew hands work around. The director, your agent in your session, writes a TASK.md brief for each member and merges each RESULT.md. I, pitch, in parallel: creative director (concepts and a wildcard), scriptwriter (facts, claims, hooks), brand designer (a brand kit); you pick a concept. II, plan: scriptwriter (the script), storyboard artist (storyboard and animatic), researcher (checks every claim), creative director (signs off); you sign off. III, build, in parallel: motion designers (one per scene), sound designer (bed, effects, mix), voice director (the voice-over). IV, review: the critic writes findings with frames; fixes go back to the same member. V, deliver: showtime qa, then the MP4 and HTML video. Footage jobs: editor, sound designer, researcher, critic. Members never talk to each other or to you.
Let your agent cast it (the usual way). Studio mode brings in the company; for a quick video, your agent
adds the critic on its own, the researcher when the video states facts or you will publish it, and the sound
designer when you will publish it and it has music or effects. Say
"full crew" to get every member the job can use without the pitch step, or "no crew" to keep
everything in one session. The words that set each mode:
You say
Mode
Crew
(nothing special)
quick, quality review
critic; researcher for facts or publish-bound; sound designer for publish-bound with music or effects; motion designers at 6+ scenes
"lean", "quick draft", "don't review"
quick, lean
none; a critic only when publish-bound
"full crew", "use the whole crew"
quick, full crew
every member the job can use, critic twice
"studio", "show me concepts first", "storyboard it first"
studio
pitch, storyboard gate, full crew
"no crew"
any
done inline
text
Let's make a launch trailer for this repo. Show me options first.
Or call one member yourself, by name (Claude Code syntax; in other agents, ask it to "spawn the researcher agent"):
text
@agent-showtime:researcher check the claims in narration.md against the README
@agent-showtime:critic showtime-out/<job>/review/round-1/CRITIC.md
A fix is judged by preference, not by a score. After a fix, showtime review-pack --against best
sets the new render beside the best one so far as a blind pair, and two fresh critics judge it, one in each order.
showtime review-verdict applies the rule: the new render wins only when it is preferred both times; a tie or a split
keeps the older one. There are up to three rounds. Before the job is marked delivered, every blocker and should-fix the
critics raised is fixed or waived with a one-line reason (showtime review-respond), and the receipt lists each waiver
(review guide).
Studio mode
Quick mode is the default: one request in, a video out. Studio is opt-in ("show me options first").
flowchart LR
R["Your request"] --> Q{"Options first?"}
Q -->|"no, the default"| QM["Quick mode"]
Q -->|"yes, studio"| SM["Studio mode"]
QM --> P{"Facts, or will you publish it?"}
P -->|"yes"| RS["A researcher joins"]
P -->|"no"| D["Checked by showtime qa"]
RS --> D
SM --> CR["The crew joins"]
CR --> D
D --> RC["A critic reviews it (say lean to skip)"]
classDef st fill:#15100E,stroke:#E9B949,color:#F5EBDC
classDef hot fill:#B3121F,stroke:#E9B949,color:#FFF7EC
class R,Q,QM,SM,P,RS,CR,RC st
class D hot
Quick mode is one sentence in and a video out; studio mode opens a local board first, then builds.
In studio you talk about facts and goals in chat; everything about look, sound and timing is shown on a
board, a local page served on 127.0.0.1 with a token, with lettered options, one recommendation and
buttons you click.
Studio mode, on a local board at 127.0.0.1 with a token. 1 concepts: three and a wildcard, with style frames. 2 look and sound, optional: three looks, three music beds, voices. 3 storyboard: every shot with time, picture, text and voice-over. 4 animatic: a draft with the bed, notes by timecode. 5 build and review: the final, checked with showtime qa. Picks and comments come back as data and are logged.
Output formats. One request, every shape: 16:9 for YouTube, X and LinkedIn; 1:1 for square feeds; 9:16 for Reels, TikTok and Shorts, laid out again or face-tracked rather than just cropped. What a job can hand you: final.mp4 (H.264 and AAC, mastered to -14 LUFS), the HTML video, WebP and GIF loops, poster.jpg and thumbnails, SRT and VTT captions, WebM and ProRes with alpha, share.txt with post copy and credits.txt.
HTML videos
showtime export html writes one file that plays offline in any browser, with the same frames as the
render. Press ? in the player for the key map. A link can open a moment (#t=18) or loop a part
(#t=10-20; Shift + drag on the scrubber picks one), and questions listed in showtime.json pause the
video until the viewer answers (guide).
Anatomy of an HTML video: the real player of example 02, heat-pump.html, paused at 0:18 with its chapter menu open (Hook, Heat in cold air, The loop, Evaporator, Compressor, Condenser, Expansion valve, Payoff, End card). 1 one file of about 1 MB with frames, audio and player inside. 2 deep links such as #t=18 or #chapter=4. 3 chapters on the scrubber, in a menu and on keys 1 to 9. 4 keyboard control. 5 zero network requests.
The player's keys
Keys
Action
Space or K
play / pause
← / →
back / forward 1 s
, / .
one frame back / forward
J / L
back / forward 5 s
1 to 9
jump to a chapter
[ / ]
previous / next chapter
M
mute
F
fullscreen
C
copy a link to this moment (#t=), or to the picked range (#t=a-b)
Shift + drag on the scrubber
pick a range to loop and link (Shift + click: from the playhead); Esc clears it
A-C or 1-3, Enter
while a question is asked: answer it, then continue
What is in the box
image Voice-over Kokoro, Piper and Supertonic voices, English, Spanish and 30+ more languages, with exact word timings for captions and kinetic type.
image Music and sound 297 produced tracks (Scott Buckley, Kevin MacLeod, a dozen more composers, public-domain recordings) with the credit written for you, a composer that hits exact lengths, 56 synthesized effect types, 1,334 permissively licensed sounds, beat grids, ducking, mastering.
image Captions Five styles, burned in or as SRT/VTT, placed inside each platform's safe zone; karaoke from the voice's word times.
image Footage editing Word-level local transcripts that keep the ums; cut fillers and pauses by editing text; speakers, scenes, face-tracked 9:16, stabilize, denoise, grade.
image Math with Manim Equations, proofs, graphs and grid transforms, timed to the narration, as an optional extra.
image Studio boards Concepts, style frames, music beds, a storyboard and an animatic on local pages you click through; picks are logged.
image A crew of ten Optional specialist sub-agents from creative director to critic; your agent stays the director and the only one who talks to you.
image HTML videos One self-contained file per video: chapters, keyboard control, links to a moment or a looping part, questions that wait for the viewer's answer, zero network requests.
image QA before done Pre-render checks and a phone check, then showtime qa on the final: loudness, black or frozen frames, captions, platform specs, and a hearing pass (a voice buried under the music, long quiet stretches, jumps in level at a cut, sound cut off at the end).
image Looks and motion blur Seven WebGL looks (fluted glass, tilt-shift, liquid metal, mesh gradient, god rays, marble, metaballs) and a shutter blur on fast moves, all rendered without a GPU (demo).
image Talking heads Cards that appear as the words are said (name tag, list, data callout, pull-quote, side panel), caption emphasis, and a big word behind the speaker, cut out on the CPU.
image Long recordings to clips A podcast, talk or panel ranked for its best moments on your machine, then the ones you pick as captioned vertical clips, each checked by qa.
Also: 30 motion components (seven of them WebGL looks), 26 transitions (15 CSS, 11 WebGL) and 6 themes, 12 look signatures that new
dom, launch, short and data projects start in (a palette, a type pair and a motion feel, picked away from your
recent videos; showtime signature), a showreel template for a dense 15-second reel, living diagrams (a system as an isometric figure that builds itself,
also exported as a live figure people poke), website capture
(screenshots, copy, brand colours and fonts), scripted app recordings with smooth auto-zoom, cursor and keycaps, PDF import, CSV and JSON to charts, a brand kit, posters baked into frame
0, exports for YouTube, X, LinkedIn, Reels, TikTok, Shorts and square feeds, README loops (animated WebP
and GIF, like the previews on this page), credits written automatically when an asset needs
attribution, a look history so videos do not repeat, style references, adopting video code you already wrote or a
Claude Design export (showtime adopt), and a receipt for every job.
Every command
showtime --help lists them grouped, with examples; showtime <command> --help has the details.
setup, doctor, config, install, report, paths, version, mcp, guide, help
More
series (a tutorial series sharing one kit), signature (the look signatures: list, apply)
bash
showtime new dom my-video --duration 20 # a project from a template
showtime voice script my-video/narration.md -o my-video/voice --fit 18 # local narration, fitted to 18 s
showtime retime my-video --from-voice my-video/voice/timeline.json # scenes follow the narration
showtime data import signups.csv my-video --x month --y signups --scene bars # a CSV becomes a chart
showtime preview my-video # live player with scrubber and audio
showtime render my-video --preview # fast draft
showtime render my-video -o final.mp4 # full quality
showtime qa final.mp4 # PASS/WARN/FAIL: loudness, black/frozen frames, captions, platform
showtime deliver exports final.mp4 --targets youtube,reels,square
showtime export html my-video # a single-file interactive HTML video
showtime look my-video # one composite of the key frames, for a quick visual check
showtime reference clip.mp4 --job my-job # a video's pace, shots and type scale, as a brief (never its content)
showtime adopt my-page/ # a page that already has seek(t) gets check, sound, qa and export
showtime adopt design-html.zip # a Claude Design animation's HTML export to a 1080p video, its fonts local
showtime release-video notes.md -o my-video # release notes to a ready-to-render project, no agent needed
showtime pr-video 123 # a pull request to a video under 10 MB for its description
showtime recap --latest # this folder's newest Claude Code session as a short film: script.md first, then --yes
showtime repro -- npx playwright test tests/login.spec.ts # a failing test as a bug-report video: script.md first, then --yes
showtime new diagram how-it-works --example enter # a living diagram: a system that builds and explains itself
showtime export html how-it-works --interactive # the same scene as a live figure people poke, one offline file
showtime review open my-job # a local page to leave notes on frames or stretches of the finished video
showtime edit cards suggest edit/transcripts/talk.json # moments in a talking head for cards (name tag, quote, list)
showtime footage cutout talk.mp4 # the speaker cut out on the CPU: a video with alpha, a matte, a sheet
showtime edit moments my-job # a long recording's best moments for short clips, ranked locally
showtime edit clips my-job --pick m1,m3 # the picked moments as finished 9:16 clips, each through qa
showtime assets font --css "https://fonts.googleapis.com/css2?family=Anton" --copy-to my-video/fonts
The audio toolkit
Everything is local and license-gated: no sample leaves your machine, and an asset that needs
attribution writes itself into credits.txt. Catalog tracks are downloaded from their creators on first use
(with the size announced) and never re-hosted here.
Command
What it does
audio compose
procedural music to an exact length in 18 styles, with stems, MIDI and a beat map; restrained beds for explainers and data, livelier styles on request
audio sfx
56 synthesized effect types (whooshes, hits, UI clicks, risers), with the hit time printed
audio music
the produced-music catalog: 297 tracks, each measured for quality and tagged by mood, energy and tempo; audio music pick --for launch --dur 45 chooses one, and the credit lands in credits.txt and the post copy by itself
audio lib
the local library, 1,334 sounds: CC0 effects and ambiences, CC-BY music beds credited automatically, and beds rendered on your machine; audio packs adds 35 more sound packs (34 CC0, 1 CC BY) on demand
audio beats
beats, downbeats, onsets, energy, sections and key, so cuts land on the music
audio fit
loops or trims music to a length on bar lines
audio mix
one mix file: ducking under the voice, effects aligned to hits, loudness
audio meter, audio master
LUFS, true peak and loudness range; mastering to -14 LUFS / -1 dBTP by default
Math with Manim
showtime manim new|render|check|cues makes equations, proofs, graphs and grid transforms with Manim
Community (the manim extra; LaTeX is needed only for equations), and times them to the narration.
Example 22 cuts a circle into rings, unrolls them into a triangle and
lands on
$$A = \tfrac{1}{2} \cdot 2\pi r \cdot r = \pi r^2$$
with a vertical cut for Shorts from the same scenes. An optional OpenGL engine (the manimgl extra) runs
scene files written for it. showtime manim check also renders a draft and runs qa's black-frame and frozen-frame
detectors on it, so a near-black scene or a barely visible change is reported before the full render.
Canvas text outside the safe box. At 9:16, every step of the dense timeline compares each text a page draws on
its own canvas with the safe box (x 64-916, y 220-1440 at 1080x1920): one safe_zone warning per text, with its span.
Canvas text size. Raw fillText/strokeText now feeds the tiny_text rule and the phone check, as DOM text and
F.text already did.
Text over text. Every text a canvas paints and the DOM's are compared on the whole timeline: a pair that overlaps
on two steps in a row is a text_overlap warning with when it starts and ends. Text layered on purpose can say so
(F.text(..., {layer: true}), F.layer, ST.layer).
A probe that did not run is a warning (cut_probe_failed, webgpu_probe_failed), so such a check never reads as
clean and check --strict fails on it.
X-ray
9:16. The sound strip sits above the counters inside the safe box, and the part labels are 44 px in a column at
the safe box's edge, with the drawing between the columns. The 9:16 layout change leaves 16:9, 4:5 and 1:1 as
they were. A project made with 0.4.5 keeps its copy of the template; showtime new xray gets the new layout.
16:9. A new project passes its own check, and the strip's label is 26 px and fits a long mechanism word.
"xray".offset_frames. The sound strip, track_until and the piano, drums and guitar follow the recording's
clock (k.rt, k.frameAt(t) in the drawing kit).
xray verify reads the sync marker on a --preview or --scale render; the receipt says what "the original" is
for a film made from a rendering of data.
export html --interactive packs a page's own fonts, and export html run from inside a job writes into that job
(xray).
Fixes
Files as installed. The repository stores every file exactly as it is installed (.gitattributes* -text,
Windows launchers with CRLF), checked by scripts/check_release.py.
setup --home X installs ffmpeg into X when a default install exists.
Living diagrams. Space or Enter on a focused control no longer also fires the scene's key.
The embed element takes a file: address only on a page opened from disk.
showtime assets icon suggests the right name at once for a misspelled one.
From data.showtime xray import <events.csv|json> --job <job> --time-map SLOW,T0 writes xray.json from event
times measured in data (peaks of a signal, a sensor log): film time is (t_data - T0) x SLOW and each event lands on
its frame. --source names the sound the film plays, so xray verify can check it.
From a recording with no picture.xray analyze takes a WAV (events on a frame grid of --fps, default 30) and
xray notes takes one too, always at 30 fps; the page draws the picture side.
The live page. It states how the events were measured, lists your own steps when "xray".made.commands has them,
and the page, the gallery and the guide say what sharing a page shares
(guide, xray).
The skill and the tools
Routing by family. SKILL.md sends a request to one of six families at 1,200 words or fewer; flags live in the
guides and --help. A routing eval (benchmarks/routing-eval/) and a release check keep a case for every new
workflow guide.
footage trim -o <file> writes that file. An existing file is refused unless --overwrite.
The embed element loads only a relative, http(s) or file: address.
Living diagrams on a phone. The Type field takes a paste, an input-method composition and Android Backspace, and
no longer zooms the page on iOS.
showtime xray.analyze finds every event (a keystroke, a pluck, a hit) in a clip's sound with its frame;
showtime new xray --mechanism <object> draws the inside moving on those frames, on the object (through), beside
it (split) or as an isometric diagram (diagram), as a dark radiograph or a light blueprint, 16:9 or 9:16; the
library has a typewriter, a music box, a switch, a piano, a guitar and a drum kit. notes writes a score, a guitar
tab or a drum sheet from the sound; verify reads the finished film back and qa fails a missing or extra event or
audio more than 20 ms off. The receipt and the clip's credit go on the end card
(guide, xray).
The live page.showtime export html <xray project> --interactive writes one offline page: pads play the next
event of their kind with the clip's sound, your keyboard types on the typewriter, drag scrubs, #hit4 and #t2.5
link to a moment, --prompt puts the request that made it on the page next to the commands, and
<showtime-xray src="you-live.html"> or an iframe embeds it.
The gallery. The X-ray page plays ten films with their
receipts and plays each one live in place.
Living diagrams
You touch them. A scene can take typing (interactive.type), a click on a part (parts[].press) and a drag that
turns a knob (parts[].drag). --example typewriter and --example computer are new, and the heat pump's outdoor
unit drags to set the weather (guide).
Living diagrams.showtime new diagram draws a system as an isometric figure that builds itself over time:
parts arrive in the order that explains them, pipes and links join them, flows, packets and state changes move
through them, labels land when their part matters, and the camera chooses what to look at. Light, dark or white;
--example enter (a coding agent's loop), --example market and --example econ-lab start from finished scenes.
showtime check reports a label that collides or never shows whole
(diagram, issue #51).
Live figures.showtime export html <project> --interactive writes the same scene as one offline file,
<slug>-figure.html: no play button, the board is live from the first frame. Hover a part to light it and read
its value, pick a step to run it as an experiment on the board, turn a knob and the levels and numbers answer at
once; untouched, a short tour plays. Keys, deep links to a state (#step=cost&rule=3), reduced motion, a phone
layout and no network requests. showtime check walks every step, knob value and hovered part for cut or
overlapping text and broken readouts (html-export § Live figure,
the demo, live on the site).
From your agent's work
showtime recap. A Claude Code session becomes a 30-60 s narrated film of what the agent did: the time, turns
and tool calls, a timeline of the files it read and edited and the commands and tests it ran, the tests red to
green and the diff from git. It reads the session log on your machine through an allow-list of facts
(repository-relative paths, program names from a fixed list, test counts, git stats), never the transcript's own
text; a filter drops anything that still looks like a key, a path, a URL or an e-mail address, and nothing renders
until you have read script.md (recap).
showtime repro. A failing Playwright test (its trace.zip, or the test command) becomes a narrated
bug-report video: each step on the trace's screenshots with a cursor and the target boxed, then the failure slowed
down with expected and received, plus repro.md to paste into the issue. Typed values are never shown or spoken
(their fields are covered); paths are shortened to the file name, URLs lose their query strings, and secrets are
masked (repro).
Render, sound and the site
Every render worker captures from a page set up like the first one. Under load, a worker whose page opened
while one of its modules got no reply could render bare frames. Each page's setup is now compared with the first
page's, and a page that differs is opened again; if the first page was the broken one, the render stops with an
error instead of shipping its frames (issue #52).
Music per video, and quiet cuts. Recap and repro pick their bed from the music catalog (or a composed style
offline) per session or test, so two films do not sound the same; a rerun keeps its bed, --music pins one, and a
CC BY track's credit is written for you. A catalog track is downloaded once from its creator's site and cached;
nothing is sent, and --music <style> or SHOWTIME_OFFLINE=1 keeps the whole film local. Recap, repro,
release-video and pr-video no longer put a sound on every cut (--cut-sounds adds a soft swoosh back), and the
transition sounds are softer everywhere.
How showtime is built. A new page on the site, how showtime is built,
is the crew's operating manual: who does what, and how a task becomes a merged pull request or a film (issue #53).
The site and the repository share one link-preview image (issue #54).
New in 0.4.2
What's new has a short paragraph for each group of them.
Render
Chapter mode.showtime render --chapters plans the pieces from your chapters (or the film's acts),
--chapter N --job J renders one, and --join --job J joins them and builds the soundtrack once for the whole
video, so there are none of the loudness steps (2.6 and 0.7 dB) that joining separately mastered sections gave.
Every seam is checked against a master before the file is named final.mp4, and after a whole render or a
join a later fix to one chapter re-renders exactly its frames. On one machine a whole render is faster: use
chapters for a second machine (not measured), a later fix of one chapter, or a long film (render § Speed, issue #22).
A browser window resized late no longer ruins a render. With 3 workers, 7 of 40 renders on a 6-core Intel Mac with a
GPU had a wrong-sized capture lane under heavy load, and 0 of 30 do after the fix; the same fix makes --scale 2 real
on a Mac. A page with the wrong size is set again and render.log says so
(render, issue #49).
A frame that never comes no longer stalls a render (when the browser reports its processes' work; otherwise
the 10-minute cap stays): the frame is drawn again in a new browser, or the check ends with an error (issue #24).
A WebGL canvas that loses its context on the GPU renders again without the GPU (--gpu off) instead of shipping
white.
More browsers without a GPU. Without a GPU, --workers auto uses CPU threads - 2 from 8 threads up (at most 8,
within the frame, memory and SHOWTIME_MAX_WORKERS limits): on an 8-thread machine it picks 6 browsers instead of
3; with a GPU nothing changes (issue #41, FAQ).
Footage and voice
edit render keeps the sound in sync on showtime's own renders: a range could come out with its sound up to
21 ms early (issue #38).
Narration that fits.showtime voice script narration.md -o voice --fit 15 --estimate says up front whether
the narration can fit before it synthesizes a single line.
Your own local voice engine. Extra engines load by name, and doctor no longer fails on Kokoro when you chose
another (voice, issue #8).
Help
A first-video guide, troubleshooting by symptom and a glossary; showtime doctor ends with a link to the
troubleshooting page when a check fails, and the site's docs start on "Start here"
(your first video, troubleshooting,
glossary).