proofcut

An AI video editor that proves its cuts. Your recordings in, a finished, mastered film out: cut by transcript, with b-roll, cards, music and captions, and every step an agent can call. proofcut renders on your own machine, then transcribes the render and checks that it says what the edit says.

https://github.com/user-attachments/assets/4153d180-3d7c-4c70-af5f-54d63d0a8bd5

An agent cutting a demo video, unattended, from a goal and no steps.

The two runs it was cut from, uncut

Silent, because the recorder took frames only; the voice is in the film the agent cut. The workspace (2:26) and Claude Code with the proofcut plugin (3:09).

Runs on Linux, where it is developed. macOS and Windows pass the test suite on CI; how far each has gone by hand is § Help wanted.

Quickstart

With uv installed:

uvx proofcut doctor          # only looks: what is missing, and the fix for each

uvx proofcut setup --plan # what an install would fetch, and its size; touches nothing uvx proofcut setup # installs it for you alone, no sudo; --uninstall reverses it

Then make the two-minute demo, or give an agent the tools with the Claude Code plugin. § Try it walks all of it.

Why it exists

Most of the work in a narrated video, whether an essay, a tutorial, a screencast or a talk, is bookkeeping. Find the retakes and cut them clean. Put the right footage under each line. Level the music under the voice, caption it, end on a card, render it, master it. An agent can do that bookkeeping now, given an editor it can drive.

What an agent cannot do on its own is know that the file it rendered is the film it meant. ffmpeg, melt and auto-editor all exit 0 on some failures, so a render can drop a line, keep a retake, add a frame of black or carry no captions and still report success. Every check that reads the project rather than the file agrees with it. The usual way to find out is to watch the whole thing.

proofcut is an editor built around that gap. You, or an agent, edit a timeline addressed by the words in it. proofcut renders it on your machine, then transcribes the render, counts its frames, and says where the file and the edit disagree.

Here it is on the demo project. The retake is cut from the edit, and verify is pointed at a render made before the cut:

proofcut -C proj cut vo 11:23 --pad 0.1

proofcut -C proj verify stale.mp4

"expected_words": 34, "heard_words": 47, "similarity": 0.84, "diff": ["--- timeline", "+++ render", "@@ -10,4 +10,17 @@", " video", " editor", "+every", "+cut", "+you", "+make", "+names", "+a", "+um", "+no", "+let", "+me", "+try", "+that", "+again", " every", " cut"]

The file still says the thirteen words the edit took out, and verify names them. A render of the edit as it stands hears all 34 (DEMO.md step 7).

Run, not staged

TRIAL.md scores three unattended runs, each handed a goal and no steps, and each passed every one of its checks:

• The demo cut, the one above.
• Real footage. 96 seconds of narration with its fluffed takes left in, plus four clips of film footage. The agent cut it to 45 seconds, chose footage by what each line was about, burned captions, and checked its own render: all 123 expected words heard back.
• A whole film. The demo material plus a score, briefed as a finished film ready to upload. In 192 seconds and $2.27 the agent cut it, laid the music under the voice, ended on a card, mastered it to −16 LUFS, and checked it. The score, the level and the end card were each measured in the delivered file, not taken from the project.

How it compares

COMPETITORS.md reads every entry from its source, most recently on 2026-09-28. In short:

• Transcript editors (the Descript model, and its open-source re-implementations) cut by deleting words, for a person's hands. None of the open ones has an agent surface, and none checks its render.
• Agent editors over MCP let an agent drive the edit. The nearest render checks among them compare the duration within a tolerance, or transcribe short windows around suspect seams. None diffs the whole render's words against the cut.
• NLEs (Kdenlive, Resolve, Premiere) are where a person finishes by hand, and DaVinci Resolve 21.1 now ships an MCP server of its own. proofcut exports to them rather than replacing them, and, with the trim brought back by import-edit, verify checks what they deliver.
• auto-editor removes silences headlessly. proofcut uses it as a render backend.

What proofcut lacks that others have: a check for frozen or silent spans in a render.

What it can do

Every stage from the first import to the delivered file is a proofcut command. No NLE finishes the film, and nothing else touches the render. Each row links the manual section that walks it.

Two video essays of five to six minutes, first finished in Kdenlive, have been rebuilt with these commands alone and measured against the delivered files. One came out the same length to the frame. The other matched all 63 of its voiceover ranges to the millisecond, with the voice aligned to the sample. Both master at the original's −16 LUFS. The measurements are in HISTORY.md.

Beyond those stages:

• Cuts stay addressable. A word's index never renumbers, so cut vo 111:114 names the same words however many cuts came before it, and a cue hung off a phrase stays addressed through every cut around it.
• An agent that can look. shot-sheet draws the whole picture track as one labelled grid, and footage-sheet browses a clip you haven't cut yet. Both return the image itself over MCP, not a path the agent can't open.
• B-roll by description. describe writes what is on screen in each ~10-second window of footage, so an agent can choose a clip by what a line is about.
• Transcript self-checks. Retake seams, invented words, swallowed repeats and suspect durations are reported when a transcript is attached, and unspoken lets the render itself testify to words nobody said.
• Reframing for another aspect. Per-shot crop windows, face-aware proposals (reframe-detect), a review sheet, and stacked splits for two speakers. Cards are redrawn at the new frame size, never stretched.
• Screen recordings. Named instants (events) that a crop, a sound or a speed change can hang off, a clip inset into the recording, and a retime for the slow parts.
• Animated graphics. A web page, written by an agent or filled from a template (typing, a highlighter sweep, a letter build, chips), captured frame by frame and placed over a span of words. It animates in, holds for the span, and animates out, so a cut never breaks one. A page can show the project's own footage, exact to the frame, and saved graphics carry across projects.
• Stills and stickers. Photos and cut-outs go in once, upright, and play full frame or ride over the film: placed, sized, turned, framed as a photo card, popping or sliding in. Paste one into the agent's prompt and it is added.
• Built for agents. 132 MCP tools with typed inputs, structured returns and read/write annotations, so Claude Code, Codex or your own agent can drive it and a permission layer can tell a look from a change.
• No lock-in. The timeline is OpenTimelineIO, the manifest is JSON, and the render is ffmpeg's and MLT's. Export a .kdenlive or OTIO file and finish anywhere.

How people use it

Tell an agent what film you want. In Claude Code, install the plugin and describe the film: which recording is the voice, what the b-roll is, where the music goes, what it ends on. The agent imports, transcribes, cuts the retakes, hangs footage off the lines it belongs to, scores, masters and checks the render, using proofcut's tools and nothing else. It can look at the picture track as a labelled grid while it works, so it sees what