No need to memorize FFmpeg parameters anymore: let AI edit locally, and your footage never leaves your machine
An open-source project called ffmpeg-skill lets Claude Code and Cursor call local FFmpeg directly to edit video. No API key, 42 tools, each operation measures itself after it runs, and it honestly says when something can't be measured.

FFmpeg parameters are hard to remember; that's an old problem. If you get one comma wrong in a filter_complex, the whole video can go black, and the command line may not even report an error. Someone in the replies to the tweet said that tuning FFmpeg parameters is tedious anyway, so why not just hand it to a tool to write the command and save yourself from digging through the manual.
Now someone has packaged this work into an Agent Skill called ffmpeg-skill, by kajisho5. Once installed, coding assistants like Claude Code, Cursor, and Codex can call FFmpeg locally to edit video. Footage is not uploaded to the cloud, no API key is required, and it does not depend on any online service.
Install with one line:
npx ffmpeg-skill
Then run npx ffmpeg-skill doctor to check whether FFmpeg, Python, and all the filters are available on this machine. It requires FFmpeg 6.1+ and Python 3.10+, and both need to be in PATH.
Usage is natural language. For example, tell the agent: cut 0:45 to 3:10 and 5:00 to 6:30 from interview.mp4, and make it a vertical Reels video that is exactly 60 seconds. The agent will run probe.py, cut.py, fit.py, export.py, check.py, and look.py in sequence, then report that final.mp4 is 59.98 seconds, 1080x1920, 30fps, AAC stereo, with a contact sheet attached.
This toolkit has 42 tools in total, covering cutting, concatenation, silence removal, aspect-ratio changes, subtitles, color grading, audio mixing, multicam, and batch processing. When connected via MCP, it lists only 12 core tools by default (render, look, caption, export, check, fit, cut, audio, loudness, graphics, silence, probe); the rest are called by name, to avoid stuffing 30 rarely used schemas into the context.
There is one design rule: measure first, then act. Every task starts with probe.py, reading duration, frame rate, resolution, rotation, color tags, and audio stream layout from the file itself, not guessing from the filename. After changes, measure again. For anything with visual changes, look.py also generates a thumbnail contact sheet so the agent can look at it.

silence.py handles silence removal. The default threshold is -35 dBFS, with 0.2 seconds of padding before and after each speech segment to avoid cutting into breaths or trailing sounds. The project author's test data is 20 files with known gaps: 0 missed cuts, and residual silence no longer than 1 millisecond. If a cut point might fall in the middle of a word, the result includes a separate warning.

caption.py handles subtitles, supporting SRT, burned-in ASS, automatic line wrapping for platform safe areas, and word-by-word karaoke highlighting. For non-Latin scripts such as Chinese, Japanese, Korean, and Arabic, it automatically picks a font that covers the text; if the machine lacks a matching font, it errors out directly instead of rendering a row of boxes.
Several people in the tweet replies asked the same thing: does it check its own work after editing? The answer is that it does, in part. The output file's duration, codec, frame rate, loudness, true peak, and stream count can all be measured again. Steps it cannot measure are marked not_measured, not passed. But whether the visual content is correct, whether the composition is good, whether subtitle placement is appropriate, and whether a cut point lands in the middle of a word—these are explicitly listed as unverified and left for the calling agent or a human to check.
In the README, the author puts its role clearly: this is hands, not brain. It handles cutting, measuring, rendering, and reporting; it does not decide which segment is worth cutting, what the subtitles should say, or whether the video is ready to publish. Those are the job of the higher-level agent.

Another frequently asked question: after the final cut, if you want to shorten the second shot by half a second, can it change only that one spot? render.py supports declaring the entire edit in a project.json, and with --cache it can reuse unchanged stages, so theoretically after a change it only reruns the affected part. But it will not decide on its own whether that half second should be trimmed; you have to tell it.
The boundaries are also stated honestly. It does not find faces, track subjects, or judge which segment is exciting. Cropping 16:9 to 9:16 is centered by default; to keep the person in frame, you have to give coordinates, or have an agent that can see images look at the contact sheet and decide. The tool does not make aesthetic judgments for you about losing 70% of the width.
The value of this thing has little to do with the gimmick that AI can edit video. It breaks FFmpeg's error-prone manual work into parts with input validation and output verification. Each part declares what it needs, what it writes, and how it is verified, while also putting unverifiable matters on the table. For someone who needs to batch-process footage but does not want to upload original files to someone else's server, this sense of proportion is more practical than the number of features.
发布时间: 2026-11-15 17:30