Showtime

https://github.com/user-attachments/assets/638bfa30-522f-4e7c-ab9e-e77f364e7dc9

Quick start

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.

2. Add showtime to your agent. In Claude Code:

/plugin marketplace add FavioVazquez/showtime
/plugin install showtime@showtime

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.

Claude Code

/plugin marketplace add FavioVazquez/showtime
/plugin install showtime@showtime

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 plugin marketplace add FavioVazquez/showtime
codex plugin add showtime@showtime
showtime install --agent codex --no-skill --no-mcp   # optional: the ten crew agents (~/.codex/agents)

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.

copilot plugin marketplace add FavioVazquez/showtime
copilot plugin install showtime@showtime

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.

droid plugin marketplace add FavioVazquez/showtime
droid plugin install showtime@showtime

Factory translates the .claude-plugin/ layout. Without the plugin: showtime install --agent factory.

MCP only

Any client that starts local (stdio) servers can use showtime's MCP server on its own, without the skill. After setup:

{
  "mcpServers": {
    "showtime": { "command": "/home/<you>/.showtime/bin/showtime", "args": ["mcp"] }
  }
}

(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:

{ "command": "npx", "args": ["-y", "@faviovazquez/showtime-mcp"] }

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.

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.

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:

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

The agents live in agents/; their briefs, in skills/showtime/references/crew/, work on any agent host, and the crew guide has the dispatch rules.

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).

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.