Local video editing MCP servers for AI agents, and hosted alternatives: 7 compared

On 17 October 2026, the makers of Cutbolt compared seven video editing tools for AI agents: we measured Cutbolt over MCP on one Windows PC and read the other six from their code and docs, without running them. Four are local MCP servers that edit your files: Cutbolt (18 tools by default), Kinocut (formerly mcp-video; 203 tools), claudeclip (31) and video-edit-mcp (34). Video Jungle MCP edits on Video Jungle's servers, Vlexor has a hosted engine plan each edit and renders it on your machine, and HyperFrames renders new videos from HTML, with no local MCP server for desktop agents. In six runs across Cutbolt's 0.4.0 release and main, a cut of a 720p test clip exported exactly the expected 150 source frames in order, resending the same edit request returned its original receipt instead of applying it again, undo restored the earlier cut, and repeated H.264 exports of the cut were byte-identical with one FFmpeg build. Method, sources and data are below.

We make Cutbolt. Read this as a vendor's page: our own numbers come from runs you can repeat, and everything about the other tools links to where we read it. If we got something wrong, open an issue and we will correct it.

Last checked: 17 October 2026 (UK time) · Cutbolt measured as the 0.4.0 release (tag v0.4.0, e668c16) and as main at ddc77c9 (40 commits later), both built from source · Next check by 16 November 2026, or sooner when one of these tools releases.

The short answer

• You have real footage (interviews, talking heads, tutorials, screen recordings) and want an agent to cut, caption, mix and export it, then revise, retry or undo its edits, on your own machine with no account: Cutbolt. It keeps every edit as a saved revision, and we measured frame-exact cuts and repeatable exports (main fixes a repeatability case that the 0.4.0 release still has). You install FFmpeg yourself, and MCP exports need Windows or Linux (the macOS build can't run them). It is young: version 0.4.0 and 1 GitHub star.
• You want the most tools of the seven compared here (203), in Python, with quality gates, receipts and optional AI extras (transcription, upscaling, HTML graphics): Kinocut, with 206 GitHub stars and regular releases.
• You want quick one-off jobs (trim, convert, make a GIF, burn in subtitles, even out loudness) from one npx line, with FFmpeg fetched for you: claudeclip.
• You want to make new videos, such as motion graphics, explainers or launch videos, rather than edit footage: HyperFrames. It installs as a Claude Code plugin and a CLI; its MCP connector is hosted by HeyGen and needs a HeyGen account.
• Your footage lives in Video Jungle, or you want hosted search and edits with a hand-off to DaVinci Resolve Studio: Video Jungle MCP, with a Video Jungle account and API key.
• Vlexor and video-edit-mcp: on 17 October Vlexor's package could not be installed as its README says, and its site said it was being rebuilt; video-edit-mcp has had no commits since July 2025. Check both before you rely on them.

Side by side

Cutbolt's column is measured or taken from its own docs. The other columns are from each project's README, docs and source at the commit named under Sources, or from its own web pages, read on 17 October 2026, not run by us. Tool counts for the others are counted in their source.

What we measured on Cutbolt

On 17 October 2026, on one machine: Windows 11 Pro (build 26200), an AMD Ryzen 9 7950X3D, Rust 1.98.1, FFmpeg 7.0 (the gyan.dev full build), no GPU work. We built two versions from source with cargo build --release --locked: the 0.4.0 release (tag v0.4.0, e668c16, 1 min 45 s), which is what the release downloads and the MCP Registry entry ship, and main at ddc77c9 (1 min 53 s), 40 commits later (0.4.0 build, main build). We drove each over MCP stdio from a small Python client, the way an agent's MCP client does. Every result below held on both builds unless it says otherwise.

• Tests (main): cargo test --release --locked passed 261 of 261 Rust tests in 10.8 s (output, compile lines removed). Cutbolt's own check of the recipes in its six agent skills, python -X utf8 tools/verify.py --only skills --no-rust --engine target/release/cutbolt, passed in 33 s (output, temporary path removed); its installation guide says this check runs every JSON request in the skills against synthetic footage. We didn't re-run its longer acceptance suite, or the tests on 0.4.0.
• MCP tools: both builds list 18 tools by default: session create, get, apply, undo, history and receipt; job start, wait, status, cancel and resume; schema; files list; media inspect; timeline check; cache inspect and prune; and cutbolt_run, which runs the other 69 commands by name. The tools/list reply is 21,198 bytes on 0.4.0 and 22,726 on main. mcp --tools full lists all 86 tools directly, in 235,843 and 240,088 bytes (lists: 0.4.0 default and full, main default and full).
• The test clip: 10 s of 1280×720, 30 fps H.264 (High, 4:2:0) with stereo 48 kHz AAC, made with FFmpeg so that every frame has its own flat colour. Reading a frame's colour back gives its source frame number, so we could check every exported frame independently of Cutbolt.
• The edit, over MCP: inspect the clip; create a saved project keeping source seconds 0–3 and 5–8, picture and sound linked (6 s); preview the frame at 3 s; ripple-delete timeline seconds 1–2 (5 s); send that same edit request again; preview the frame at 1 s; export H.264/AAC twice and a lossless reference once; undo; export again. We ran it three times per build, each in a new folder. Median times on main: inspect 535 ms, create 14 ms, the ripple delete 6 ms, the resent request 1 ms, undo 7 ms, a frame preview 311–374 ms, an H.264 export of the 5-second cut 1.9–2.0 s from queueing the job to its finished receipt, and 3.3 s for the lossless one. On 0.4.0 the session calls were within 0.5 ms of these, and inspection, previews and exports within 4%.
• Frame-exact: in all six runs, the 150 frames of every export of the cut were source frames 0–29, 60–89 and 150–239, in order, with none missing or repeated; after undo, the 180 exported frames were 0–89 and 150–239. Both previews showed the right source frame (150 and 60). Each MP4's AAC track lasted exactly as long as its picture: 5.000 s and 6.000 s.
• Safe retries: resending the identical edit request, with the same request ID, returned its original receipt and revision 1, and the saved project stayed at revision 1 rather than applying the cut twice. Cutbolt's docs say the same ID with different arguments is refused, and a new ID is a new edit.
• Undo: session.undo saved revision 2, identical to revision 0 apart from its number, and session.history listed all three revisions.
• Repeatable exports: on the colour-coded clip, all 12 H.264 exports of the cut (two per run, three runs per build) had the same SHA-256. Because flat colours are easy for an encoder, we repeated the edit twice per build on FFmpeg's moving testsrc2 pattern: within each build, all four H.264 exports were byte-identical, while 0.4.0's bytes differ from main's, because on 14 October main switched x264 to its CPU-independent mode after exports of identical frames from a small moving sample decoded differently (see Cutbolt's limits below). The frames fed to the encoder were the same on both builds. The lossless .mkv files differed byte for byte from run to run, but their decoded pictures and sound did not: FFmpeg's own hash of each run's decoded RGB frames and PCM audio was the same on all six runs, and equal to the hashes in Cutbolt's H.264 receipts of the frames and samples it fed the encoder (hashes). All of this was one FFmpeg build: like Kinocut, Cutbolt doesn't promise identical bytes across FFmpeg builds.
• Source preserved: the source file's SHA-256 was the same before and after every run, and matched the hash Cutbolt reported when it inspected the file.

Data: summary and medians; colour-coded runs on 0.4.0 1, 2, 3 and on main 1, 2, 3; moving-pattern runs on 0.4.0 1, 2 and on main 1, 2 (frame-number checks don't apply to this clip and read false). Scripts: cutbolt_probe.py (the MCP round trip), cutbolt_frame_ids.py (reads frame numbers back) and mcp_session.py (a minimal MCP client).

To repeat it you need Rust, a C compiler and linker (for the bundled SQLite), Python 3 and FFmpeg 7 on PATH. Clone and build Cutbolt, put the three scripts in the Cutbolt folder, then make the clip and run the probe there:

git clone https://github.com/skulitom/Cutbolt
cd Cutbolt
git checkout v0.4.0
cargo build --release --locked
# download cutbolt_probe.py, cutbolt_frame_ids.py and mcp_session.py into this folder
mkdir run1
ffmpeg -f lavfi -i "color=c=black:s=1280x720:r=30:d=10,format=gbrp,geq=r='mod(N\,16)*16+8':g='floor(N/16)*12+8':b='64',scale=out_color_matrix=bt709:out_range=tv,format=yuv420p" -f lavfi -i "sine=frequency=440:sample_rate=48000:duration=10" -ac 2 -c:v libx264 -profile:v high -preset medium -crf 12 -g 30 -bf 2 -colorspace bt709 -color_primaries bt709 -color_trc bt709 -c:a aac -b:a 192k -movflags +faststart run1/source.mp4
python cutbolt_probe.py target/release/cutbolt ffmpeg ffprobe run1 run1-result.json

Use a new folder holding a copy of source.mp4 for each run. To test main, run git checkout ddc77c9 and cargo build --release --locked again. On Windows, use cutbolt.exe and full paths to ffmpeg.exe and ffprobe.exe. With our FFmpeg build the clip hashed 4ded9771…, and the moving pattern ca010470… (both in full in the summary); file hashes match ours only with the same FFmpeg build, while the frame, retry and undo checks and the run-to-run comparisons don't depend on it. For the moving pattern, replace the first input with -f lavfi -i "testsrc2=s=1280x720:r=30:d=10" and use -vf "scale=out_color_matrix=bt709:out_range=tv,format=yuv420p"; then only the hash comparisons apply. The hashes file gives the FFmpeg commands for the decoded-stream hashes.

Each tool, and when to choose it over Cutbolt

Kinocut (formerly mcp-video)

KyaniteLabs/kinocut (PyPI kinocut 1.16.1) is the project that directory listings still show as mcp-video under pastorsimon1798 or KyaniteLabs: those addresses redirect to the same repository, and the mcp-video package on PyPI now just installs Kinocut. It is a Python server whose source registers 203 tools: trimming, merging, effects, overlays, subtitles, audio mixing and loudness, a JSON timeline spec, projects and replayable recipes, OTIO import and export, quality gates, and optional AI tools such as Whisper transcription and upscaling, plus wrappers for HyperFrames. Multi-step workflows write receipts with SHA-256 of each step's inputs and outputs and can resume; its README says rendered bytes may vary across FFmpeg builds. Its FFmpeg tools need no account, but some tools fetch from the network: a video URL given to video_analyze is downloaded with yt-dlp, missing Google Fonts and model weights are downloaded on demand, and image analysis with Claude Vision needs an Anthropic API key. The repository has 5,757 test functions and CI. We read the repository 29 commits after 1.16.1, the version you install.

Choose it when you want the largest tool set compared here (203 tools), in Python, AI extras such as transcription and upscaling, or HTML graphics through HyperFrames, from an active project with a large test suite. Choose Cutbolt when the agent will revise an edit many times: every edit is a saved revision with undo, resending a request with the same ID returns its original receipt instead of applying it again, cuts landed on exact frames in our test (we didn't test Kinocut's), and the default tool list is 18 tools rather than 203.

claudeclip

gulkoa/claudeclip (npm claudeclip 1.2.1) is a TypeScript server with 31 tools that each run one FFmpeg command on a local file: trim (a frame-accurate re-encode or a fast copy), join, speed, resize, crop, convert, GIF, overlays, picture in picture, burning in an SRT or ASS file, EBU R128 loudness, scene and silence detection, and a contact sheet of frames so the agent can see the video. Outputs never overwrite a file and, unless you name one, land next to the input. Installing it downloads an FFmpeg 6.1.1 build through the ffmpeg-static package, and it uses your own FFmpeg when it finds one. It keeps no project or undo history. Its CI runs a smoke test that calls every tool on three operating systems. All its commits so far came from one author on 4 August 2026.

Choose it for quick, single-step jobs from one npx line, especially when you don't have FFmpeg installed. Choose Cutbolt for an edit made of many cuts you will revisit: a saved multi-clip timeline with linked picture and sound (frame-exact in our test), captions from transcripts, and undo.

video-edit-mcp

Aditya2755/video-edit-mcp (PyPI video-edit-mcp 0.1.1) wraps MoviePy 1.0.3 in 34 tools for trimming, merging, speed, overlays, format conversion and audio mixing, and can keep results in memory to chain calls without temporary files. It has no subtitle tools, no loudness normalisation, no tests, and no commits since 30 July 2025. Its download_video tool fetches any URL with yt-dlp, text overlays need ImageMagick, and outputs go to ~/Downloads/video_mcp_output unless you set VIDEO_MCP_OUTPUT_DIR. The code on GitHub now serves MCP over HTTP, while the 0.1.1 package on PyPI uses stdio.

Choose it if you want MoviePy in Python, chaining operations in memory without temporary files, or a URL download tool, and you're prepared to maintain a fork (no commits since July 2025). Choose Cutbolt for an actively developed engine with tests, captions, loudness and saved, undoable edits.

Video Jungle MCP (burningion/video-editing-mcp)

burningion/video-editing-mcp (PyPI video-editor-mcp 0.1.59) connects an agent to Video Jungle, a hosted video service: uploading videos, searching them by what is said, generating edits, and rendering them on Video Jungle's servers. It needs a Video Jungle account and API key. Its edit-locally tool downloads an edit's assets, builds an OTIO timeline and imports it into DaVinci Resolve Studio, which must already be running. At startup it downloads the jina-clip-v1 model from Hugging Face and runs that model's own code, and it opens Video Jungle's web app in your browser after edits. The repository has no licence file.

Choose it when your footage is in Video Jungle, or you want hosted search across your videos and a hand-off to DaVinci Resolve Studio. Choose Cutbolt when footage must stay on your machine, with no account, no browser and no desktop app in the loop.

Vlexor MCP

Open2Loop/vlexor-mcp has 6 tools. Its generate_edit_plan sends your instruction (and any transcript) to Vlexor's hosted engine, which counts against your plan's usage; compile_edit_plan and render then build and run an FFmpeg command on your machine, with burned-in captions as an option. It needs a Vlexor API key to start. On 17 October 2026 the package its README tells you to run, @velxor/mcp, returned 404 on npm, the repository depends on private packages and can't be built on its own, Vlexor's home page said it was being rebuilt, and its pricing page returned 404. Its terms describe Pro, Pro+ and Max plans with monthly caps on AI-editing minutes.

Choose it, once it can be installed again, for edits planned by a hosted AI from plain-language instructions and rendered locally. Choose Cutbolt for an engine you can install today, with no account or usage limits, where the agent itself decides each edit.

HyperFrames

heygen-com/hyperframes (npm hyperframes 0.8.168, about 65,700 GitHub stars) turns HTML, CSS and JavaScript into video: headless Chrome captures each frame and FFmpeg encodes them. It ships a CLI, 21 agent skills and a Claude Code plugin, with workflows for captions, audio and whole videos. It has no local MCP server for desktop agents: its MCP is a hosted connector, in beta, that needs a HeyGen account and renders on HeyGen's infrastructure, and its Studio app exposes WebMCP tools (an early browser feature) to an agent running in the browser. Its CLI sends usage data to PostHog by default, which you can turn off (hyperframes telemetry disable, HYPERFRAMES_NO_TELEMETRY or DO_NOT_TRACK). It releases almost every day.

Choose it to make new videos (motion graphics, explainers, launch videos, animated captions) from code models already write well, with a large community behind it. Choose Cutbolt to edit footage you recorded: cuts, ripple deletes, linked sound, multicam, OTIO hand-off and loudness, all through a local MCP server. The two can work together: Cutbolt's command line can compile a rendered PNG sequence with transparency into a lossless movie (image.sequence.compile, not an MCP tool), and an alpha_over track places it over your footage; on main, a transparent ProRes file can be placed through automatic preparation.

Cutbolt's limits

• It edits footage you already have. It doesn't generate video from a prompt, and it has no visual timeline for editing by hand: an agent, JSON commands or the Rust library drive it.
• FFmpeg and ffprobe must already be installed; Cutbolt neither bundles nor downloads them.
• Windows and Linux are its tested platforms. The macOS (Apple silicon) build exists, but background jobs, which MCP exports go through, need Windows or Linux, and native audio recording and hardware decoding need Windows.
• Footage goes on the timeline as it is only when it is even-sized, 8-bit 4:2:0 H.264 or HEVC at the project's exact size and frame rate; other formats are converted first. On main (since 13 October) a queued export does that automatically; in the 0.4.0 release you prepare them explicitly first. The timeline works in 8-bit SDR by default, and anything outside its documented limits fails with an error rather than a guess.
• In the 0.4.0 release, repeated H.264 exports of the same frames can occasionally differ: Cutbolt's own 0.4.0 notes record an open, intermittent difference, and on 14 October eight encodes of a small moving sample with its settings gave three different results. main fixed this that day by switching x264 to its CPU-independent mode. Our 0.4.0 runs didn't hit it.
• Speech recognition, for cutting your own recordings by transcript, is optional and needs a separately installed Python and model setup; its tested setup used WSL and an NVIDIA GPU. Without it, transcript edits need a transcript you supply.
• It is young: version 0.4.0 (12 October 2026), 1 GitHub star, not on crates.io. Install it from the release archives or from source. It is in the official MCP Registry as io.github.skulitom/cutbolt.

Also in the results, plus two we added

• NIRA Video MCP (PyPI nira-video-mcp 1.0.3, May 2026): its README lists 55 tools: FFmpeg-based editing, grading, audio and delivery, plus 5 AI video generation tools (fal.ai with your key, or Wan2GP on your own GPU) that need a US$49 one-time PRO licence key, which also unlocks HLS export and thumbnail sprites. Its GitHub repository and account returned 404 on 17 October 2026, so we didn't read its code: it is only in the PyPI package, which we didn't download.
• VideoDB Director MCP (video-db/agent-toolkit, PyPI videodb-director-mcp 0.1.7): 4 tools. call_director passes requests to VideoDB's hosted Director agents, two tools fetch VideoDB's docs, and one opens a video in your browser. It needs a VideoDB API key, and the repository has no licence file.
• Intelligence08/video-editing-mcp, which ranked twice for "local video editing MCP server": it describes itself as an "MCP Interface for Video Jungle" and has almost the same files as Video Jungle MCP above; 0 stars, no licence file, last push July 2025.
• OpenClip: a hosted MCP server for turning long videos into clips, signed in with OAuth; new accounts start with 0 processing credits, and plans start at US$14.99 a month, billed monthly. Its own "Best Video Editing MCP Servers in 2026" page ranked for one of our searches.
• OpusClip: a hosted MCP server (clip, caption, reframe, edit, repurpose, schedule posts), signed in with an OpusClip account. Its MCP page offers a free trial, then a Pro plan with metered per-render-minute pricing; its pricing page lists a free plan (60 credits a month, watermark, no editing), Starter at US$15 a month and Pro at US$29 a month (US$14.50 a month billed annually).
• An Adobe Premiere Pro MCP server was named in one search summary. The most starred one we found, hetpatel-11/Adobe_Premiere_Pro_MCP (712 stars, MIT), drives Premiere Pro; we didn't read it further.
• Not in these searches, added for their stars: DaVinci Resolve MCP (about 3,600 stars, MIT) drives a running DaVinci Resolve 18.5 or later through its scripting API; choose it when you edit in Resolve yourself and want an agent to help there. video-creator/ffmpeg-mcp (153 stars, MIT) has 8 FFmpeg tools, runs on macOS only, downloads FFmpeg binaries at run time from personal Gitee repositories, and plays video in an ffplay window.

Method

• The searches this page answers, run on 17 October 2026: "local video editing MCP server", "MCP server for video editing local ffmpeg agent" and "best video editing MCP server for Claude Code". Directory pages (Glama, Enterprise DNA, mcpservers.org and others) filled most results, with two vendors' own pages (OpenClip and OpusClip). One summary said it found no independent head-to-head comparison. Cutbolt appeared in none.
• Which tools: mcp-video (now Kinocut) and Vlexor, which ranked for the second search; HyperFrames, the most starred video tool for agents we know of; and claudeclip, video-edit-mcp and Video Jungle MCP, which ranked or were named in the results. The other results, and two servers we added for their stars, are under "Also in the results".
• Cutbolt was built and tested as described above, from fresh clones of its 0.4.0 tag and main.
• The other tools were not installed or run. We run another tool only when it is open source from its official source, works offline with no account or key, and can't reach the network or your desktop. Only claudeclip met all three; its installation downloads an FFmpeg binary from a third-party release, so we read its code instead of installing it, and we didn't test its cuts. Kinocut, video-edit-mcp and HyperFrames can fetch from the web, Video Jungle MCP and Vlexor need accounts and keys, and Vlexor's package couldn't be installed. We read each README, the files named below and the hosted services' own pages, and counted MCP tools in each server's source. Stars, releases and package versions come from GitHub, PyPI and npm on 17 October 2026.

Sources

All read on 17 October 2026, at the commit shown.

• Kinocut at 939aecc: README, pyproject.toml, docs/ENTERPRISE.md, kinocut/ (203 @mcp.tool registrations in server_tools_*.py), ai_engine/download.py, font_manager.py, image_engine.py; PyPI kinocut and mcp-video (the release, 1.16.1, is 29 commits behind 939aecc).
• claudeclip at 045b32b: README, package.json, src/ffmpeg.ts, src/tools/ (31 tools), test/smoke.mjs; npm claudeclip; ffmpeg-static's install.js at 5d17f62 (the FFmpeg download).
• video-edit-mcp at 6338987: README, pyproject.toml, src/video_edit_mcp/ (34 tools; main.py, download_utils.py, utils.py); PyPI video-edit-mcp.
• Video Jungle MCP at fbe06dc: README, pyproject.toml, src/video_editor_mcp/server.py (tools, model download, browser), generate_opentimeline.py; PyPI video-editor-mcp.
• Vlexor MCP at 5ef1c39: README, package.json, src/config.ts, src/api-client.ts, src/tools/ (6 tools); npm registry entry for @velxor/mcp (404); Vlexor's home page ("being rebuilt"), its pricing page (404) and terms.
• HyperFrames at b18b3e9: README, docs/guides/mcp.mdx (hosted connector), docs/guides/webmcp.mdx, packages/cli/src/telemetry/config.ts, packages/cli/src/browser/manager.ts (Chrome download); npm hyperframes.
• Also: PyPI nira-video-mcp; video-db/agent-toolkit at 8a7a6f4; OpenClip's MCP page and pricing and comparison page; OpusClip's MCP page and pricing; davinci-resolve-mcp at 90eba8c; ffmpeg-mcp at c2a9ab7; Intelligence08/video-editing-mcp; hetpatel-11/Adobe_Premiere_Pro_MCP.
• Cutbolt at ddc77c9: README, llms.txt, agent interface, track edits, captions, export, tracks (overlays), export repeatability record, 0.4.0's direct sources notes (the open H.264 comparison), direct sources, automatic preparation, multicam, OTIO interchange, image sequences, installation, dependencies, Cargo.lock; the 0.4.0 release (e668c16); and this page's data: MCP round trip summary, independent hashes, tests, skill recipes.