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:
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:
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.
Say "X-ray this clip of my typewriter" to your agent, or run the three steps yourself:
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
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
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):
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".
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 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.
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.
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.
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.
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).
Now showing
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
Explainers
Product and brand
Footage and audio
Tutorials
Social
Trailers and montage
Looks and motion
For developers
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.
[!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.
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
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.
Who hands what to whom
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
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"):
@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.
See example 09 and example 21, which is
a tutorial of the board itself.
What you get
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).
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
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.
showtime --help lists them grouped, with examples; showtime <command> --help has the details.
