Using the MCP tools

The plugin registers the server in plugin/.mcp.json: rapid mcp over stdio, started by Claude Code. It runs the cli option's command (default rapid), falling back to the checkout the plugin sits in when rapid isn't on PATH. Its eleven tools (daemon/src/mcp/server.ts) touch your projects and the daemon, and reach GitHub only to install a named style. Tools that need the daemon start it in the background on first use. Each answers in a few plain lines; a failure is one short message, never a stack.

#The tools

#new_video

Makes the project folder (by default ~/rapid/<the brief's first line>), writes brief.md, and starts the video in the background. It returns at once with the job id, the folder, and the screening page. Optional: project (a folder, made if missing; one that already has storyboard.json or scenes reuses them), style (default: the project's pinned style, else swiss), look instead of style (a draft from rapid style extract, such as <project>/.rapid/look, which the job finishes with the extractor agent, holds to the style check, and pins before the storyboard), format (default reel), music (a track to cut the video to, which is heard first and copied into assets/ when it's elsewhere; see music), review (agent, or none for the code checks alone), keys (agent, the default: each scene's key frame, its hero as a still, is judged by the reviewer before the scene moves; person: you approve each one; off: straight to motion), and stops (none, the default: it runs to the finished video, approving the storyboard and taking the best try or round of anything that doesn't converge, each choice named by video_status; storyboard: it waits for your yes on the storyboard only; all: it also waits on what doesn't converge). In a chat, Claude first asks you a few questions and writes the brief (the rapid-brief skill), then starts the video and asks nothing more.

Make a twenty-second vertical video: a person asks for a poster out loud, the assistant answers, and the file arrives. Calm, one idea at a time. Use the terminal style.

#video_status

A job's state in a few lines: its scenes by state, what needs you (node ids and labels), what runs on each lane, and, when it's done, the paths of video.mp4 and video-phone.mp4, then every choice made without you (chosen without you:). With no job, the newest. It answers at once; a video takes minutes, so ask again later rather than waiting on it.

How's the video going? Does anything need me?

#approve

Approves a node waiting on you: the storyboard, or a scene accepted as it is. Claude takes the id from video_status, and approves only what you've agreed to.

The storyboard looks right. Approve it.

#redo

Runs a node again, with a note for whoever does it next. Write the note as a direction: what to change and where. What depends on the node runs again too.

Redo the storyboard: three scenes, not five, and end on the file card.

#replan_video

Asks a video's storyboarder for the storyboard again, with a note saying what to change (the structure, the pacing, a scene to add or cut). The new storyboard waits for approval; every scene whose entry changes builds again from its key frame, and the video is joined again. For one scene only, redo its build with a note instead.

Replan the video: cut the second scene and open on the file card.

#revise_video

Acts on one of your notes on a video, done or still running, then joins, mixes, and exports it again with no stops. Claude routes the note by what it names: a scene and a moment (scene, t, and t_end for a span) is a mark there and a new round of that scene only; a scene alone builds that scene again to the note; a note about the whole video (pacing, order, length, the story) storyboards it again. It answers with the route it took and the scene's new round.

In the second scene, around two seconds, the price card leaves too fast. And the whole thing feels long; tighten the middle.

#add_mark

Leaves your note on a scene at a moment (t) or over a span (t to t_end), in seconds from the scene's start, with a severity (blocker, major, minor, or nit). It's the same mark the screening page makes. It's written to renders/<scene>/marks.json, which every build of the scene reads first. To have the builder act on it now, redo the scene's build.

In the card scene, from 1.2 to 2 seconds, the card holds too long before it leaves. Make it a major note, then redo that scene's build.

#scene_still

Renders one frame of a scene file and returns it as a picture, so Claude can look at the layout, the type, and the colour. It draws the scene in a style (style, default: the project's pinned style, else swiss) and a format (format, default: the pinned one, else reel). It needs no daemon.

Show me the idea scene at 1.5 seconds, in terminal.

#list_styles

The styles and formats on this machine (installed and built in, swiss, terminal, poster, and the rest among them). Pass a query to narrow it. The shared styles are on the styles page.

What styles do I have? Is there anything dark and technical?

#add_style

Installs a style, as rapid style add does, from a folder, a .zip, an https address, github:owner/repo[/path][@ref], or a name, the folder styles/<name> of rapid's GitHub repository. Installing runs nothing.

Install the style in ~/styles/warm-field.

#open_screen

The screening page's address for a job (the newest by default), for you to open: the scenes, their contact sheets, the player, and your notes in time.

Where can I watch it?

#Tools or the CLI

Inside a Claude Code session, the tools are the easier way: they answer in plain words, start the daemon when it's down, and need no shell. Use the CLI for what they don't cover:

• rendering, sheeting, and checking one scene by hand: rapid render, sheet, check;
• cancelling a job: rapid cancel;
• writing, proving, checking, and packing styles: rapid style check, proof, pack;
• pinning a style or format in a project: rapid style use;
• anything run outside Claude Code, in a script or a terminal.

The /rapid command sits between the two: /rapid new, status, approve, redo, open, and setup act at once, without a turn of the conversation. See using the pane.