Skip to main content
Glama

OpenEdit

Edit video by talking to Claude. OpenEdit is a free, open-source, fully local AI editing toolkit. Claude Code drives it through MCP, and it edits in Adobe Premiere Pro, DaVinci Resolve, or with no editor at all (straight to a finished file with ffmpeg).

No subscription, no account, no upload. Your footage never leaves your machine.

you:     "cut the silences and ums, add bold captions, punch in on key moments, make it 9:16"
claude:  transcribe -> plan_cuts -> (shows you the plan) -> apply_cuts -> make_captions -> auto_zooms -> render

What it does

Feature

How

Jump cuts / silence removal

ffmpeg silencedetect + padding and merge rules

Filler-word removal ("um", "uh", "you know"...)

word-level transcript from local whisper.cpp

Retake detection

finds restarted sentences and keeps the last attempt

Captions

word-timed SRT / VTT / ASS, imported as a caption track, or burned in with animated styles (bold-pop, karaoke, clean, minimal)

Zooms / punch-ins

scale keyframes (Premiere), static zoom (Resolve), zoompan (standalone); auto_zooms places them for you

B-roll, music, SFX

place_clips on new tracks, gain in dB, music ducking under speech (standalone)

Motion graphics

7 animated templates rendered with transparent backgrounds via HyperFrames: title card, lower third, callout, subscribe, counter, quote, chapter

Reframe

9:16, 1:1, 16:9

Loudness

EBU R128 loudnorm

Markers

coloured sequence markers for review

Edits are non-destructive: cut plans always build a new sequence/timeline next to your original.

Related MCP server: Premiere-MCP-BuildX-Exclusive-V3

Why it's different

Most "AI editor" plugins are a thin panel that loads a remote web app and sends your work through a paid server. OpenEdit is the opposite:

  • Claude is the brain. The tools are small and precise; Claude reads the transcript, decides what to cut, and shows you the plan before touching your timeline.

  • Local. Transcription runs on whisper.cpp on your machine. Nothing is uploaded.

  • Three hosts, one workflow. The same tools work in Premiere, Resolve, or standalone.

  • Open. MIT licensed. Read it, fork it, add tools.

Install

Requirements: Node 22+, ffmpeg, whisper.cpp (whisper-cli).

brew install ffmpeg whisper-cpp
git clone https://github.com/Davdadev/openedit.git && cd openedit
npm install && npm run build
claude mcp add openedit -- node "$PWD/dist/cli.js"
node dist/cli.js doctor

The first transcription downloads the whisper model (base, ~140 MB) to ~/.openedit/models. The first motion-graphics render fetches HyperFrames and a headless Chrome.

Premiere Pro (optional)

./premiere/install.sh

Restart Premiere, then open Window > Extensions > OpenEdit. The panel listens on 127.0.0.1:47821 with a token in ~/.openedit/token. See premiere/README.md.

DaVinci Resolve (optional)

./resolve/install.sh

In Resolve: Preferences > System > General > External scripting using: Local, then restart. See resolve/README.md.

With neither editor open, OpenEdit uses the standalone ffmpeg host automatically. Force one with OPENEDIT_HOST=premiere|resolve|standalone.

Use

In Claude Code, just ask:

  • "Clean up ~/Videos/talk.mp4: remove silences and filler words, show me the plan first."

  • "Add bold-pop captions and auto zooms, then render a 9:16 version for Shorts."

  • "Make a lower third for 'Dana Lee — Product Lead' at 0:04 and put it on V3."

  • "Drop ~/sfx/whoosh.wav at every chapter marker at -6 dB."

The auto_edit MCP prompt walks Claude through the standard workflow.

Tools

editor_status · select_host · get_timeline · probe_media · transcribe · find_silences · plan_cuts · show_plan · apply_cuts · make_captions · add_markers · add_zooms · auto_zooms · import_media · place_clips · render · motion_templates · render_motion · render_caption_overlay

Architecture

Claude Code ──MCP stdio──> openedit (Node/TS)
                             ├─ engine/   ffprobe, whisper.cpp, silencedetect, cut plans, captions, ffmpeg render
                             ├─ motion/   HyperFrames templates -> ProRes 4444 / VP9 alpha overlays
                             └─ hosts/
                                 ├─ standalone  (ffmpeg, in-process)
                                 ├─ premiere ──HTTP 127.0.0.1:47821──> CEP panel ──evalScript──> ExtendScript
                                 └─ resolve  ──JSON over stdio──> python bridge ──> DaVinciResolveScript

The bridge protocol is in docs/PROTOCOL.md; shared types are in src/hosts/types.ts.

Development

npm test
node premiere/test/mock-test.mjs
python3 -m unittest discover -s resolve/test
npm run test:motion

Status

v0.1. The engine, standalone host and motion graphics are tested end to end. The Premiere and Resolve bridges are tested against simulated hosts but not yet against the real apps: please open an issue with what you see.

Known limits: Resolve's scripting API has no keyframes, so zooms there are static; captions fall back to markers if a host refuses the SRT import; burn-in captions without HyperFrames need an ffmpeg built with libass.

License

MIT. HyperFrames is Apache-2.0 (used as an optional dependency, not vendored).

Available Tools

19 tools
add_markersA

Add sequence markers (edited-timeline seconds), e.g. chapter points, highlights, or notes for the user.

Inputs: markers (required).

add_zoomsA

Add zoom/punch-in effects on the main camera over edited-timeline ranges (for emphasis or to hide jump cuts).

Inputs: zooms (required).

apply_cutsA

Apply a cut plan in the active editor. Premiere/Resolve: creates a NEW sequence with only the kept ranges (original untouched). Standalone: sets the timeline that render will export.

Inputs: planId (required), sequenceName.

auto_zoomsA

Automatic punch-ins for a cut edit: alternates framing between 100% and scale on each kept segment longer than every seconds, so jump cuts feel intentional. Adds them to the active editor.

Inputs: planId (required), every, scale.

editor_statusA

Show which video editor OpenEdit is driving (premiere, resolve, or standalone ffmpeg), whether it is connected, and the active project/sequence. Call this first.

Inputs: no named parameters.

find_silencesB

Find silent/dead-air ranges in a file's audio (ffmpeg silencedetect).

Inputs: path, minDuration, thresholdDb.

get_timelineA

List the clips, tracks and markers of the active sequence/timeline in the current editor.

Inputs: no named parameters.

import_mediaB

Import media files into the editor's project (bin "OpenEdit"). In standalone mode, the first video imported becomes the timeline source.

Inputs: paths (required).

make_captionsA

Create captions from the transcript and add them to the active editor. Pass planId to time captions to the CUT edit (use the same plan you applied), or path for an uncut file. Writes .srt, .vtt and .ass files. Styles: clean (white with outline), bold-pop (big uppercase, active word highlighted), minimal (small boxed).

Inputs: path, model, style, planId, +3 more.

motion_templatesA

List motion-graphics templates (titles, lower thirds, callouts…) and their parameters for render_motion.

Inputs: no named parameters.

place_clipsB

Place clips on the timeline at edited-timeline times: b-roll/images on upper video tracks (track 2+), music and sound effects on audio tracks. Standalone extras: duration (images), duckDb (lower music under speech by ~N dB), loop, fadeOut.

Inputs: clips (required).

plan_cutsA

Build a cut plan (which parts of the source to keep) from silences, filler words (um/uh…), retakes (restarted sentences) and your own manualCuts chosen from the transcript. Nothing is changed in the editor yet: returns a planId and a summary to review with the user, then call apply_cuts.

Inputs: path, model, minKeep, padding, +8 more.

probe_mediaA

Get duration, resolution, frame rate and audio/video presence of a media file.

Inputs: path (required).

renderA

Export the edited timeline to a file. Standalone: one ffmpeg pass with cuts, zooms, b-roll, music, captions, optional vertical reframe and loudness normalisation. Premiere/Resolve: queues the editor's own export (reframe/burnCaptions/loudnorm are standalone-only).

Inputs: output (required), preset, reframe, loudnorm, +1 more.

render_caption_overlayB

Render animated captions as a transparent video overlay (.mov with alpha) that can be placed over the edit in any editor. Use planId to time it to the cut edit.

Inputs: fps, path, model, style, +7 more.

render_motionC

Render a motion-graphics template to a video file (.mov with alpha by default) and optionally place it on the timeline at placeAt (edited seconds).

Inputs: template (required), fps, track, width, +5 more.

select_hostA

Choose the editor to drive: "premiere" (needs the OpenEdit panel open in Premiere Pro), "resolve" (DaVinci Resolve running with scripting enabled), "standalone" (no editor; edits are rendered with ffmpeg), or "auto" to re-detect.

Inputs: host (required).

show_planB

Show every cut in a plan with what was said in it, plus the kept segments, for review before applying.

Inputs: planId (required).

transcribeA

Transcribe speech locally with whisper.cpp (word-level timestamps). Returns the transcript as lines prefixed with [mm:ss.s] start times, plus the path of the full word-level JSON. Cached per file+model. If path is omitted, uses the active timeline's source media.

Inputs: path, model, language.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 19 tools

    Disambiguation4/5

    Most tools target a clearly distinct step of the editing pipeline (inspect → transcribe → plan → apply → embellish → render), and descriptions explicitly disambiguate close pairs like add_zooms vs auto_zooms and render vs render_motion. The only mild overlap is around captions (make_captions adds captions in the editor, render_caption_overlay bakes a transparent overlay video), which descriptions mostly resolve but an agent could still pause over.

    Naming Consistency4/5

    The dominant pattern is consistent snake_case verb_noun (find_silences, plan_cuts, apply_cuts, add_markers, place_clips, import_media). A few deviations exist — verb-only names (transcribe, render) and noun-only names (editor_status, motion_templates) — but they remain readable and predictable within the set.

    Tool Count4/5

    19 tools is on the heavy side but each maps to a distinct capability in a genuinely broad workflow (editor selection, analysis, cut planning, captions, zooms, media placement, rendering, motion graphics). Nothing looks redundant enough to be a filler tool, though a couple of render variants push the surface toward the upper bound.

    Completeness4/5

    The lifecycle is well covered end-to-end: session/host setup, media probing, transcription, silence/filler analysis, plan review, cut application, captions, markers, zooms, b-roll/music placement, and both editor-queued and standalone rendering. Minor gaps remain: no way to undo/revert an applied cut or remove markers/zooms, and no tool to list or delete previously created plans.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Valmera, the world’s most advanced AI video editor, edits your recorded footage through Claude, ChatGPT or another MCP client. Place your own B-roll on a spoken word, correct a caption, cut or reframe a shot, review the preview and export an MP4. Watch both four-second edits in the README. Hosted editing requires an eligible paid Valmera plan.
      MIT
    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML, covering trimming, splitting, silence removal, markers, transcript-based editing, keyframes and speed ramps, cross-NLE export, and pushing edits into a running Final Cut Pro. Every write is journaled with its sha256 and reversible, and timelines can be rendered visually for review before delivery.
      -