A real video editor, drivable by any agent.
An MCP server with an immutable timeline, a journaled edit history, and
an FFmpeg/MLT render engine. One process, one port —
/mcp for agents, /projects for people.
Say it in a sentence. Get a journaled edit.
No plugin, no screen-scraping, no "describe your video and hope". The agent calls the same named operations the editor's own buttons call — and every one of them lands in a history you can read and undo.
Grab that YouTube talk at 1080p, cut the first 8 seconds of throat-clearing, and put the title over the opening.
Imported talk.mp4 (12:41). Trimmed 0.0–8.0s and added a title over 0.0–3.2s. Project is at v4 — preview is ready.
Too long. Undo the title and make it 2s.
Undone to v3, re-added over 0.0–2.0s. Now at v5.
- v2editor_import_urlquality=1080p
- v3editor_trim_clipstart=8.0
- v4editor_add_text0.0 → 3.2undone
- v5editor_add_text0.0 → 2.0
Append-only. v4 is still on disk — undo moved the head, it did not erase the past.
One logic layer, three surfaces.
For agents. The full editing tool set over streamable-HTTP,
bearer-authenticated. editor_create_project, add/trim/
reorder clips, preview, export.
For people. A CapCut-class editor — drag, trim, split, undo/redo, annotations, export — over the same ops.
For files. Exports, preview frames and keyframe strips — served only to the account that owns them. Nothing here mutates.
Same immutable model, same journaled ops — a file dragged in by a human and one registered by an agent are indistinguishable downstream.
And when you want the mouse back.
Open the project the agent just built and keep cutting by hand. Drag, trim, split, nudge, undo — direct manipulation over the very same ops, so nothing you do is invisible to the agent and nothing it did is locked away from you.
A mock of the editor, playing on a loop: a project bar with undo, validate and export; a media rail; a preview; an inspector; and a three-track timeline. The playhead sweeps the timeline, a title lands on the text track, and a clip is split under the playhead — the version counter stepping from v3 to v5 as it goes.Drag · trim · split
Grab an edge, pull it. Scissors cut a range out and close the gap.
Undo anything
Yours and the agent's edits sit in one history. Step back through both.
Validate, then export
Structural checks run before the render — you find out now, not 4 minutes in.
Paste a URL
A link to a platform video is fetched at the quality you pick, with live progress.
Importing by URL is for content you hold the rights to use — following the source platform's own terms is on you, not the service.
What it does.
Immutable timeline
Frozen-dataclass project; every edit returns a new version, never mutates in place.
Journaled history
Append-only op journal; every mutation kept forever, replay the full edit history.
Two render engines
One contract, two backends: FFmpeg filter_complex and an MLT/melt pipeline.
Two-tier validation
structural checks guard the render; opt-in shorts checks enforce editorial bounds.
Compare-and-swap edits
Version-checked ops; a stale write gets a 409, never a silent clobber.
Clips · Text · Audio · Overlays
Four element kinds, four colors, one timeline.
From one call to a rendered frame.
Call an op
An agent or human issues one named operation.
Journal it
The op is appended to the immutable history; version + 1.
Validate
Structural (and optional shorts) checks run before any pixels.
Render
FFmpeg or MLT resolves the timeline to a truthful MP4/frame.
Every gesture ends in exactly one named, journaled op. The client never merges partial state — it replaces its snapshot with the server's.
Point your client at one endpoint.
{
"mcpServers": {
"mcpcut": {
"url": "https://mcpcut.com/mcp",
"transport": "streamable-http",
"headers": { "Authorization": "Bearer <your-token>" }
}
}
}
Streamable-HTTP, bearer-authenticated. Mint a token, drop the block
into any MCP client — Claude, IDE agents, or your own scripts — and
call editor_create_project.